1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
|
// Copyright (C) 2019 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
#include "testprojectsettings.h"
#include "autotestconstants.h"
#include "testcodeparser.h"
#include "testframeworkmanager.h"
#include "testtreemodel.h"
#include <projectexplorer/project.h>
#include <projectexplorer/projectmanager.h>
#include <utils/algorithm.h>
#include <QLoggingCategory>
using namespace Utils;
namespace Autotest {
namespace Internal {
static const char SK_ACTIVE_FRAMEWORKS[] = "AutoTest.ActiveFrameworks";
static const char SK_RUN_AFTER_BUILD[] = "AutoTest.RunAfterBuild";
static const char SK_CHECK_STATES[] = "AutoTest.CheckStates";
static const char SK_APPLY_FILTER[] = "AutoTest.ApplyFilter";
static const char SK_PATH_FILTERS[] = "AutoTest.PathFilters";
static Q_LOGGING_CATEGORY(LOG, "qtc.autotest.projectsettings", QtWarningMsg)
TestProjectSettings::TestProjectSettings(ProjectExplorer::Project *project)
: m_project(project)
{
load();
connect(project, &ProjectExplorer::Project::settingsLoaded,
this, &TestProjectSettings::load);
connect(project, &ProjectExplorer::Project::aboutToSaveSettings,
this, &TestProjectSettings::save);
}
TestProjectSettings::~TestProjectSettings()
{
save();
}
void TestProjectSettings::setUseGlobalSettings(bool useGlobal)
{
if (m_useGlobalSettings == useGlobal)
return;
m_useGlobalSettings = useGlobal;
}
void TestProjectSettings::activateFramework(const Id &id, bool activate)
{
ITestFramework *framework = TestFrameworkManager::frameworkForId(id);
m_activeTestFrameworks[framework] = activate;
if (TestTreeModel::instance()->parser()->isParsing())
framework->rootNode()->markForRemoval(!activate);
else if (!activate)
framework->resetRootNode();
}
void TestProjectSettings::activateTestTool(const Id &id, bool activate)
{
ITestTool *testTool = TestFrameworkManager::testToolForId(id);
m_activeTestTools[testTool] = activate;
if (!activate)
testTool->resetRootNode();
}
void TestProjectSettings::load()
{
const QVariant useGlobal = m_project->namedSettings(Constants::SK_USE_GLOBAL);
m_useGlobalSettings = useGlobal.isValid() ? useGlobal.toBool() : true;
const TestFrameworks registeredFrameworks = TestFrameworkManager::registeredFrameworks();
qCDebug(LOG) << "Registered frameworks sorted by priority" << registeredFrameworks;
const TestTools registeredTestTools = TestFrameworkManager::registeredTestTools();
const QVariant activeFrameworks = m_project->namedSettings(SK_ACTIVE_FRAMEWORKS);
m_activeTestFrameworks.clear();
m_activeTestTools.clear();
if (activeFrameworks.isValid()) {
const Store frameworksMap = storeFromVariant(activeFrameworks);
for (ITestFramework *framework : registeredFrameworks) {
const Id id = framework->id();
bool active = frameworksMap.value(id.toKey(), framework->active()).toBool();
m_activeTestFrameworks.insert(framework, active);
}
for (ITestTool *testTool : registeredTestTools) {
const Id id = testTool->id();
bool active = frameworksMap.value(id.toKey(), testTool->active()).toBool();
m_activeTestTools.insert(testTool, active);
}
} else {
for (ITestFramework *framework : registeredFrameworks)
m_activeTestFrameworks.insert(framework, framework->active());
for (ITestTool *testTool : registeredTestTools)
m_activeTestTools.insert(testTool, testTool->active());
}
const QVariant runAfterBuild = m_project->namedSettings(SK_RUN_AFTER_BUILD);
m_runAfterBuild = runAfterBuild.isValid() ? RunAfterBuildMode(runAfterBuild.toInt())
: RunAfterBuildMode::None;
m_checkStateCache.fromSettings(m_project->namedSettings(SK_CHECK_STATES).toMap());
m_limitToFilter = m_project->namedSettings(SK_APPLY_FILTER).toBool();
m_pathFilters = m_project->namedSettings(SK_PATH_FILTERS).toStringList();
}
void TestProjectSettings::save()
{
m_project->setNamedSettings(Constants::SK_USE_GLOBAL, m_useGlobalSettings);
QVariantMap activeFrameworks;
auto end = m_activeTestFrameworks.cend();
for (auto it = m_activeTestFrameworks.cbegin(); it != end; ++it)
activeFrameworks.insert(it.key()->id().toString(), it.value());
auto endTools = m_activeTestTools.cend();
for (auto it = m_activeTestTools.cbegin(); it != endTools; ++it)
activeFrameworks.insert(it.key()->id().toString(), it.value());
m_project->setNamedSettings(SK_ACTIVE_FRAMEWORKS, activeFrameworks);
m_project->setNamedSettings(SK_RUN_AFTER_BUILD, int(m_runAfterBuild));
m_project->setNamedSettings(SK_CHECK_STATES, m_checkStateCache.toSettings(Qt::Checked));
m_project->setNamedSettings(SK_APPLY_FILTER, m_limitToFilter);
m_project->setNamedSettings(SK_PATH_FILTERS, m_pathFilters);
}
} // namespace Internal
} // namespace Autotest
|
