AutoTest: Merge settings and tools hierarchies [2/2]

Renaming files to match class names.

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

src/plugins/autotest/qtest/qttestframework.cpp

@@ -0,0 +1,169 @@
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
+
+#include "qttestframework.h"
+
+#include "../autotestconstants.h"
+#include "../autotesttr.h"
+#include "qttestconstants.h"
+#include "qttestparser.h"
+#include "qttesttreeitem.h"
+
+#include <coreplugin/dialogs/ioptionspage.h>
+
+#include <utils/hostosinfo.h>
+#include <utils/layoutbuilder.h>
+
+using namespace Layouting;
+using namespace Utils;
+
+namespace Autotest::Internal {
+
+QtTestFramework &theQtTestFramework()
+{
+    static QtTestFramework framework;
+    return framework;
+}
+
+QtTestFramework::QtTestFramework() : ITestFramework(true)
+{
+    setSettingsGroups("Autotest", "QtTest");
+
+    setLayouter([this] {
+        return Row { Form {
+            noCrashHandler, br,
+            useXMLOutput, br,
+            verboseBench, br,
+            logSignalsSlots, br,
+            limitWarnings, maxWarnings, br,
+            Group {
+                title(Tr::tr("Benchmark Metrics")),
+                Column { metrics }
+            }, br,
+            quickCheckForDerivedTests, br
+        }, st };
+    });
+
+    metrics.setSettingsKey("Metrics");
+    metrics.setDefaultValue(Walltime);
+    metrics.addOption(Tr::tr("Walltime"), Tr::tr("Uses walltime metrics for executing benchmarks (default)."));
+    metrics.addOption(Tr::tr("Tick counter"), Tr::tr("Uses tick counter when executing benchmarks."));
+    metrics.addOption(Tr::tr("Event counter"), Tr::tr("Uses event counter when executing benchmarks."));
+    metrics.addOption({
+        Tr::tr("Callgrind"),
+        Tr::tr("Uses Valgrind Callgrind when executing benchmarks (it must be installed)."),
+        HostOsInfo::isAnyUnixHost()  // valgrind available on UNIX
+    });
+    metrics.addOption({
+        Tr::tr("Perf"),
+        Tr::tr("Uses Perf when executing benchmarks (it must be installed)."),
+        HostOsInfo::isLinuxHost() // according to docs perf Linux only
+    });
+
+    noCrashHandler.setSettingsKey("NoCrashhandlerOnDebug");
+    noCrashHandler.setDefaultValue(true);
+    noCrashHandler.setLabelText(Tr::tr("Disable crash handler while debugging"));
+    noCrashHandler.setToolTip(Tr::tr("Enables interrupting tests on assertions."));
+
+    useXMLOutput.setSettingsKey("UseXMLOutput");
+    useXMLOutput.setDefaultValue(true);
+    useXMLOutput.setLabelText(Tr::tr("Use XML output"));
+    useXMLOutput.setToolTip(Tr::tr("XML output is recommended, because it avoids parsing issues, "
+                                   "while plain text is more human readable.\n\nWarning: "
+                                   "Plain text misses some information, such as duration."));
+
+    verboseBench.setSettingsKey("VerboseBench");
+    verboseBench.setLabelText(Tr::tr("Verbose benchmarks"));
+
+    logSignalsSlots.setSettingsKey("LogSignalsSlots");
+    logSignalsSlots.setLabelText(Tr::tr("Log signals and slots"));
+    logSignalsSlots.setToolTip(Tr::tr("Log every signal emission and resulting slot invocations."));
+
+    limitWarnings.setSettingsKey("LimitWarnings");
+    limitWarnings.setLabelText(Tr::tr("Limit warnings"));
+    limitWarnings.setToolTip(Tr::tr("Set the maximum number of warnings. 0 means that the number "
+                                "is not limited."));
+
+    maxWarnings.setSettingsKey("MaxWarnings");
+    maxWarnings.setRange(0, 10000);
+    maxWarnings.setDefaultValue(2000);
+    maxWarnings.setSpecialValueText(Tr::tr("Unlimited"));
+    maxWarnings.setEnabler(&limitWarnings);
+
+    quickCheckForDerivedTests.setSettingsKey("QuickCheckForDerivedTests");
+    quickCheckForDerivedTests.setDefaultValue(false);
+    quickCheckForDerivedTests.setLabelText(Tr::tr("Check for derived Qt Quick tests"));
+    quickCheckForDerivedTests.setToolTip(
+        Tr::tr("Search for Qt Quick tests that are derived from TestCase.\nWarning: Enabling this "
+               "feature significantly increases scan time."));
+}
+
+QString QtTestFramework::metricsTypeToOption(const MetricsType type)
+{
+    switch (type) {
+    case MetricsType::Walltime:
+        return {};
+    case MetricsType::TickCounter:
+        return QString("-tickcounter");
+    case MetricsType::EventCounter:
+        return QString("-eventcounter");
+    case MetricsType::CallGrind:
+        return QString("-callgrind");
+    case MetricsType::Perf:
+        return QString("-perf");
+    }
+    return {};
+}
+
+ITestParser *QtTestFramework::createTestParser()
+{
+    return new QtTestParser(this);
+}
+
+ITestTreeItem *QtTestFramework::createRootNode()
+{
+    return new QtTestTreeItem(this, displayName(), {}, ITestTreeItem::Root);
+}
+
+const char *QtTestFramework::name() const
+{
+    return QtTest::Constants::FRAMEWORK_NAME;
+}
+
+QString QtTestFramework::displayName() const
+{
+    return Tr::tr(QtTest::Constants::FRAMEWORK_SETTINGS_CATEGORY);
+}
+
+unsigned QtTestFramework::priority() const
+{
+    return QtTest::Constants::FRAMEWORK_PRIORITY;
+}
+
+QStringList QtTestFramework::testNameForSymbolName(const QString &symbolName) const
+{
+    int index = symbolName.lastIndexOf("::");
+    if (index == -1)
+        return {};
+    return { symbolName.left(index), symbolName.mid(index + 2) };
+}
+
+// QtTestSettingsPage
+
+class QtTestSettingPage final : public Core::IOptionsPage
+{
+public:
+    QtTestSettingPage()
+    {
+        setId(Id(Constants::SETTINGSPAGE_PREFIX).withSuffix(QString("%1.%2")
+            .arg(QtTest::Constants::FRAMEWORK_PRIORITY)
+            .arg(QtTest::Constants::FRAMEWORK_NAME)));
+        setCategory(Constants::AUTOTEST_SETTINGS_CATEGORY);
+        setDisplayName(Tr::tr(QtTest::Constants::FRAMEWORK_SETTINGS_CATEGORY));
+        setSettingsProvider([] { return &theQtTestFramework(); });
+    }
+};
+
+const QtTestSettingPage settingsPage;
+
+} // Autotest::Internal