SL-17483: Add integration test for CommonControl

and for LLViewerControlListener, to which it talks.

Fix glitches detected by the tests.

4 files changed, 215 insertions, 17 deletions

diff --git a/indra/llcommon/commoncontrol.cpp b/indra/llcommon/commoncontrol.cpp
index 2c2a2abeb0..81e66baf8c 100644
--- a/indra/llcommon/commoncontrol.cpp
+++ b/indra/llcommon/commoncontrol.cpp
@@ -51,6 +51,8 @@ LLSD LL::CommonControl::access(const LLSD& params)
     {
         LLTHROW(ParamError(error));
     }
+    response.erase("error");
+    response.erase("reqid");
     return response;
 }
 
diff --git a/indra/llcommon/threadpool.cpp b/indra/llcommon/threadpool.cpp
index e8daf549ef..f49dd40a8b 100644
--- a/indra/llcommon/threadpool.cpp
+++ b/indra/llcommon/threadpool.cpp
@@ -93,27 +93,36 @@ void LL::ThreadPool::run()
 //static
 size_t LL::ThreadPool::getConfiguredWidth(const std::string& name, size_t dft)
 {
-    LLSD poolSizes{ LL::CommonControl::get("Global", "ThreadPoolSizes") };
-    // "ThreadPoolSizes" is actually a map containing the sizes of interest --
-    // or should be, if this process has an "LLViewerControl" LLEventAPI
-    // instance and its settings include "ThreadPoolSizes". If we failed to
-    // retrieve it, perhaps we're in a program that doesn't define that, or
-    // perhaps there's no such setting, or perhaps we're asking too early,
-    // before the LLEventAPI itself has been instantiated. In any of those
-    // cases, it seems worth warning.
-    if (! poolSizes.isDefined())
+    LLSD poolSizes;
+    try
     {
-        // Note: we don't warn about absence of an override key for a
-        // particular ThreadPool name, that's fine. This warning is about
-        // complete absence of a ThreadPoolSizes setting, which we expect in a
-        // normal viewer session.
-        LL_WARNS("ThreadPool") << "No 'ThreadPoolSizes' setting for ThreadPool '"
-                               << name << "'" << LL_ENDL;
+        poolSizes = LL::CommonControl::get("Global", "ThreadPoolSizes");
+        // "ThreadPoolSizes" is actually a map containing the sizes of
+        // interest -- or should be, if this process has an
+        // LLViewerControlListener instance and its settings include
+        // "ThreadPoolSizes". If we failed to retrieve it, perhaps we're in a
+        // program that doesn't define that, or perhaps there's no such
+        // setting, or perhaps we're asking too early, before the LLEventAPI
+        // itself has been instantiated. In any of those cases, it seems worth
+        // warning.
+        if (! poolSizes.isDefined())
+        {
+            // Note: we don't warn about absence of an override key for a
+            // particular ThreadPool name, that's fine. This warning is about
+            // complete absence of a ThreadPoolSizes setting, which we expect
+            // in a normal viewer session.
+            LL_WARNS("ThreadPool") << "No 'ThreadPoolSizes' setting for ThreadPool '"
+                                   << name << "'" << LL_ENDL;
+        }
     }
-    else
+    catch (const LL::CommonControl::Error& exc)
     {
-        LL_DEBUGS("ThreadPool") << "ThreadPoolSizes = " << poolSizes << LL_ENDL;
+        // We don't want ThreadPool to *require* LLViewerControlListener.
+        // Just log it and carry on.
+        LL_WARNS("ThreadPool") << "Can't check 'ThreadPoolSizes': " << exc.what() << LL_ENDL;
     }
+
+    LL_DEBUGS("ThreadPool") << "ThreadPoolSizes = " << poolSizes << LL_ENDL;
     // LLSD treats an undefined value as an empty map when asked to retrieve a
     // key, so we don't need this to be conditional.
     LLSD sizeSpec{ poolSizes[name] };
diff --git a/indra/newview/CMakeLists.txt b/indra/newview/CMakeLists.txt
index c253eca94e..f13ce85495 100644
--- a/indra/newview/CMakeLists.txt
+++ b/indra/newview/CMakeLists.txt
@@ -2506,6 +2506,19 @@ if (LL_TESTS)
     "${test_libs}"
     )
 
+  set(llviewercontrollistener_test_sources
+    llviewercontrollistener.cpp
+    ../llxml/llcontrol.cpp
+    ../llxml/llxmltree.cpp
+    ../llxml/llxmlparser.cpp
+    ../llcommon/commoncontrol.cpp
+    )
+
+  LL_ADD_INTEGRATION_TEST(llviewercontrollistener
+    "${llviewercontrollistener_test_sources}"
+    "${test_libs}"
+    )
+
   LL_ADD_INTEGRATION_TEST(llviewernetwork
      llviewernetwork.cpp
     "${test_libs}"
diff --git a/indra/newview/tests/llviewercontrollistener_test.cpp b/indra/newview/tests/llviewercontrollistener_test.cpp
new file mode 100644
index 0000000000..6d100ef984
--- /dev/null
+++ b/indra/newview/tests/llviewercontrollistener_test.cpp
@@ -0,0 +1,174 @@
+/**
+ * @file   llviewercontrollistener_test.cpp
+ * @author Nat Goodspeed
+ * @date   2022-06-09
+ * @brief  Test for llviewercontrollistener.
+ * 
+ * $LicenseInfo:firstyear=2022&license=viewerlgpl$
+ * Copyright (c) 2022, Linden Research, Inc.
+ * $/LicenseInfo$
+ */
+
+// Precompiled header
+#include "llviewerprecompiledheaders.h"
+// associated header
+#include "llviewercontrollistener.h"
+// STL headers
+// std headers
+// external library headers
+// other Linden headers
+#include "../test/lltut.h"
+#include "../test/catch_and_store_what_in.h" // catch_what()
+#include "commoncontrol.h"
+#include "llcontrol.h"              // LLControlGroup
+#include "llviewercontrollistener.h"
+
+/*****************************************************************************
+*   TUT
+*****************************************************************************/
+namespace tut
+{
+    void ensure_contains(const std::string& msg, const std::string& substr)
+    {
+        ensure_contains("Exception does not contain " + substr, msg, substr);
+    }
+
+    struct llviewercontrollistener_data
+    {
+        LLControlGroup Global{"FakeGlobal"};
+
+        llviewercontrollistener_data()
+        {
+            Global.declareString("strvar", "woof", "string variable");
+            // together we will stroll the boolvar, ma cherie
+            Global.declareBOOL("boolvar",  TRUE, "bool variable");
+        }
+    };
+    typedef test_group<llviewercontrollistener_data> llviewercontrollistener_group;
+    typedef llviewercontrollistener_group::object object;
+    llviewercontrollistener_group llviewercontrollistenergrp("llviewercontrollistener");
+
+    template<> template<>
+    void object::test<1>()
+    {
+        set_test_name("CommonControl no listener");
+        // Not implemented: the linker drags in LLViewerControlListener when
+        // we bring in LLViewerControl.
+    }
+
+    template<> template<>
+    void object::test<2>()
+    {
+        set_test_name("CommonControl bad group");
+        std::string threw{ catch_what<LL::CommonControl::ParamError>(
+                [](){ LL::CommonControl::get("Nonexistent", "Variable"); }) };
+        ensure_contains(threw, "group");
+        ensure_contains(threw, "Nonexistent");
+    }
+
+    template<> template<>
+    void object::test<3>()
+    {
+        set_test_name("CommonControl bad variable");
+        std::string threw{ catch_what<LL::CommonControl::ParamError>(
+                [](){ LL::CommonControl::get("FakeGlobal", "Nonexistent"); }) };
+        ensure_contains(threw, "key");
+        ensure_contains(threw, "Nonexistent");
+    }
+
+    template<> template<>
+    void object::test<4>()
+    {
+        set_test_name("CommonControl toggle string");
+        std::string threw{ catch_what<LL::CommonControl::ParamError>(
+                [](){ LL::CommonControl::toggle("FakeGlobal", "strvar"); }) };
+        ensure_contains(threw, "non-boolean");
+        ensure_contains(threw, "strvar");
+    }
+
+    template<> template<>
+    void object::test<5>()
+    {
+        set_test_name("CommonControl list bad group");
+        std::string threw{ catch_what<LL::CommonControl::ParamError>(
+                [](){ LL::CommonControl::get_vars("Nonexistent"); }) };
+        ensure_contains(threw, "group");
+        ensure_contains(threw, "Nonexistent");
+    }
+
+    template<> template<>
+    void object::test<6>()
+    {
+        set_test_name("CommonControl get");
+        auto strvar{ LL::CommonControl::get("FakeGlobal", "strvar") };
+        ensure_equals(strvar, "woof");
+        auto boolvar{ LL::CommonControl::get("FakeGlobal", "boolvar") };
+        ensure(boolvar);
+    }
+
+    template<> template<>
+    void object::test<7>()
+    {
+        set_test_name("CommonControl set, set_default, toggle");
+
+        std::string newstr{ LL::CommonControl::set("FakeGlobal", "strvar", "mouse").asString() };
+        ensure_equals(newstr, "mouse");
+        ensure_equals(LL::CommonControl::get("FakeGlobal", "strvar").asString(), "mouse");
+        ensure_equals(LL::CommonControl::set_default("FakeGlobal", "strvar").asString(), "woof");
+
+        bool newbool{ LL::CommonControl::set("FakeGlobal", "boolvar", false) };
+        ensure(! newbool);
+        ensure(! LL::CommonControl::get("FakeGlobal", "boolvar").asBoolean());
+        ensure(LL::CommonControl::set_default("FakeGlobal", "boolvar").asBoolean());
+        ensure(! LL::CommonControl::toggle("FakeGlobal", "boolvar").asBoolean());
+    }
+
+    template<> template<>
+    void object::test<8>()
+    {
+        set_test_name("CommonControl get_def");
+        LLSD def{ LL::CommonControl::get_def("FakeGlobal", "strvar") };
+        ensure_equals(
+            def,
+            llsd::map("name", "strvar",
+                      "type", "String",
+                      "value", "woof",
+                      "comment", "string variable"));
+    }
+
+    template<> template<>
+    void object::test<9>()
+    {
+        set_test_name("CommonControl get_groups");
+        std::vector<std::string> groups{ LL::CommonControl::get_groups() };
+        ensure_equals(groups.size(), 1);
+        ensure_equals(groups[0], "FakeGlobal");
+    }
+
+    template<> template<>
+    void object::test<10>()
+    {
+        set_test_name("CommonControl get_vars");
+        LLSD vars{ LL::CommonControl::get_vars("FakeGlobal") };
+        // convert from array (unpredictable order) to map
+        LLSD varsmap{ LLSD::emptyMap() };
+        for (auto& var : llsd::inArray(vars))
+        {
+            varsmap[var["name"].asString()] = var;
+        }
+        // comparing maps is order-insensitive
+        ensure_equals(
+            varsmap,
+            llsd::map(
+                "strvar",
+                llsd::map("name", "strvar",
+                          "type", "String",
+                          "value", "woof",
+                          "comment", "string variable"),
+                "boolvar",
+                llsd::map("name", "boolvar",
+                          "type", "Boolean",
+                          "value", TRUE,
+                          "comment", "bool variable")));
+    }
+} // namespace tut