Inside Bitcoin

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