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
128
129
130
131
|
// 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 "boosttestconfiguration.h"
#include "boosttestoutputreader.h"
#include "boosttestsettings.h"
#include "../autotestplugin.h"
#include "../itestframework.h"
#include "../testsettings.h"
#include <utils/algorithm.h>
#include <utils/stringutils.h>
using namespace Utils;
namespace Autotest {
namespace Internal {
TestOutputReader *BoostTestConfiguration::createOutputReader(
const QFutureInterface<TestResult> &fi, QtcProcess *app) const
{
auto settings = static_cast<BoostTestSettings *>(framework()->testSettings());
return new BoostTestOutputReader(fi, app, buildDirectory(), projectFile(),
LogLevel(settings->logLevel.value()),
ReportLevel(settings->reportLevel.value()));
}
enum class InterferingType { Options, EnvironmentVariables };
static QStringList interfering(InterferingType type)
{
const QStringList knownInterfering { "log_level", "log_format", "log_sink",
"report_level", "report_format", "report_sink",
"output_format",
"catch_system_errors", "no_catch_system_errors",
"detect_fp_exceptions", "no_detect_fp_exceptions",
"detect_memory_leaks", "random", "run_test",
"show_progress", "result_code", "no_result_code",
"help", "list_content", "list_labels", "version"
};
switch (type) {
case InterferingType::Options:
return Utils::transform(knownInterfering, [](const QString &item) {
return QString("--" + item);
});
case InterferingType::EnvironmentVariables:
return Utils::transform(knownInterfering, [](const QString &item) {
return QString("BOOST_TEST_" + item).toUpper();
});
}
return QStringList();
}
static QStringList filterInterfering(const QStringList &provided, QStringList *omitted)
{
const QStringList knownInterfering = interfering(InterferingType::Options);
const QString interferingSingleWithParam = "efklortcpsx?";
QStringList allowed;
bool filterNextArg = false;
bool ignoreRest = false;
for (const auto &arg : provided) {
bool filterArg = filterNextArg;
filterNextArg = false;
if (ignoreRest) {
allowed.append(arg);
continue;
}
bool interferes = false;
if (filterArg && !arg.startsWith('-')) {
interferes = true;
} else if (arg.startsWith("--")) {
if (arg.size() == 2)
ignoreRest = true;
else
interferes = knownInterfering.contains(arg.left(arg.indexOf('=')));
} else if (arg.startsWith('-') && arg.size() > 1) {
interferes = interferingSingleWithParam.contains(arg.at(1));
filterNextArg = interferes;
}
if (!interferes)
allowed.append(arg);
else if (omitted)
omitted->append(arg);
}
return allowed;
}
QStringList BoostTestConfiguration::argumentsForTestRunner(QStringList *omitted) const
{
auto boostSettings = static_cast<BoostTestSettings *>(framework()->testSettings());
QStringList arguments;
arguments << "-l" << BoostTestSettings::logLevelToOption(LogLevel(boostSettings->logLevel.value()));
arguments << "-r" << BoostTestSettings::reportLevelToOption(ReportLevel(boostSettings->reportLevel.value()));
if (boostSettings->randomize.value())
arguments << QString("--random=").append(QString::number(boostSettings->seed.value()));
if (boostSettings->systemErrors.value())
arguments << "-s";
if (boostSettings->fpExceptions.value())
arguments << "--detect_fp_exceptions";
if (!boostSettings->memLeaks.value())
arguments << "--detect_memory_leaks=0";
// TODO improve the test case gathering and arguments building to avoid too long command lines
for (const QString &test : testCases())
arguments << "-t" << test;
if (AutotestPlugin::settings()->processArgs) {
arguments << filterInterfering(runnable().command.arguments().split(
' ', Qt::SkipEmptyParts), omitted);
}
return arguments;
}
Environment BoostTestConfiguration::filteredEnvironment(const Environment &original) const
{
const QStringList interferingEnv = interfering(InterferingType::EnvironmentVariables);
Environment result = original;
if (!result.hasKey("BOOST_TEST_COLOR_OUTPUT"))
result.set("BOOST_TEST_COLOR_OUTPUT", "1"); // use colored output by default
for (const QString &key : interferingEnv)
result.unset(key);
return result;
}
} // namespace Internal
} // namespace Autotest
|
