AutoTest: Dissolve TestFrameworkManager

It's a handful functions around two independent lists.

Change-Id: I0a7015deef27a77d4e67488e1f9b6c7a8d71133b
Reviewed-by: Christian Stenger <christian.stenger@qt.io>

src/plugins/autotest/autotestplugin.cpp

@@ -99,7 +99,6 @@ public:
     TestCodeParser m_testCodeParser;
     TestTreeModel m_testTreeModel{&m_testCodeParser};
     TestRunner m_testRunner;
-    TestFrameworkManager m_frameworkManager;
 #ifdef WITH_TESTS
     LoadProjectScenario m_loadProjectScenario{&m_testTreeModel};
 #endif
@@ -128,15 +127,15 @@ AutotestPluginPrivate::AutotestPluginPrivate()
 {
     dd = this; // Needed as the code below access it via the static plugin interface
     initializeMenuEntries();
-    m_frameworkManager.registerTestFramework(&theQtTestFramework());
-    m_frameworkManager.registerTestFramework(&theQuickTestFramework());
-    m_frameworkManager.registerTestFramework(&theGTestFramework());
-    m_frameworkManager.registerTestFramework(&theBoostTestFramework());
-    m_frameworkManager.registerTestFramework(&theCatchFramework());
+    TestFrameworkManager::registerTestFramework(&theQtTestFramework());
+    TestFrameworkManager::registerTestFramework(&theQuickTestFramework());
+    TestFrameworkManager::registerTestFramework(&theGTestFramework());
+    TestFrameworkManager::registerTestFramework(&theBoostTestFramework());
+    TestFrameworkManager::registerTestFramework(&theCatchFramework());
 
-    m_frameworkManager.registerTestTool(&theCTestTool());
+    TestFrameworkManager::registerTestTool(&theCTestTool());
+    TestFrameworkManager::synchronizeSettings();
 
-    m_frameworkManager.synchronizeSettings();
     m_resultsPane = TestResultsPane::instance();
 
     auto panelFactory = new ProjectExplorer::ProjectPanelFactory();

src/plugins/autotest/testframeworkmanager.cpp

@@ -11,92 +11,89 @@
 
 using namespace Utils;
 
-namespace Autotest {
+namespace Autotest::TestFrameworkManager {
 
-static TestFrameworkManager *s_instance = nullptr;
-
-TestFrameworkManager::TestFrameworkManager()
+TestFrameworks &testFrameworks()
 {
-    s_instance = this;
+    static TestFrameworks theFrameworks;
+    return theFrameworks;
 }
 
-TestFrameworkManager::~TestFrameworkManager()
+TestTools &testTools()
 {
-    s_instance = nullptr;
+    static TestTools theTools;
+    return theTools;
 }
 
-void TestFrameworkManager::registerTestFramework(ITestFramework *framework)
+void registerTestFramework(ITestFramework *framework)
 {
     QTC_ASSERT(framework, return);
-    QTC_ASSERT(!m_registeredFrameworks.contains(framework), return);
+    QTC_ASSERT(!testFrameworks().contains(framework), return);
     // TODO check for unique priority before registering
-    m_registeredFrameworks.append(framework);
-    Utils::sort(m_registeredFrameworks, &ITestFramework::priority);
+    testFrameworks().append(framework);
+    Utils::sort(testFrameworks(), &ITestFramework::priority);
 }
 
-void TestFrameworkManager::registerTestTool(ITestTool *testTool)
+void registerTestTool(ITestTool *testTool)
 {
     QTC_ASSERT(testTool, return);
-    QTC_ASSERT(!m_registeredTestTools.contains(testTool), return);
-    m_registeredTestTools.append(testTool);
+    QTC_ASSERT(!testTools().contains(testTool), return);
+    testTools().append(testTool);
 }
 
-void TestFrameworkManager::activateFrameworksAndToolsFromSettings()
+void activateFrameworksAndToolsFromSettings()
 {
     const Internal::TestSettings &settings = Internal::testSettings();
-    for (ITestFramework *framework : std::as_const(s_instance->m_registeredFrameworks)) {
+    for (ITestFramework *framework : std::as_const(testFrameworks())) {
         framework->setActive(settings.frameworks.value(framework->id(), false));
         framework->setGrouping(settings.frameworksGrouping.value(framework->id(), false));
     }
-    for (ITestTool *testTool : std::as_const(s_instance->m_registeredTestTools))
+    for (ITestTool *testTool : std::as_const(testTools()))
         testTool->setActive(settings.tools.value(testTool->id(), false));
 }
 
-const TestFrameworks TestFrameworkManager::registeredFrameworks()
+const TestFrameworks registeredFrameworks()
 {
-    return s_instance->m_registeredFrameworks;
+    return testFrameworks();
 }
 
-const TestTools TestFrameworkManager::registeredTestTools()
+const TestTools registeredTestTools()
 {
-    return s_instance->m_registeredTestTools;
+    return testTools();
 }
 
-ITestFramework *TestFrameworkManager::frameworkForId(Id frameworkId)
+ITestFramework *frameworkForId(Id frameworkId)
 {
-    return Utils::findOrDefault(s_instance->m_registeredFrameworks,
-            [frameworkId](ITestFramework *framework) {
+    return Utils::findOrDefault(testFrameworks(), [frameworkId](ITestFramework *framework) {
                 return framework->id() == frameworkId;
     });
 }
 
-ITestTool *TestFrameworkManager::testToolForId(Id testToolId)
+ITestTool *testToolForId(Id testToolId)
 {
-    return Utils::findOrDefault(s_instance->m_registeredTestTools,
-            [testToolId](ITestTool *testTool) {
+    return Utils::findOrDefault(testTools(), [testToolId](ITestTool *testTool) {
                 return testTool->id() == testToolId;
     });
 }
 
-ITestTool *TestFrameworkManager::testToolForBuildSystemId(Id buildSystemId)
+ITestTool *testToolForBuildSystemId(Id buildSystemId)
 {
     if (!buildSystemId.isValid())
         return nullptr;
 
-    return Utils::findOrDefault(s_instance->m_registeredTestTools,
-                                [&buildSystemId](ITestTool *testTool) {
+    return Utils::findOrDefault(testTools(), [&buildSystemId](ITestTool *testTool) {
         return testTool->buildSystemId() == buildSystemId;
     });
 }
 
-void TestFrameworkManager::synchronizeSettings()
+void synchronizeSettings()
 {
     Internal::testSettings().fromSettings();
-    for (ITestFramework *framework : std::as_const(m_registeredFrameworks))
+    for (ITestFramework *framework : std::as_const(testFrameworks()))
         framework->readSettings();
 
-    for (ITestTool *testTool : std::as_const(m_registeredTestTools))
+    for (ITestTool *testTool : std::as_const(testTools()))
         testTool->readSettings();
 }
 
-} // namespace Autotest
+} // Autotest::TestframeworkManager

src/plugins/autotest/testframeworkmanager.h

@@ -5,29 +5,18 @@
 
 #include "itestframework.h"
 
-namespace Autotest {
-
-class TestFrameworkManager final
-{
-
-public:
-    TestFrameworkManager();
-    ~TestFrameworkManager();
+namespace Autotest::TestFrameworkManager {
 
 void registerTestFramework(ITestFramework *framework);
 void registerTestTool(ITestTool *testTool);
 void synchronizeSettings();
 
-    static ITestFramework *frameworkForId(Utils::Id frameworkId);
-    static ITestTool *testToolForId(Utils::Id testToolId);
-    static ITestTool *testToolForBuildSystemId(Utils::Id buildSystemId);
-    static void activateFrameworksAndToolsFromSettings();
-    static const TestFrameworks registeredFrameworks();
-    static const TestTools registeredTestTools();
+ITestFramework *frameworkForId(Utils::Id frameworkId);
+ITestTool *testToolForId(Utils::Id testToolId);
+ITestTool *testToolForBuildSystemId(Utils::Id buildSystemId);
+void activateFrameworksAndToolsFromSettings();
+const TestFrameworks registeredFrameworks();
+const TestTools registeredTestTools();
 
-private:
-    TestFrameworks m_registeredFrameworks;
-    TestTools m_registeredTestTools;
-};
 
-} // namespace Autotest
+} // Autotest::TestFrameworkManager