From e064f20d8a8a3746040ccde52ef3b4b492aa858a Mon Sep 17 00:00:00 2001
From: Ryan Ofsky <ryan@ofsky.org>
Date: Sat, 23 Nov 2019 10:25:48 -0500
Subject: [PATCH] test: Extend util_ArgsMerge test to check for "Multiple
 values specified" errors

Also skip calling TestArgString in these cases since exact behavior retrieving
values is irrelevant when parsing values fails.

Also s/TestArgString/GetArg/ to be more efficient and direct, now that it's no
longer necessary to call with separation of ALLOW_LIST and non ALLOW_LIST
cases.
---
 src/test/argsman_tests.cpp | 48 +++++++++++++++++++++++++++++++++-----
 1 file changed, 42 insertions(+), 6 deletions(-)

diff --git a/src/test/argsman_tests.cpp b/src/test/argsman_tests.cpp
index fac37f502d2..f2ff11ac8a4 100644
--- a/src/test/argsman_tests.cpp
+++ b/src/test/argsman_tests.cpp
@@ -1400,17 +1400,23 @@ BOOST_FIXTURE_TEST_CASE(util_ArgsMerge, ArgsMergeTestingSetup)
 
     ForEachMergeSetup([&](const ActionList& arg_actions, const ActionList& conf_actions, bool soft_set, bool force_set,
                           const std::string& section, const std::string& network, bool net_specific) {
-        TestArgsManager parser;
+        TestArgsManager parser, single_parser;
         LOCK(parser.cs_args);
+        LOCK(single_parser.cs_args);
 
         std::string desc = "net=";
         desc += network;
         parser.m_network = network;
+        single_parser.m_network = network;
 
         const std::string& name = net_specific ? "wallet" : "server";
         const std::string key = "-" + name;
         parser.AddArg(key, name, ArgsManager::ALLOW_ANY | ArgsManager::ALLOW_LIST, OptionsCategory::OPTIONS);
-        if (net_specific) parser.SetNetworkOnlyArg(key);
+        single_parser.AddArg(key, name, ArgsManager::ALLOW_ANY, OptionsCategory::OPTIONS);
+        if (net_specific) {
+            parser.SetNetworkOnlyArg(key);
+            single_parser.SetNetworkOnlyArg(key);
+        }
 
         auto args = GetValues(arg_actions, section, name, "a");
         std::vector<const char*> argv = {"ignored"};
@@ -1423,6 +1429,8 @@ BOOST_FIXTURE_TEST_CASE(util_ArgsMerge, ArgsMergeTestingSetup)
         std::string error;
         BOOST_CHECK(parser.ParseParameters(argv.size(), argv.data(), error));
         BOOST_CHECK_EQUAL(error, "");
+        BOOST_CHECK(single_parser.ParseParameters(argv.size(), argv.data(), error));
+        BOOST_CHECK_EQUAL(error, "");
 
         std::string conf;
         for (auto& conf_val : GetValues(conf_actions, section, name, "c")) {
@@ -1434,17 +1442,27 @@ BOOST_FIXTURE_TEST_CASE(util_ArgsMerge, ArgsMergeTestingSetup)
         std::istringstream conf_stream(conf);
         BOOST_CHECK(parser.ReadConfigStream(conf_stream, "filepath", error));
         BOOST_CHECK_EQUAL(error, "");
+        std::istringstream single_conf_stream(conf);
+        if (single_parser.ReadConfigStream(single_conf_stream, "filepath", error)) {
+            BOOST_CHECK_EQUAL(error, "");
+        } else {
+            BOOST_CHECK(!error.empty());
+        }
 
         if (soft_set) {
             desc += " soft";
             parser.SoftSetArg(key, "soft1");
             parser.SoftSetArg(key, "soft2");
+            single_parser.SoftSetArg(key, "soft1");
+            single_parser.SoftSetArg(key, "soft2");
         }
 
         if (force_set) {
             desc += " force";
             parser.ForceSetArg(key, "force1");
             parser.ForceSetArg(key, "force2");
+            single_parser.ForceSetArg(key, "force1");
+            single_parser.ForceSetArg(key, "force2");
         }
 
         desc += " || ";
@@ -1452,14 +1470,32 @@ BOOST_FIXTURE_TEST_CASE(util_ArgsMerge, ArgsMergeTestingSetup)
         if (!parser.IsArgSet(key)) {
             desc += "unset";
             BOOST_CHECK(!parser.IsArgNegated(key));
-            BOOST_CHECK_EQUAL(parser.TestArgString(key, "default"), "default");
             BOOST_CHECK(parser.GetArgs(key).empty());
+            if (error.empty()) {
+                BOOST_CHECK(!single_parser.IsArgSet(key));
+                BOOST_CHECK(!single_parser.IsArgNegated(key));
+                BOOST_CHECK_EQUAL(single_parser.GetArg(key, "default"), "default");
+            } else {
+                desc += " / ";
+                desc += error;
+            }
         } else if (parser.IsArgNegated(key)) {
             desc += "negated";
-            BOOST_CHECK_EQUAL(parser.TestArgString(key, "default"), "0");
             BOOST_CHECK(parser.GetArgs(key).empty());
+            if (error.empty()) {
+                BOOST_CHECK(single_parser.IsArgSet(key));
+                BOOST_CHECK(single_parser.IsArgNegated(key));
+                BOOST_CHECK_EQUAL(single_parser.GetArg(key, "default"), "0");
+            } else {
+                desc += " / ";
+                desc += error;
+            }
         } else {
-            desc += parser.TestArgString(key, "default");
+            if (error.empty()) {
+                desc += single_parser.GetArg(key, "default");
+            } else {
+                desc += error;
+            }
             desc += " |";
             for (const auto& arg : parser.GetArgs(key)) {
                 desc += " ";
@@ -1502,7 +1538,7 @@ BOOST_FIXTURE_TEST_CASE(util_ArgsMerge, ArgsMergeTestingSetup)
     // Results file is formatted like:
     //
     //   <input> || <IsArgSet/IsArgNegated/GetArg output> | <GetArgs output> | <GetUnsuitable output>
-    BOOST_CHECK_EQUAL(out_sha_hex, "f1ee5ab094cc43d16a6086fa7f2c10389e0f99902616b31bbf29189972ad1473");
+    BOOST_CHECK_EQUAL(out_sha_hex, "28b16f794dc598d39c3bc558cb8ed3b7bfbdb442ea118684627b520c8be9ec75");
 }
 
 // Similar test as above, but for ArgsManager::GetChainTypeString function.