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