Bitcoin Core 31.99.0
P2P Digital Currency
argsman_tests.cpp
Go to the documentation of this file.
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
23using util::ToString;
24
25BOOST_FIXTURE_TEST_SUITE(argsman_tests, BasicTestingSetup)
26
27BOOST_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
52struct 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
70class CheckValueTest : public TestChain100Setup
71{
72public:
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
155BOOST_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
174struct 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
186BOOST_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
193BOOST_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());
208 BOOST_CHECK(s.ro_config.empty());
209 });
210
211 BOOST_CHECK(testArgs.ParseParameters(1, argv_test, error));
212 testArgs.LockSettings([&](const common::Settings& s) {
213 BOOST_CHECK(s.command_line_options.empty());
214 BOOST_CHECK(s.ro_config.empty());
215 });
216
217 BOOST_CHECK(testArgs.ParseParameters(7, argv_test, error));
218 // expectation: -ignored is ignored (program name argument),
219 // -a, -b and -ccc end up in map, -d ignored because it is after
220 // a non-option argument (non-GNU option parsing)
221 BOOST_CHECK(testArgs.IsArgSet("-a"));
222 BOOST_CHECK(testArgs.IsArgSet("-b"));
223 BOOST_CHECK(testArgs.IsArgSet("-ccc"));
224 BOOST_CHECK(!testArgs.IsArgSet("f"));
225 BOOST_CHECK(!testArgs.IsArgSet("-d"));
226 testArgs.LockSettings([&](const common::Settings& s) {
227 BOOST_CHECK(s.command_line_options.size() == 3);
228 BOOST_CHECK(s.ro_config.empty());
229 BOOST_CHECK(s.command_line_options.contains("a"));
230 BOOST_CHECK(s.command_line_options.contains("b"));
231 BOOST_CHECK(s.command_line_options.contains("ccc"));
232 BOOST_CHECK(!s.command_line_options.contains("f"));
233 BOOST_CHECK(!s.command_line_options.contains("d"));
234
235 BOOST_CHECK(s.command_line_options.at("a").size() == 1);
236 BOOST_CHECK(s.command_line_options.at("a").front().get_str() == "");
237 BOOST_CHECK(s.command_line_options.at("ccc").size() == 2);
238 BOOST_CHECK(s.command_line_options.at("ccc").front().get_str() == "argument");
239 BOOST_CHECK(s.command_line_options.at("ccc").back().get_str() == "multiple");
240 });
241 BOOST_CHECK(testArgs.GetArgs("-ccc").size() == 2);
242}
243
244BOOST_AUTO_TEST_CASE(util_ParseInvalidParameters)
245{
246 TestArgsManager test;
247 test.SetupArgs({{"-registered", ArgsManager::ALLOW_ANY}});
248
249 const char* argv[] = {"ignored", "-registered"};
250 std::string error;
251 BOOST_CHECK(test.ParseParameters(2, argv, error));
252 BOOST_CHECK_EQUAL(error, "");
253
254 argv[1] = "-unregistered";
255 BOOST_CHECK(!test.ParseParameters(2, argv, error));
256 BOOST_CHECK_EQUAL(error, "Invalid parameter -unregistered");
257
258 // Make sure registered parameters prefixed with a chain type trigger errors.
259 // (Previously, they were accepted and ignored.)
260 argv[1] = "-test.registered";
261 BOOST_CHECK(!test.ParseParameters(2, argv, error));
262 BOOST_CHECK_EQUAL(error, "Invalid parameter -test.registered");
263}
264
265static void TestParse(const std::string& str, bool expected_bool, int64_t expected_int)
266{
267 TestArgsManager test;
268 test.SetupArgs({{"-value", ArgsManager::ALLOW_ANY}});
269 std::string arg = "-value=" + str;
270 const char* argv[] = {"ignored", arg.c_str()};
271 std::string error;
272 BOOST_CHECK(test.ParseParameters(2, argv, error));
273 BOOST_CHECK_EQUAL(test.GetBoolArg("-value", false), expected_bool);
274 BOOST_CHECK_EQUAL(test.GetBoolArg("-value", true), expected_bool);
275 BOOST_CHECK_EQUAL(test.GetIntArg("-value", 99998), expected_int);
276 BOOST_CHECK_EQUAL(test.GetIntArg("-value", 99999), expected_int);
277}
278
279// Test bool and int parsing.
280BOOST_AUTO_TEST_CASE(util_ArgParsing)
281{
282 // Some of these cases could be ambiguous or surprising to users, and might
283 // be worth triggering errors or warnings in the future. But for now basic
284 // test coverage is useful to avoid breaking backwards compatibility
285 // unintentionally.
286 TestParse("", true, 0);
287 TestParse(" ", false, 0);
288 TestParse("0", false, 0);
289 TestParse("0 ", false, 0);
290 TestParse(" 0", false, 0);
291 TestParse("+0", false, 0);
292 TestParse("-0", false, 0);
293 TestParse("5", true, 5);
294 TestParse("5 ", true, 5);
295 TestParse(" 5", true, 5);
296 TestParse("+5", true, 5);
297 TestParse("-5", true, -5);
298 TestParse("0 5", false, 0);
299 TestParse("5 0", true, 5);
300 TestParse("050", true, 50);
301 TestParse("0.", false, 0);
302 TestParse("5.", true, 5);
303 TestParse("0.0", false, 0);
304 TestParse("0.5", false, 0);
305 TestParse("5.0", true, 5);
306 TestParse("5.5", true, 5);
307 TestParse("x", false, 0);
308 TestParse("x0", false, 0);
309 TestParse("x5", false, 0);
310 TestParse("0x", false, 0);
311 TestParse("5x", true, 5);
312 TestParse("0x5", false, 0);
313 TestParse("false", false, 0);
314 TestParse("true", false, 0);
315 TestParse("yes", false, 0);
316 TestParse("no", false, 0);
317}
318
319BOOST_AUTO_TEST_CASE(util_GetBoolArg)
320{
321 TestArgsManager testArgs;
322 const auto a = std::make_pair("-a", ArgsManager::ALLOW_ANY);
323 const auto b = std::make_pair("-b", ArgsManager::ALLOW_ANY);
324 const auto c = std::make_pair("-c", ArgsManager::ALLOW_ANY);
325 const auto d = std::make_pair("-d", ArgsManager::ALLOW_ANY);
326 const auto e = std::make_pair("-e", ArgsManager::ALLOW_ANY);
327 const auto f = std::make_pair("-f", ArgsManager::ALLOW_ANY);
328
329 const char *argv_test[] = {
330 "ignored", "-a", "-nob", "-c=0", "-d=1", "-e=false", "-f=true"};
331 std::string error;
332 testArgs.SetupArgs({a, b, c, d, e, f});
333 BOOST_CHECK(testArgs.ParseParameters(7, argv_test, error));
334
335 // Each letter should be set.
336 for (const char opt : "abcdef")
337 BOOST_CHECK(testArgs.IsArgSet({'-', opt}) || !opt);
338
339 // Nothing else should be in the map
340 testArgs.LockSettings([&](const common::Settings& s) {
341 BOOST_CHECK(s.command_line_options.size() == 6);
342 BOOST_CHECK(s.ro_config.empty());
343 });
344
345 // The -no prefix should get stripped on the way in.
346 BOOST_CHECK(!testArgs.IsArgSet("-nob"));
347
348 // The -b option is flagged as negated, and nothing else is
349 BOOST_CHECK(testArgs.IsArgNegated("-b"));
350 BOOST_CHECK(!testArgs.IsArgNegated("-a"));
351
352 // Check expected values.
353 BOOST_CHECK(testArgs.GetBoolArg("-a", false) == true);
354 BOOST_CHECK(testArgs.GetBoolArg("-b", true) == false);
355 BOOST_CHECK(testArgs.GetBoolArg("-c", true) == false);
356 BOOST_CHECK(testArgs.GetBoolArg("-d", false) == true);
357 BOOST_CHECK(testArgs.GetBoolArg("-e", true) == false);
358 BOOST_CHECK(testArgs.GetBoolArg("-f", true) == false);
359}
360
361BOOST_AUTO_TEST_CASE(util_GetBoolArgEdgeCases)
362{
363 // Test some awful edge cases that hopefully no user will ever exercise.
364 TestArgsManager testArgs;
365
366 // Params test
367 const auto foo = std::make_pair("-foo", ArgsManager::ALLOW_ANY);
368 const auto bar = std::make_pair("-bar", ArgsManager::ALLOW_ANY);
369 const char *argv_test[] = {"ignored", "-nofoo", "-foo", "-nobar=0"};
370 testArgs.SetupArgs({foo, bar});
371 std::string error;
372 BOOST_CHECK(testArgs.ParseParameters(4, argv_test, error));
373
374 // This was passed twice, second one overrides the negative setting.
375 BOOST_CHECK(!testArgs.IsArgNegated("-foo"));
376 BOOST_CHECK(testArgs.GetArg("-foo", "xxx") == "");
377
378 // A double negative is a positive, and not marked as negated.
379 BOOST_CHECK(!testArgs.IsArgNegated("-bar"));
380 BOOST_CHECK(testArgs.GetArg("-bar", "xxx") == "1");
381
382 // Config test
383 const char *conf_test = "nofoo=1\nfoo=1\nnobar=0\n";
384 BOOST_CHECK(testArgs.ParseParameters(1, argv_test, error));
385 testArgs.ReadConfigString(conf_test);
386
387 // This was passed twice, second one overrides the negative setting,
388 // and the value.
389 BOOST_CHECK(!testArgs.IsArgNegated("-foo"));
390 BOOST_CHECK(testArgs.GetArg("-foo", "xxx") == "1");
391
392 // A double negative is a positive, and does not count as negated.
393 BOOST_CHECK(!testArgs.IsArgNegated("-bar"));
394 BOOST_CHECK(testArgs.GetArg("-bar", "xxx") == "1");
395
396 // Combined test
397 const char *combo_test_args[] = {"ignored", "-nofoo", "-bar"};
398 const char *combo_test_conf = "foo=1\nnobar=1\n";
399 BOOST_CHECK(testArgs.ParseParameters(3, combo_test_args, error));
400 testArgs.ReadConfigString(combo_test_conf);
401
402 // Command line overrides, but doesn't erase old setting
403 BOOST_CHECK(testArgs.IsArgNegated("-foo"));
404 BOOST_CHECK(testArgs.GetArg("-foo", "xxx") == "0");
405 BOOST_CHECK(testArgs.GetArgs("-foo").size() == 0);
406
407 // Command line overrides, but doesn't erase old setting
408 BOOST_CHECK(!testArgs.IsArgNegated("-bar"));
409 BOOST_CHECK(testArgs.GetArg("-bar", "xxx") == "");
410 BOOST_REQUIRE(testArgs.GetArgs("-bar").size() == 1);
411 BOOST_CHECK(testArgs.GetArgs("-bar").front() == "");
412}
413
414BOOST_AUTO_TEST_CASE(util_ReadConfigStream)
415{
416 const char *str_config =
417 "a=\n"
418 "b=1\n"
419 "ccc=argument\n"
420 "ccc=multiple\n"
421 "d=e\n"
422 "nofff=1\n"
423 "noggg=0\n"
424 "h=1\n"
425 "noh=1\n"
426 "noi=1\n"
427 "i=1\n"
428 "sec1.ccc=extend1\n"
429 "\n"
430 "[sec1]\n"
431 "ccc=extend2\n"
432 "d=eee\n"
433 "h=1\n"
434 "[sec2]\n"
435 "ccc=extend3\n"
436 "iii=2\n";
437
438 TestArgsManager test_args;
439 const auto a = std::make_pair("-a", ArgsManager::ALLOW_ANY);
440 const auto b = std::make_pair("-b", ArgsManager::ALLOW_ANY);
441 const auto ccc = std::make_pair("-ccc", ArgsManager::ALLOW_ANY);
442 const auto d = std::make_pair("-d", ArgsManager::ALLOW_ANY);
443 const auto e = std::make_pair("-e", ArgsManager::ALLOW_ANY);
444 const auto fff = std::make_pair("-fff", ArgsManager::ALLOW_ANY);
445 const auto ggg = std::make_pair("-ggg", ArgsManager::ALLOW_ANY);
446 const auto h = std::make_pair("-h", ArgsManager::ALLOW_ANY);
447 const auto i = std::make_pair("-i", ArgsManager::ALLOW_ANY);
448 const auto iii = std::make_pair("-iii", ArgsManager::ALLOW_ANY);
449 test_args.SetupArgs({a, b, ccc, d, e, fff, ggg, h, i, iii});
450
451 test_args.ReadConfigString(str_config);
452 // expectation: a, b, ccc, d, fff, ggg, h, i end up in map
453 // so do sec1.ccc, sec1.d, sec1.h, sec2.ccc, sec2.iii
454
455 test_args.LockSettings([&](const common::Settings& s) {
456 BOOST_CHECK(s.command_line_options.empty());
457 BOOST_CHECK(s.ro_config.size() == 3);
458 BOOST_CHECK(s.ro_config.at("").size() == 8);
459 BOOST_CHECK(s.ro_config.at("sec1").size() == 3);
460 BOOST_CHECK(s.ro_config.at("sec2").size() == 2);
461
462 BOOST_CHECK(s.ro_config.at("").contains("a"));
463 BOOST_CHECK(s.ro_config.at("").contains("b"));
464 BOOST_CHECK(s.ro_config.at("").contains("ccc"));
465 BOOST_CHECK(s.ro_config.at("").contains("d"));
466 BOOST_CHECK(s.ro_config.at("").contains("fff"));
467 BOOST_CHECK(s.ro_config.at("").contains("ggg"));
468 BOOST_CHECK(s.ro_config.at("").contains("h"));
469 BOOST_CHECK(s.ro_config.at("").contains("i"));
470 BOOST_CHECK(s.ro_config.at("sec1").contains("ccc"));
471 BOOST_CHECK(s.ro_config.at("sec1").contains("h"));
472 BOOST_CHECK(s.ro_config.at("sec2").contains("ccc"));
473 BOOST_CHECK(s.ro_config.at("sec2").contains("iii"));
474 });
475
476 BOOST_CHECK(test_args.IsArgSet("-a"));
477 BOOST_CHECK(test_args.IsArgSet("-b"));
478 BOOST_CHECK(test_args.IsArgSet("-ccc"));
479 BOOST_CHECK(test_args.IsArgSet("-d"));
480 BOOST_CHECK(test_args.IsArgSet("-fff"));
481 BOOST_CHECK(test_args.IsArgSet("-ggg"));
482 BOOST_CHECK(test_args.IsArgSet("-h"));
483 BOOST_CHECK(test_args.IsArgSet("-i"));
484 BOOST_CHECK(!test_args.IsArgSet("-zzz"));
485 BOOST_CHECK(!test_args.IsArgSet("-iii"));
486
487 BOOST_CHECK_EQUAL(test_args.GetArg("-a", "xxx"), "");
488 BOOST_CHECK_EQUAL(test_args.GetArg("-b", "xxx"), "1");
489 BOOST_CHECK_EQUAL(test_args.GetArg("-ccc", "xxx"), "argument");
490 BOOST_CHECK_EQUAL(test_args.GetArg("-d", "xxx"), "e");
491 BOOST_CHECK_EQUAL(test_args.GetArg("-fff", "xxx"), "0");
492 BOOST_CHECK_EQUAL(test_args.GetArg("-ggg", "xxx"), "1");
493 BOOST_CHECK_EQUAL(test_args.GetArg("-h", "xxx"), "0");
494 BOOST_CHECK_EQUAL(test_args.GetArg("-i", "xxx"), "1");
495 BOOST_CHECK_EQUAL(test_args.GetArg("-zzz", "xxx"), "xxx");
496 BOOST_CHECK_EQUAL(test_args.GetArg("-iii", "xxx"), "xxx");
497
498 for (const bool def : {false, true}) {
499 BOOST_CHECK(test_args.GetBoolArg("-a", def));
500 BOOST_CHECK(test_args.GetBoolArg("-b", def));
501 BOOST_CHECK(!test_args.GetBoolArg("-ccc", def));
502 BOOST_CHECK(!test_args.GetBoolArg("-d", def));
503 BOOST_CHECK(!test_args.GetBoolArg("-fff", def));
504 BOOST_CHECK(test_args.GetBoolArg("-ggg", def));
505 BOOST_CHECK(!test_args.GetBoolArg("-h", def));
506 BOOST_CHECK(test_args.GetBoolArg("-i", def));
507 BOOST_CHECK(test_args.GetBoolArg("-zzz", def) == def);
508 BOOST_CHECK(test_args.GetBoolArg("-iii", def) == def);
509 }
510
511 BOOST_REQUIRE(test_args.GetArgs("-a").size() == 1);
512 BOOST_CHECK(test_args.GetArgs("-a").front() == "");
513 BOOST_REQUIRE(test_args.GetArgs("-b").size() == 1);
514 BOOST_CHECK(test_args.GetArgs("-b").front() == "1");
515 BOOST_REQUIRE(test_args.GetArgs("-ccc").size() == 2);
516 BOOST_CHECK(test_args.GetArgs("-ccc").front() == "argument");
517 BOOST_CHECK(test_args.GetArgs("-ccc").back() == "multiple");
518 BOOST_CHECK(test_args.GetArgs("-fff").size() == 0);
519 BOOST_CHECK(test_args.GetArgs("-nofff").size() == 0);
520 BOOST_REQUIRE(test_args.GetArgs("-ggg").size() == 1);
521 BOOST_CHECK(test_args.GetArgs("-ggg").front() == "1");
522 BOOST_CHECK(test_args.GetArgs("-noggg").size() == 0);
523 BOOST_CHECK(test_args.GetArgs("-h").size() == 0);
524 BOOST_CHECK(test_args.GetArgs("-noh").size() == 0);
525 BOOST_REQUIRE(test_args.GetArgs("-i").size() == 1);
526 BOOST_CHECK(test_args.GetArgs("-i").front() == "1");
527 BOOST_CHECK(test_args.GetArgs("-noi").size() == 0);
528 BOOST_CHECK(test_args.GetArgs("-zzz").size() == 0);
529
530 BOOST_CHECK(!test_args.IsArgNegated("-a"));
531 BOOST_CHECK(!test_args.IsArgNegated("-b"));
532 BOOST_CHECK(!test_args.IsArgNegated("-ccc"));
533 BOOST_CHECK(!test_args.IsArgNegated("-d"));
534 BOOST_CHECK(test_args.IsArgNegated("-fff"));
535 BOOST_CHECK(!test_args.IsArgNegated("-ggg"));
536 BOOST_CHECK(test_args.IsArgNegated("-h")); // last setting takes precedence
537 BOOST_CHECK(!test_args.IsArgNegated("-i")); // last setting takes precedence
538 BOOST_CHECK(!test_args.IsArgNegated("-zzz"));
539
540 // Test sections work
541 test_args.SelectConfigNetwork("sec1");
542
543 // same as original
544 BOOST_CHECK_EQUAL(test_args.GetArg("-a", "xxx"), "");
545 BOOST_CHECK_EQUAL(test_args.GetArg("-b", "xxx"), "1");
546 BOOST_CHECK_EQUAL(test_args.GetArg("-fff", "xxx"), "0");
547 BOOST_CHECK_EQUAL(test_args.GetArg("-ggg", "xxx"), "1");
548 BOOST_CHECK_EQUAL(test_args.GetArg("-zzz", "xxx"), "xxx");
549 BOOST_CHECK_EQUAL(test_args.GetArg("-iii", "xxx"), "xxx");
550 // d is overridden
551 BOOST_CHECK(test_args.GetArg("-d", "xxx") == "eee");
552 // section-specific setting
553 BOOST_CHECK(test_args.GetArg("-h", "xxx") == "1");
554 // section takes priority for multiple values
555 BOOST_CHECK(test_args.GetArg("-ccc", "xxx") == "extend1");
556 // check multiple values works
557 const std::vector<std::string> sec1_ccc_expected = {"extend1","extend2","argument","multiple"};
558 const auto& sec1_ccc_res = test_args.GetArgs("-ccc");
559 BOOST_CHECK_EQUAL_COLLECTIONS(sec1_ccc_res.begin(), sec1_ccc_res.end(), sec1_ccc_expected.begin(), sec1_ccc_expected.end());
560
561 test_args.SelectConfigNetwork("sec2");
562
563 // same as original
564 BOOST_CHECK(test_args.GetArg("-a", "xxx") == "");
565 BOOST_CHECK(test_args.GetArg("-b", "xxx") == "1");
566 BOOST_CHECK(test_args.GetArg("-d", "xxx") == "e");
567 BOOST_CHECK(test_args.GetArg("-fff", "xxx") == "0");
568 BOOST_CHECK(test_args.GetArg("-ggg", "xxx") == "1");
569 BOOST_CHECK(test_args.GetArg("-zzz", "xxx") == "xxx");
570 BOOST_CHECK(test_args.GetArg("-h", "xxx") == "0");
571 // section-specific setting
572 BOOST_CHECK(test_args.GetArg("-iii", "xxx") == "2");
573 // section takes priority for multiple values
574 BOOST_CHECK(test_args.GetArg("-ccc", "xxx") == "extend3");
575 // check multiple values works
576 const std::vector<std::string> sec2_ccc_expected = {"extend3","argument","multiple"};
577 const auto& sec2_ccc_res = test_args.GetArgs("-ccc");
578 BOOST_CHECK_EQUAL_COLLECTIONS(sec2_ccc_res.begin(), sec2_ccc_res.end(), sec2_ccc_expected.begin(), sec2_ccc_expected.end());
579
580 // Test section only options
581
582 const auto ccc2 = std::make_pair("-ccc", ArgsManager::ALLOW_ANY | ArgsManager::NETWORK_ONLY);
583 const auto d2 = std::make_pair("-d", ArgsManager::ALLOW_ANY | ArgsManager::NETWORK_ONLY);
584 const auto h2 = std::make_pair("-h", ArgsManager::ALLOW_ANY | ArgsManager::NETWORK_ONLY);
585 test_args.ClearArgs();
586 test_args.SetupArgs({a, b, ccc2, d2, e, fff, ggg, h2, i, iii});
587 test_args.ReadConfigString(str_config);
588
589 test_args.SelectConfigNetwork(ChainTypeToString(ChainType::MAIN));
590 BOOST_CHECK(test_args.GetArg("-d", "xxx") == "e");
591 BOOST_CHECK(test_args.GetArgs("-ccc").size() == 2);
592 BOOST_CHECK(test_args.GetArg("-h", "xxx") == "0");
593
594 test_args.SelectConfigNetwork("sec1");
595 BOOST_CHECK(test_args.GetArg("-d", "xxx") == "eee");
596 BOOST_CHECK(test_args.GetArgs("-d").size() == 1);
597 BOOST_CHECK(test_args.GetArgs("-ccc").size() == 2);
598 BOOST_CHECK(test_args.GetArg("-h", "xxx") == "1");
599
600 test_args.SelectConfigNetwork("sec2");
601 BOOST_CHECK(test_args.GetArg("-d", "xxx") == "xxx");
602 BOOST_CHECK(test_args.GetArgs("-d").size() == 0);
603 BOOST_CHECK(test_args.GetArgs("-ccc").size() == 1);
604 BOOST_CHECK(test_args.GetArg("-h", "xxx") == "0");
605}
606
607BOOST_AUTO_TEST_CASE(util_GetArg)
608{
609 TestArgsManager testArgs;
610 testArgs.LockSettings([&](common::Settings& s) {
611 s.command_line_options.clear();
612 s.command_line_options["strtest1"] = {"string..."};
613 // strtest2 undefined on purpose
614 s.command_line_options["inttest1"] = {"12345"};
615 s.command_line_options["inttest2"] = {"81985529216486895"};
616 // inttest3 undefined on purpose
617 s.command_line_options["booltest1"] = {""};
618 // booltest2 undefined on purpose
619 s.command_line_options["booltest3"] = {"0"};
620 s.command_line_options["booltest4"] = {"1"};
621
622 // priorities
623 s.command_line_options["pritest1"] = {"a", "b"};
624 s.ro_config[""]["pritest2"] = {"a", "b"};
625 s.command_line_options["pritest3"] = {"a"};
626 s.ro_config[""]["pritest3"] = {"b"};
627 s.command_line_options["pritest4"] = {"a","b"};
628 s.ro_config[""]["pritest4"] = {"c","d"};
629 });
630
631 BOOST_CHECK_EQUAL(testArgs.GetArg("strtest1", "default"), "string...");
632 BOOST_CHECK_EQUAL(testArgs.GetArg("strtest2", "default"), "default");
633 BOOST_CHECK_EQUAL(testArgs.GetIntArg("inttest1", -1), 12345);
634 BOOST_CHECK_EQUAL(testArgs.GetIntArg("inttest2", -1), 81985529216486895LL);
635 BOOST_CHECK_EQUAL(testArgs.GetIntArg("inttest3", -1), -1);
636 BOOST_CHECK_EQUAL(testArgs.GetBoolArg("booltest1", false), true);
637 BOOST_CHECK_EQUAL(testArgs.GetBoolArg("booltest2", false), false);
638 BOOST_CHECK_EQUAL(testArgs.GetBoolArg("booltest3", false), false);
639 BOOST_CHECK_EQUAL(testArgs.GetBoolArg("booltest4", false), true);
640
641 BOOST_CHECK_EQUAL(testArgs.GetArg("pritest1", "default"), "b");
642 BOOST_CHECK_EQUAL(testArgs.GetArg("pritest2", "default"), "a");
643 BOOST_CHECK_EQUAL(testArgs.GetArg("pritest3", "default"), "a");
644 BOOST_CHECK_EQUAL(testArgs.GetArg("pritest4", "default"), "b");
645}
646
647BOOST_AUTO_TEST_CASE(util_AddCommand)
648{
649 enum TestFail { SUCCESS,
650 PARSE_FAIL,
651 PARSE_ERROR,
652 NO_COMMAND,
653 COMMAND_OPTS_BAD_DETAILS,
654 COMMAND_OPTS };
655
656 auto testfn = [&](const auto& argv) -> TestFail {
657 TestArgsManager test_args;
658 test_args.AddArg("-opt1=<file name>", "Opt 1", ArgsManager::ALLOW_ANY | ArgsManager::DISALLOW_NEGATION, OptionsCategory::COMMAND_OPTIONS);
659 test_args.AddArg("-opt2=<file name>", "Opt 2", ArgsManager::ALLOW_ANY | ArgsManager::DISALLOW_NEGATION, OptionsCategory::COMMAND_OPTIONS);
660 test_args.AddArg("-opt3=<file name>", "Opt 3", ArgsManager::ALLOW_ANY | ArgsManager::DISALLOW_NEGATION, OptionsCategory::OPTIONS);
661
662 test_args.AddCommand("cmd1", "No specific options");
663 test_args.AddCommand("cmd2", "Opt 1", {"-opt1"});
664 test_args.AddCommand("cmd3", "Opt 1 or 2", {"-opt1", "-opt2"});
665
666 std::string error;
667 if (!test_args.ParseParameters(argv.size(), argv.data(), error)) return PARSE_FAIL;
668 if (!error.empty()) return PARSE_ERROR;
669 const auto command = test_args.GetCommand();
670 if (!command) return NO_COMMAND;
671 std::vector<std::string> details;
672 if (!test_args.CheckCommandOptions(command->command, &details)) {
673 if (details.empty()) return COMMAND_OPTS_BAD_DETAILS;
674 return COMMAND_OPTS;
675 } else if (!details.empty()) {
676 return COMMAND_OPTS_BAD_DETAILS;
677 }
678 return SUCCESS;
679 };
680
681 BOOST_CHECK_EQUAL(COMMAND_OPTS, testfn(std::array{"x", "-opt1=foo", "cmd1"}));
682 BOOST_CHECK_EQUAL(SUCCESS, testfn(std::array{"x", "cmd1", "-opt1=foo"})); // things after the command are "args" and left unparsed, not options
683
684 BOOST_CHECK_EQUAL(SUCCESS, testfn(std::array{"x", "-opt1=foo", "cmd2"}));
685 BOOST_CHECK_EQUAL(SUCCESS, testfn(std::array{"x", "-opt1=foo", "cmd3"}));
686 BOOST_CHECK_EQUAL(COMMAND_OPTS, testfn(std::array{"x", "-opt2=foo", "cmd1"}));
687 BOOST_CHECK_EQUAL(COMMAND_OPTS, testfn(std::array{"x", "-opt2=foo", "cmd2"}));
688 BOOST_CHECK_EQUAL(SUCCESS, testfn(std::array{"x", "-opt2=foo", "cmd3"}));
689 BOOST_CHECK_EQUAL(SUCCESS, testfn(std::array{"x", "-opt3=foo", "cmd1"}));
690 BOOST_CHECK_EQUAL(SUCCESS, testfn(std::array{"x", "-opt3=foo", "cmd2"}));
691 BOOST_CHECK_EQUAL(SUCCESS, testfn(std::array{"x", "-opt3=foo", "cmd3"}));
692
693 BOOST_CHECK_EQUAL(COMMAND_OPTS, testfn(std::array{"x", "-opt1=foo", "-opt3=bar", "-opt2=baz", "cmd1"}));
694 BOOST_CHECK_EQUAL(COMMAND_OPTS, testfn(std::array{"x", "-opt1=foo", "-opt3=bar", "-opt2=baz", "cmd2"}));
695 BOOST_CHECK_EQUAL(SUCCESS, testfn(std::array{"x", "-opt1=foo", "-opt3=bar", "-opt2=baz", "cmd3"}));
696
697 BOOST_CHECK_EQUAL(PARSE_FAIL, testfn(std::array{"x", "cmd4"}));
698 BOOST_CHECK_EQUAL(NO_COMMAND, testfn(std::array{"x", "-opt3=foo"}));
699 BOOST_CHECK_EQUAL(PARSE_FAIL, testfn(std::array{"x", "-opt4=foo"}));
700}
701
702BOOST_AUTO_TEST_CASE(util_AddCommand_clearargs_replaces_command_options)
703{
704 const auto add_command{[&](TestArgsManager& test_args, const std::string& option) {
705 test_args.AddArg(option, "option", ArgsManager::ALLOW_ANY, OptionsCategory::COMMAND_OPTIONS);
706 test_args.AddCommand("cmd", "cmd", {option});
707 }};
708
709 TestArgsManager test_args;
710 add_command(test_args, "-opt1");
711 test_args.ClearArgs();
712 add_command(test_args, "-opt2");
713
714 const auto help{test_args.GetHelpMessage()};
715 BOOST_CHECK(help.find("-opt2") != std::string::npos);
716
717 test_args.ForceSetArg("-opt2", "1");
718 std::vector<std::string> details;
719 BOOST_CHECK(test_args.CheckCommandOptions("cmd", &details));
720 BOOST_CHECK(details.empty());
721}
722
723BOOST_AUTO_TEST_CASE(util_GetChainTypeString)
724{
725 TestArgsManager test_args;
726 const auto testnet = std::make_pair("-testnet", ArgsManager::ALLOW_ANY);
727 const auto testnet4 = std::make_pair("-testnet4", ArgsManager::ALLOW_ANY);
728 const auto regtest = std::make_pair("-regtest", ArgsManager::ALLOW_ANY);
729 test_args.SetupArgs({testnet, testnet4, regtest});
730
731 const char* argv_testnet4[] = {"cmd", "-testnet4"};
732 const char* argv_regtest[] = {"cmd", "-regtest"};
733 const char* argv_test_no_reg[] = {"cmd", "-testnet4", "-noregtest"};
734 const char* argv_both[] = {"cmd", "-testnet4", "-regtest"};
735
736 // regtest in test network section is ignored
737 const char* testnetconf = "testnet4=1\nregtest=0\n[testnet4]\nregtest=1";
738 std::string error;
739
740 BOOST_CHECK(test_args.ParseParameters(0, argv_testnet4, error));
741 BOOST_CHECK_EQUAL(test_args.GetChainTypeString(), "main");
742
743 BOOST_CHECK(test_args.ParseParameters(0, argv_testnet4, error));
744 BOOST_CHECK_EQUAL(test_args.GetChainTypeString(), "main");
745
746 BOOST_CHECK(test_args.ParseParameters(2, argv_testnet4, error));
747 BOOST_CHECK_EQUAL(test_args.GetChainTypeString(), "testnet4");
748
749 BOOST_CHECK(test_args.ParseParameters(2, argv_regtest, error));
750 BOOST_CHECK_EQUAL(test_args.GetChainTypeString(), "regtest");
751
752 BOOST_CHECK(test_args.ParseParameters(3, argv_test_no_reg, error));
753 BOOST_CHECK_EQUAL(test_args.GetChainTypeString(), "testnet4");
754
755 BOOST_CHECK(test_args.ParseParameters(3, argv_both, error));
756 BOOST_CHECK_THROW(test_args.GetChainTypeString(), std::runtime_error);
757
758 BOOST_CHECK(test_args.ParseParameters(0, argv_testnet4, error));
759 test_args.ReadConfigString(testnetconf);
760 BOOST_CHECK_EQUAL(test_args.GetChainTypeString(), "testnet4");
761
762 BOOST_CHECK(test_args.ParseParameters(2, argv_testnet4, error));
763 test_args.ReadConfigString(testnetconf);
764 BOOST_CHECK_EQUAL(test_args.GetChainTypeString(), "testnet4");
765
766 BOOST_CHECK(test_args.ParseParameters(2, argv_regtest, error));
767 test_args.ReadConfigString(testnetconf);
768 BOOST_CHECK_THROW(test_args.GetChainTypeString(), std::runtime_error);
769
770 BOOST_CHECK(test_args.ParseParameters(3, argv_test_no_reg, error));
771 test_args.ReadConfigString(testnetconf);
772 BOOST_CHECK_EQUAL(test_args.GetChainTypeString(), "testnet4");
773
774 BOOST_CHECK(test_args.ParseParameters(3, argv_both, error));
775 test_args.ReadConfigString(testnetconf);
776 BOOST_CHECK_THROW(test_args.GetChainTypeString(), std::runtime_error);
777
778 // check setting the network to testnet4 (and thus making
779 // [testnet4] regtest=1 potentially relevant) doesn't break things
780 test_args.SelectConfigNetwork("testnet4");
781
782 BOOST_CHECK(test_args.ParseParameters(0, argv_testnet4, error));
783 test_args.ReadConfigString(testnetconf);
784 BOOST_CHECK_EQUAL(test_args.GetChainTypeString(), "testnet4");
785
786 BOOST_CHECK(test_args.ParseParameters(2, argv_testnet4, error));
787 test_args.ReadConfigString(testnetconf);
788 BOOST_CHECK_EQUAL(test_args.GetChainTypeString(), "testnet4");
789
790 BOOST_CHECK(test_args.ParseParameters(2, argv_regtest, error));
791 test_args.ReadConfigString(testnetconf);
792 BOOST_CHECK_THROW(test_args.GetChainTypeString(), std::runtime_error);
793
794 BOOST_CHECK(test_args.ParseParameters(2, argv_test_no_reg, error));
795 test_args.ReadConfigString(testnetconf);
796 BOOST_CHECK_EQUAL(test_args.GetChainTypeString(), "testnet4");
797
798 BOOST_CHECK(test_args.ParseParameters(3, argv_both, error));
799 test_args.ReadConfigString(testnetconf);
800 BOOST_CHECK_THROW(test_args.GetChainTypeString(), std::runtime_error);
801}
802
803// Test different ways settings can be merged, and verify results. This test can
804// be used to confirm that updates to settings code don't change behavior
805// unintentionally.
806//
807// The test covers:
808//
809// - Combining different setting actions. Possible actions are: configuring a
810// setting, negating a setting (adding "-no" prefix), and configuring/negating
811// settings in a network section (adding "main." or "test." prefixes).
812//
813// - Combining settings from command line arguments and a config file.
814//
815// - Combining SoftSet and ForceSet calls.
816//
817// - Testing "main" and "testnet4" network values to make sure settings from network
818// sections are applied and to check for mainnet-specific behaviors like
819// inheriting settings from the default section.
820//
821// - Testing network-specific settings like "-wallet", that may be ignored
822// outside a network section, and non-network specific settings like "-server"
823// that aren't sensitive to the network.
824//
825struct ArgsMergeTestingSetup : public BasicTestingSetup {
828 static constexpr int MAX_ACTIONS = 3;
829
830 enum Action { NONE, SET, NEGATE, SECTION_SET, SECTION_NEGATE };
831 using ActionList = Action[MAX_ACTIONS];
832
834 template <typename Fn>
835 void ForEachMergeSetup(Fn&& fn)
836 {
837 ActionList arg_actions = {};
838 // command_line_options do not have sections. Only iterate over SET and NEGATE
839 ForEachNoDup(arg_actions, SET, NEGATE, [&] {
840 ActionList conf_actions = {};
841 ForEachNoDup(conf_actions, SET, SECTION_NEGATE, [&] {
842 for (bool soft_set : {false, true}) {
843 for (bool force_set : {false, true}) {
844 for (const std::string& section : {ChainTypeToString(ChainType::MAIN), ChainTypeToString(ChainType::TESTNET), ChainTypeToString(ChainType::TESTNET4), ChainTypeToString(ChainType::SIGNET)}) {
845 for (const std::string& network : {ChainTypeToString(ChainType::MAIN), ChainTypeToString(ChainType::TESTNET), ChainTypeToString(ChainType::TESTNET4), ChainTypeToString(ChainType::SIGNET)}) {
846 for (bool net_specific : {false, true}) {
847 fn(arg_actions, conf_actions, soft_set, force_set, section, network, net_specific);
848 }
849 }
850 }
851 }
852 }
853 });
854 });
855 }
856
858 std::vector<std::string> GetValues(const ActionList& actions,
859 const std::string& section,
860 const std::string& name,
861 const std::string& value_prefix)
862 {
863 std::vector<std::string> values;
864 int suffix = 0;
865 for (Action action : actions) {
866 if (action == NONE) break;
867 std::string prefix;
868 if (action == SECTION_SET || action == SECTION_NEGATE) prefix = section + ".";
869 if (action == SET || action == SECTION_SET) {
870 for (int i = 0; i < 2; ++i) {
871 values.push_back(prefix + name + "=" + value_prefix + ToString(++suffix));
872 }
873 }
874 if (action == NEGATE || action == SECTION_NEGATE) {
875 values.push_back(prefix + "no" + name + "=1");
876 }
877 }
878 return values;
879 }
880};
881
882// Regression test covering different ways config settings can be merged. The
883// test parses and merges settings, representing the results as strings that get
884// compared against an expected hash. To debug, the result strings can be dumped
885// to a file (see comments below).
886BOOST_FIXTURE_TEST_CASE(util_ArgsMerge, ArgsMergeTestingSetup)
887{
888 CHash256 out_sha;
889 FILE* out_file = nullptr;
890 if (const char* out_path = getenv("ARGS_MERGE_TEST_OUT")) {
891 out_file = fsbridge::fopen(out_path, "w");
892 if (!out_file) throw std::system_error(errno, std::generic_category(), "fopen failed");
893 }
894
895 ForEachMergeSetup([&](const ActionList& arg_actions, const ActionList& conf_actions, bool soft_set, bool force_set,
896 const std::string& section, const std::string& network, bool net_specific) {
897 TestArgsManager parser;
898
899 std::string desc = "net=";
900 desc += network;
901 parser.SelectConfigNetwork(network);
902
903 const std::string& name = net_specific ? "wallet" : "server";
904 const std::string key = "-" + name;
905 unsigned int flags = ArgsManager::ALLOW_ANY;
906 if (net_specific) flags |= ArgsManager::NETWORK_ONLY;
907 parser.AddArg(key, name, flags, OptionsCategory::OPTIONS);
908
909 auto args = GetValues(arg_actions, section, name, "a");
910 std::vector<const char*> argv = {"ignored"};
911 for (auto& arg : args) {
912 arg.insert(0, "-");
913 desc += " ";
914 desc += arg;
915 argv.push_back(arg.c_str());
916 }
917 std::string error;
918 BOOST_CHECK(parser.ParseParameters(argv.size(), argv.data(), error));
919 BOOST_CHECK_EQUAL(error, "");
920
921 std::string conf;
922 for (auto& conf_val : GetValues(conf_actions, section, name, "c")) {
923 desc += " ";
924 desc += conf_val;
925 conf += conf_val;
926 conf += "\n";
927 }
928 std::istringstream conf_stream(conf);
929 BOOST_CHECK(parser.ReadConfigStream(conf_stream, "filepath", error));
930 BOOST_CHECK_EQUAL(error, "");
931
932 if (soft_set) {
933 desc += " soft";
934 parser.SoftSetArg(key, "soft1");
935 parser.SoftSetArg(key, "soft2");
936 }
937
938 if (force_set) {
939 desc += " force";
940 parser.ForceSetArg(key, "force1");
941 parser.ForceSetArg(key, "force2");
942 }
943
944 desc += " || ";
945
946 if (!parser.IsArgSet(key)) {
947 desc += "unset";
948 BOOST_CHECK(!parser.IsArgNegated(key));
949 BOOST_CHECK_EQUAL(parser.GetArg(key, "default"), "default");
950 BOOST_CHECK(parser.GetArgs(key).empty());
951 } else if (parser.IsArgNegated(key)) {
952 desc += "negated";
953 BOOST_CHECK_EQUAL(parser.GetArg(key, "default"), "0");
954 BOOST_CHECK(parser.GetArgs(key).empty());
955 } else {
956 desc += parser.GetArg(key, "default");
957 desc += " |";
958 for (const auto& arg : parser.GetArgs(key)) {
959 desc += " ";
960 desc += arg;
961 }
962 }
963
964 std::set<std::string> ignored = parser.GetUnsuitableSectionOnlyArgs();
965 if (!ignored.empty()) {
966 desc += " | ignored";
967 for (const auto& arg : ignored) {
968 desc += " ";
969 desc += arg;
970 }
971 }
972
973 desc += "\n";
974
975 out_sha.Write(MakeUCharSpan(desc));
976 if (out_file) {
977 BOOST_REQUIRE(fwrite(desc.data(), 1, desc.size(), out_file) == desc.size());
978 }
979 });
980
981 if (out_file) {
982 if (fclose(out_file)) throw std::system_error(errno, std::generic_category(), "fclose failed");
983 out_file = nullptr;
984 }
985
986 unsigned char out_sha_bytes[CSHA256::OUTPUT_SIZE];
987 out_sha.Finalize(out_sha_bytes);
988 std::string out_sha_hex = HexStr(out_sha_bytes);
989
990 // If check below fails, should manually dump the results with:
991 //
992 // ARGS_MERGE_TEST_OUT=results.txt ./test_bitcoin --run_test=argsman_tests/util_ArgsMerge
993 //
994 // And verify diff against previous results to make sure the changes are expected.
995 //
996 // Results file is formatted like:
997 //
998 // <input> || <IsArgSet/IsArgNegated/GetArg output> | <GetArgs output> | <GetUnsuitable output>
999 BOOST_CHECK_EQUAL(out_sha_hex, "f1ee5ab094cc43d16a6086fa7f2c10389e0f99902616b31bbf29189972ad1473");
1000}
1001
1002// Similar test as above, but for ArgsManager::GetChainTypeString function.
1003struct ChainMergeTestingSetup : public BasicTestingSetup {
1004 static constexpr int MAX_ACTIONS = 2;
1005
1006 enum Action { NONE, ENABLE_TEST, DISABLE_TEST, NEGATE_TEST, ENABLE_REG, DISABLE_REG, NEGATE_REG };
1007 using ActionList = Action[MAX_ACTIONS];
1008
1010 template <typename Fn>
1011 void ForEachMergeSetup(Fn&& fn)
1012 {
1013 ActionList arg_actions = {};
1014 ForEachNoDup(arg_actions, ENABLE_TEST, NEGATE_REG, [&] {
1015 ActionList conf_actions = {};
1016 ForEachNoDup(conf_actions, ENABLE_TEST, NEGATE_REG, [&] { fn(arg_actions, conf_actions); });
1017 });
1018 }
1019};
1020
1021BOOST_FIXTURE_TEST_CASE(util_ChainMerge, ChainMergeTestingSetup)
1022{
1023 CHash256 out_sha;
1024 FILE* out_file = nullptr;
1025 if (const char* out_path = getenv("CHAIN_MERGE_TEST_OUT")) {
1026 out_file = fsbridge::fopen(out_path, "w");
1027 if (!out_file) throw std::system_error(errno, std::generic_category(), "fopen failed");
1028 }
1029
1030 ForEachMergeSetup([&](const ActionList& arg_actions, const ActionList& conf_actions) {
1031 TestArgsManager parser;
1032 parser.AddArg("-regtest", "regtest", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
1033 parser.AddArg("-testnet4", "testnet4", ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
1034
1035 auto arg = [](Action action) { return action == ENABLE_TEST ? "-testnet4=1" :
1036 action == DISABLE_TEST ? "-testnet4=0" :
1037 action == NEGATE_TEST ? "-notestnet4=1" :
1038 action == ENABLE_REG ? "-regtest=1" :
1039 action == DISABLE_REG ? "-regtest=0" :
1040 action == NEGATE_REG ? "-noregtest=1" : nullptr; };
1041
1042 std::string desc;
1043 std::vector<const char*> argv = {"ignored"};
1044 for (Action action : arg_actions) {
1045 const char* argstr = arg(action);
1046 if (!argstr) break;
1047 argv.push_back(argstr);
1048 desc += " ";
1049 desc += argv.back();
1050 }
1051 std::string error;
1052 BOOST_CHECK(parser.ParseParameters(argv.size(), argv.data(), error));
1053 BOOST_CHECK_EQUAL(error, "");
1054
1055 std::string conf;
1056 for (Action action : conf_actions) {
1057 const char* argstr = arg(action);
1058 if (!argstr) break;
1059 desc += " ";
1060 desc += argstr + 1;
1061 conf += argstr + 1;
1062 conf += "\n";
1063 }
1064 std::istringstream conf_stream(conf);
1065 BOOST_CHECK(parser.ReadConfigStream(conf_stream, "filepath", error));
1066 BOOST_CHECK_EQUAL(error, "");
1067
1068 desc += " || ";
1069 try {
1070 desc += parser.GetChainTypeString();
1071 } catch (const std::runtime_error& e) {
1072 desc += "error: ";
1073 desc += e.what();
1074 }
1075 desc += "\n";
1076
1077 out_sha.Write(MakeUCharSpan(desc));
1078 if (out_file) {
1079 BOOST_REQUIRE(fwrite(desc.data(), 1, desc.size(), out_file) == desc.size());
1080 }
1081 });
1082
1083 if (out_file) {
1084 if (fclose(out_file)) throw std::system_error(errno, std::generic_category(), "fclose failed");
1085 out_file = nullptr;
1086 }
1087
1088 unsigned char out_sha_bytes[CSHA256::OUTPUT_SIZE];
1089 out_sha.Finalize(out_sha_bytes);
1090 std::string out_sha_hex = HexStr(out_sha_bytes);
1091
1092 // If check below fails, should manually dump the results with:
1093 //
1094 // CHAIN_MERGE_TEST_OUT=results.txt ./test_bitcoin --run_test=argsman_tests/util_ChainMerge
1095 //
1096 // And verify diff against previous results to make sure the changes are expected.
1097 //
1098 // Results file is formatted like:
1099 //
1100 // <input> || <output>
1101 BOOST_CHECK_EQUAL(out_sha_hex, "c0e33aab0c74e040ddcee9edad59e8148d8e1cacb3cccd9ea1a1f485cb6bad21");
1102}
1103
1104BOOST_AUTO_TEST_CASE(util_ReadWriteSettings)
1105{
1106 // Test writing setting.
1107 TestArgsManager args1;
1108 args1.ForceSetArg("-datadir", fs::PathToString(m_path_root));
1109 args1.LockSettings([&](common::Settings& s) { s.rw_settings["name"] = "value"; });
1110 args1.WriteSettingsFile();
1111
1112 // Test reading setting.
1113 TestArgsManager args2;
1114 args2.ForceSetArg("-datadir", fs::PathToString(m_path_root));
1115 args2.ReadSettingsFile();
1116 args2.LockSettings([&](common::Settings& s) { BOOST_CHECK_EQUAL(s.rw_settings["name"].get_str(), "value"); });
1117
1118 // Test error logging, and remove previously written setting.
1119 {
1120 ASSERT_DEBUG_LOG("Failed renaming settings file");
1121 fs::remove(args1.GetDataDirBase() / "settings.json");
1122 fs::create_directory(args1.GetDataDirBase() / "settings.json");
1123 args2.WriteSettingsFile();
1124 fs::remove(args1.GetDataDirBase() / "settings.json");
1125 }
1126}
1127
1128BOOST_AUTO_TEST_SUITE_END()
BOOST_FIXTURE_TEST_CASE
BOOST_FIXTURE_TEST_CASE(util_CheckValue, CheckValueTest)
Definition: argsman_tests.cpp:155
TestParse
static void TestParse(const std::string &str, bool expected_bool, int64_t expected_int)
Definition: argsman_tests.cpp:265
BOOST_AUTO_TEST_CASE
BOOST_AUTO_TEST_CASE(util_datadir)
Definition: argsman_tests.cpp:27
flags
int flags
Definition: bitcoin-tx.cpp:530
command
const auto command
Definition: bitcoin-wallet.cpp:117
args
ArgsManager & args
Definition: bitcoind.cpp:280
ChainTypeToString
std::string ChainTypeToString(ChainType chain)
Definition: chaintype.cpp:12
ArgsManager::ParseParameters
bool ParseParameters(int argc, const char *const argv[], std::string &error) EXCLUSIVE_LOCKS_REQUIRED(!cs_args)
Definition: args.cpp:175
ArgsManager::GetSettingsList
std::vector< common::SettingsValue > GetSettingsList(const std::string &arg) const EXCLUSIVE_LOCKS_REQUIRED(!cs_args)
Get list of setting values.
Definition: args.cpp:976
ArgsManager::GetArgs
std::vector< std::string > GetArgs(const std::string &strArg) const EXCLUSIVE_LOCKS_REQUIRED(!cs_args)
Return a vector of strings of the given argument.
Definition: args.cpp:422
ArgsManager::NETWORK_ONLY
@ NETWORK_ONLY
Definition: args.h:128
ArgsManager::ALLOW_ANY
@ ALLOW_ANY
disable validation
Definition: args.h:114
ArgsManager::DISALLOW_NEGATION
@ DISALLOW_NEGATION
disallow -nofoo syntax
Definition: args.h:119
ArgsManager::GetSetting
common::SettingsValue GetSetting(const std::string &arg) const EXCLUSIVE_LOCKS_REQUIRED(!cs_args)
Get setting value.
Definition: args.cpp:970
ArgsManager::ReadConfigString
bool ReadConfigString(const std::string &str_config) EXCLUSIVE_LOCKS_REQUIRED(!cs_args)
Definition: config.cpp:120
ArgsManager::CheckCommandOptions
bool CheckCommandOptions(const std::string &command, std::vector< std::string > *errors=nullptr) const EXCLUSIVE_LOCKS_REQUIRED(!cs_args)
Check that any command-specific options the user specified are valid for the given command.
Definition: args.cpp:388
ArgsManager::GetDataDirBase
fs::path GetDataDirBase() const EXCLUSIVE_LOCKS_REQUIRED(!cs_args)
Get data directory path.
Definition: args.cpp:323
ArgsManager::AddCommand
void AddCommand(const std::string &cmd, const std::string &help, std::set< std::string > options={}) EXCLUSIVE_LOCKS_REQUIRED(!cs_args)
Add command.
Definition: args.cpp:633
ArgsManager::SoftSetArg
bool SoftSetArg(const std::string &strArg, const std::string &strValue) EXCLUSIVE_LOCKS_REQUIRED(!cs_args)
Set an argument if it doesn't already have a value.
Definition: args.cpp:611
ArgsManager::GetUnsuitableSectionOnlyArgs
std::set< std::string > GetUnsuitableSectionOnlyArgs() const EXCLUSIVE_LOCKS_REQUIRED(!cs_args)
Log warnings for options in m_section_only_args when they are specified in the default section but no...
Definition: args.cpp:132
ArgsManager::AddArg
void AddArg(const std::string &name, const std::string &help, unsigned int flags, const OptionsCategory &cat) EXCLUSIVE_LOCKS_REQUIRED(!cs_args)
Add argument.
Definition: args.cpp:657
ArgsManager::WriteSettingsFile
bool WriteSettingsFile(std::vector< std::string > *errors=nullptr, bool backup=false) const EXCLUSIVE_LOCKS_REQUIRED(!cs_args)
Write settings file or backup settings file.
Definition: args.cpp:485
ArgsManager::LockSettings
void LockSettings(Fn &&fn) EXCLUSIVE_LOCKS_REQUIRED(!cs_args)
Access settings with lock held.
Definition: args.h:442
ArgsManager::ClearPathCache
void ClearPathCache() EXCLUSIVE_LOCKS_REQUIRED(!cs_args)
Clear cached directory paths.
Definition: args.cpp:359
ArgsManager::ForceSetArg
void ForceSetArg(const std::string &strArg, const std::string &strValue) EXCLUSIVE_LOCKS_REQUIRED(!cs_args)
Definition: args.cpp:627
ArgsManager::GetArg
std::string GetArg(const std::string &strArg, const std::string &strDefault) const EXCLUSIVE_LOCKS_REQUIRED(!cs_args)
Return string argument or default value.
Definition: args.cpp:517
ArgsManager::GetChainTypeString
std::string GetChainTypeString() const EXCLUSIVE_LOCKS_REQUIRED(!cs_args)
Returns the appropriate chain type string from the program arguments.
Definition: args.cpp:917
ArgsManager::ReadSettingsFile
bool ReadSettingsFile(std::vector< std::string > *errors=nullptr) EXCLUSIVE_LOCKS_REQUIRED(!cs_args)
Read settings file.
Definition: args.cpp:462
ArgsManager::ClearArgs
void ClearArgs() EXCLUSIVE_LOCKS_REQUIRED(!cs_args)
Clear available arguments.
Definition: args.cpp:693
ArgsManager::IsArgSet
bool IsArgSet(const std::string &strArg) const EXCLUSIVE_LOCKS_REQUIRED(!cs_args)
Return true if the given argument has been manually set.
Definition: args.cpp:431
ArgsManager::GetCommand
std::optional< const Command > GetCommand() const EXCLUSIVE_LOCKS_REQUIRED(!cs_args)
Get the command and command args (returns std::nullopt if no command provided)
Definition: args.cpp:368
ArgsManager::IsArgNegated
bool IsArgNegated(const std::string &strArg) const EXCLUSIVE_LOCKS_REQUIRED(!cs_args)
Return true if the argument was originally passed as a negated option, i.e.
Definition: args.cpp:512
ArgsManager::ReadConfigStream
bool ReadConfigStream(std::istream &stream, const std::string &filepath, std::string &error, bool ignore_invalid_keys=false) EXCLUSIVE_LOCKS_REQUIRED(!cs_args)
Definition: config.cpp:91
ArgsManager::GetIntArg
int64_t GetIntArg(const std::string &strArg, int64_t nDefault) const EXCLUSIVE_LOCKS_REQUIRED(!cs_args)
Definition: args.h:323
ArgsManager::GetBoolArg
bool GetBoolArg(const std::string &strArg, bool fDefault) const EXCLUSIVE_LOCKS_REQUIRED(!cs_args)
Return boolean argument or default value.
Definition: args.cpp:571
ArgsManager::SelectConfigNetwork
void SelectConfigNetwork(const std::string &network) EXCLUSIVE_LOCKS_REQUIRED(!cs_args)
Select the network in use.
Definition: args.cpp:169
ArgsManager::GetHelpMessage
std::string GetHelpMessage() const EXCLUSIVE_LOCKS_REQUIRED(!cs_args)
Get the help string.
Definition: args.cpp:720
CHash256
A hasher class for Bitcoin's 256-bit hash (double SHA-256).
Definition: hash.h:32
CHash256::Finalize
void Finalize(std::span< unsigned char > output)
Definition: hash.h:38
CHash256::Write
CHash256 & Write(std::span< const unsigned char > input)
Definition: hash.h:45
CSHA256::OUTPUT_SIZE
static constexpr size_t OUTPUT_SIZE
Definition: sha256.h:21
CheckValueTest
Test GetSetting and GetArg type coercion, negation, and default value handling.
Definition: argsman_tests.cpp:71
CheckValueTest::CheckValue
void CheckValue(unsigned int flags, const char *arg, const Expect &expect)
Definition: argsman_tests.cpp:95
UniValue::write
std::string write(unsigned int prettyIndent=0, unsigned int indentLevel=0) const
Definition: univalue_write.cpp:30
Parse
static UniValue Parse(std::string_view raw, ParamFormat format=ParamFormat::JSON)
Parse string to UniValue or throw runtime_error if string contains invalid JSON.
Definition: client.cpp:404
BOOST_FIXTURE_TEST_SUITE
BOOST_FIXTURE_TEST_SUITE(cuckoocache_tests, BasicTestingSetup)
Test Suite for CuckooCache.
BOOST_AUTO_TEST_SUITE_END
BOOST_AUTO_TEST_SUITE_END()
std::filesystem::PathToString
static std::string PathToString(const path &path)
Convert path object to a byte string.
Definition: fs.h:162
HexStr
std::string HexStr(const std::span< const uint8_t > s)
Convert a span of bytes to a lower-case hexadecimal string.
Definition: hex_base.cpp:30
BOOST_CHECK_EQUAL
BOOST_CHECK_EQUAL(headers.FindFirst("key"), "value")
fsbridge::fopen
FILE * fopen(const fs::path &p, const char *mode)
Definition: fs.cpp:23
test_vectors_musig2_generate.s
tuple s
Definition: test_vectors_musig2_generate.py:72
util::ToString
std::string ToString(const T &t)
Locale-independent version of std::to_string.
Definition: string.h:249
BOOST_CHECK_THROW
#define BOOST_CHECK_THROW(stmt, excMatch)
Definition: object.cpp:18
BOOST_CHECK
#define BOOST_CHECK(expr)
Definition: object.cpp:16
prefix
const char * prefix
Definition: rest.cpp:1180
name
const char * name
Definition: rest.cpp:56
values
static const int64_t values[]
A selection of numbers that do not trigger int64_t overflow when added/subtracted.
Definition: scriptnum_tests.cpp:17
help
static RPCMethod help()
Definition: server.cpp:123
setup_common.h
MakeUCharSpan
constexpr auto MakeUCharSpan(const V &v) -> decltype(UCharSpanCast(std::span{v}))
Like the std::span constructor, but for (const) unsigned char member types only.
Definition: span.h:111
ForEachNoDup
void ForEachNoDup(CharType(&string)[StringLength], CharType min_char, CharType max_char, Fn &&fn)
Iterate over string values and call function for each string without successive duplicate characters.
Definition: str.h:30
ArgsMergeTestingSetup::ForEachMergeSetup
void ForEachMergeSetup(Fn &&fn)
Enumerate all possible test configurations.
Definition: argsman_tests.cpp:835
ArgsMergeTestingSetup::MAX_ACTIONS
static constexpr int MAX_ACTIONS
Max number of actions to sequence together.
Definition: argsman_tests.cpp:828
ArgsMergeTestingSetup::GetValues
std::vector< std::string > GetValues(const ActionList &actions, const std::string &section, const std::string &name, const std::string &value_prefix)
Translate actions into a list of <key>=setting strings.
Definition: argsman_tests.cpp:858
ArgsMergeTestingSetup::ActionList
Action[MAX_ACTIONS] ActionList
Definition: argsman_tests.cpp:831
BasicTestingSetup
Basic testing setup.
Definition: setup_common.h:58
ChainMergeTestingSetup::ForEachMergeSetup
void ForEachMergeSetup(Fn &&fn)
Enumerate all possible test configurations.
Definition: argsman_tests.cpp:1011
ChainMergeTestingSetup::ActionList
Action[MAX_ACTIONS] ActionList
Definition: argsman_tests.cpp:1007
ChainMergeTestingSetup::MAX_ACTIONS
static constexpr int MAX_ACTIONS
Definition: argsman_tests.cpp:1004
CheckValueTest::Expect::Expect
Expect(common::SettingsValue s)
Definition: argsman_tests.cpp:84
CheckValueTest::Expect::List
Expect & List(std::vector< std::string > m)
Definition: argsman_tests.cpp:91
CheckValueTest::Expect::Bool
Expect & Bool(bool b)
Definition: argsman_tests.cpp:90
CheckValueTest::Expect::String
Expect & String(const char *s)
Definition: argsman_tests.cpp:88
CheckValueTest::Expect::int_value
std::optional< int64_t > int_value
Definition: argsman_tests.cpp:79
CheckValueTest::Expect::list_value
std::optional< std::vector< std::string > > list_value
Definition: argsman_tests.cpp:81
CheckValueTest::Expect::Error
Expect & Error(const char *e)
Definition: argsman_tests.cpp:92
CheckValueTest::Expect::setting
common::SettingsValue setting
Definition: argsman_tests.cpp:74
CheckValueTest::Expect::bool_value
std::optional< bool > bool_value
Definition: argsman_tests.cpp:80
CheckValueTest::Expect::Int
Expect & Int(int64_t i)
Definition: argsman_tests.cpp:89
NoIncludeConfTest::Parse
std::string Parse(const char *arg)
Definition: argsman_tests.cpp:175
TestArgsManager::ReadConfigString
void ReadConfigString(const std::string &str_config)
Definition: argsman_tests.cpp:54
TestArgsManager::SetupArgs
void SetupArgs(const std::vector< std::pair< std::string, unsigned int > > &args)
Definition: argsman_tests.cpp:58
TestArgsManager::ReadConfigStream
bool ReadConfigStream(std::istream &stream, const std::string &filepath, std::string &error, bool ignore_invalid_keys=false) EXCLUSIVE_LOCKS_REQUIRED(!cs_args)
Definition: config.cpp:91
TestChain100Setup
Testing fixture that pre-creates a 100-block REGTEST-mode block chain.
Definition: setup_common.h:139
common::Settings
Stored settings.
Definition: settings.h:34
ASSERT_DEBUG_LOG
#define ASSERT_DEBUG_LOG(message)
Definition: logging.h:42
expect
#define expect(bit)
Definition: univalue_read.cpp:258
Generated on Sun Aug 16 2026 20:00:34 for Bitcoin Core by doxygen 1.9.4