feedc0de/qt-creator
1
0
Fork 0
forked from qt-creator/qt-creator
Code Pull Requests Activity

Autotest: Partially aspectify autotest settings

Browse Source 
This only handles the storage side, all gui/layouting is left for
follow-up changes.

Change-Id: I0f2b6dc82e5d4374528c8a72610a5afe264a72b1
Reviewed-by: Christian Stenger <christian.stenger@qt.io>
This commit is contained in:
hjk
2021-03-24 12:40:03 +01:00
parent 341132dd0a
commit a202301918
24 changed files with 343 additions and 436 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
src/plugins/autotest/CMakeLists.txt
View File

@@ -43,7 +43,6 @@ add_qtc_plugin(AutoTest
itemdatacache.h
itestframework.cpp itestframework.h
itestparser.cpp itestparser.h
itestsettings.h
projectsettingswidget.cpp projectsettingswidget.h
qtest/qttest_utils.cpp qtest/qttest_utils.h
qtest/qttestconfiguration.cpp qtest/qttestconfiguration.h

1
src/plugins/autotest/autotest.pro
View File

@@ -89,7 +89,6 @@ HEADERS += \
itemdatacache.h \
itestframework.h \
itestparser.h \
itestsettings.h \
projectsettingswidget.h \
testcodeparser.h \
testconfiguration.h \

1
src/plugins/autotest/autotest.qbs
View File

@@ -79,7 +79,6 @@ QtcPlugin {
"itestparser.h",
"itestframework.cpp",
"itestframework.h",
"itestsettings.h",
"testframeworkmanager.cpp",
"testframeworkmanager.h",
"testrunconfiguration.h"

21
src/plugins/autotest/boost/boosttestconfiguration.cpp
View File

@@ -40,9 +40,10 @@ namespace Internal {
TestOutputReader *BoostTestConfiguration::outputReader(const QFutureInterface<TestResultPtr> &fi,
QProcess *app) const
{
auto settings = dynamic_cast<BoostTestSettings *>(framework()->testSettings());
auto settings = static_cast<BoostTestSettings *>(framework()->testSettings());
return new BoostTestOutputReader(fi, app, buildDirectory(), projectFile(),
settings->logLevel, settings->reportLevel);
LogLevel(settings->logLevel.value()),
ReportLevel(settings->reportLevel.value()));
}
enum class InterferingType { Options, EnvironmentVariables };
@@ -107,19 +108,19 @@ static QStringList filterInterfering(const QStringList &provided, QStringList *o
QStringList BoostTestConfiguration::argumentsForTestRunner(QStringList *omitted) const
{
auto boostSettings = dynamic_cast<BoostTestSettings *>(framework()->testSettings());
auto boostSettings = static_cast<BoostTestSettings *>(framework()->testSettings());
QStringList arguments;
arguments << "-l" << BoostTestSettings::logLevelToOption(boostSettings->logLevel);
arguments << "-r" << BoostTestSettings::reportLevelToOption(boostSettings->reportLevel);
arguments << "-l" << BoostTestSettings::logLevelToOption(LogLevel(boostSettings->logLevel.value()));
arguments << "-r" << BoostTestSettings::reportLevelToOption(ReportLevel(boostSettings->reportLevel.value()));
if (boostSettings->randomize)
arguments << QString("--random=").append(QString::number(boostSettings->seed));
if (boostSettings->randomize.value())
arguments << QString("--random=").append(QString::number(boostSettings->seed.value()));
if (boostSettings->systemErrors)
if (boostSettings->systemErrors.value())
arguments << "-s";
if (boostSettings->fpExceptions)
if (boostSettings->fpExceptions.value())
arguments << "--detect_fp_exceptions";
if (!boostSettings->memLeaks)
if (!boostSettings->memLeaks.value())
arguments << "--detect_memory_leaks=0";
// TODO improve the test case gathering and arguments building to avoid too long command lines

54
src/plugins/autotest/boost/boosttestsettings.cpp
View File

@@ -28,40 +28,34 @@
namespace Autotest {
namespace Internal {
static const char logLevelKey[] = "LogLevel";
static const char reportLevelKey[] = "ReportLevel";
static const char seedKey[] = "Seed";
static const char randomizeKey[] = "Randomize";
static const char systemErrorsKey[] = "SystemErrors";
static const char fpExceptionsKey[] = "FPExceptions";
static const char memLeaksKey[] = "MemoryLeaks";
QString BoostTestSettings::name() const
BoostTestSettings::BoostTestSettings()
{
return QString("BoostTest");
}
setSettingsGroups("Autotest", "BoostTest");
setAutoApply(false);
void BoostTestSettings::fromTestSettings(const QSettings *s)
registerAspect(&logLevel);
logLevel.setSettingsKey("LogLevel");
logLevel.setDefaultValue(int(LogLevel::Warning));
{
logLevel = LogLevel((s->value(logLevelKey, int(LogLevel::All)).toInt()));
reportLevel = ReportLevel((s->value(reportLevelKey, int(ReportLevel::Confirm)).toInt()));
systemErrors = s->value(systemErrorsKey, false).toBool();
fpExceptions = s->value(fpExceptionsKey, false).toBool();
memLeaks = s->value(memLeaksKey, true).toBool();
randomize = s->value(randomizeKey, false).toBool();
seed = s->value(seedKey, 0).toInt();
}
registerAspect(&reportLevel);
reportLevel.setSettingsKey("ReportLevel");
reportLevel.setDefaultValue(int(ReportLevel::Confirm));
void BoostTestSettings::toTestSettings(QSettings *s) const
{
s->setValue(logLevelKey, int(logLevel));
s->setValue(reportLevelKey, int(reportLevel));
s->setValue(systemErrorsKey, systemErrors);
s->setValue(fpExceptionsKey, fpExceptions);
s->setValue(memLeaksKey, memLeaks);
s->setValue(randomizeKey, randomize);
s->setValue(seedKey, seed);
registerAspect(&seed);
seed.setSettingsKey("Seed");
registerAspect(&randomize);
randomize.setSettingsKey("Randomize");
registerAspect(&systemErrors);
systemErrors.setSettingsKey("SystemErrors");
registerAspect(&fpExceptions);
fpExceptions.setSettingsKey("FPExceptions");
registerAspect(&memLeaks);
memLeaks.setSettingsKey("MemoryLeaks");
memLeaks.setDefaultValue(true);
}
QString BoostTestSettings::logLevelToOption(const LogLevel logLevel)

26
src/plugins/autotest/boost/boosttestsettings.h
View File

@@ -25,7 +25,7 @@
#pragma once
#include "../itestsettings.h"
#include <utils/aspects.h>
namespace Autotest {
namespace Internal {
@@ -53,25 +53,21 @@ enum class ReportLevel
No
};
class BoostTestSettings : public ITestSettings
class BoostTestSettings : public Utils::AspectContainer
{
public:
BoostTestSettings() = default;
QString name() const override;
BoostTestSettings();
static QString logLevelToOption(const LogLevel logLevel);
static QString reportLevelToOption(const ReportLevel reportLevel);
LogLevel logLevel = LogLevel::Warning;
ReportLevel reportLevel = ReportLevel::Confirm;
int seed = 0;
bool randomize = false;
bool systemErrors = false;
bool fpExceptions = false;
bool memLeaks = true;
protected:
void fromTestSettings(const QSettings *s) override;
void toTestSettings(QSettings *s) const override;
Utils::SelectionAspect logLevel;
Utils::SelectionAspect reportLevel;
Utils::IntegerAspect seed;
Utils::BoolAspect randomize;
Utils::BoolAspect systemErrors;
Utils::BoolAspect fpExceptions;
Utils::BoolAspect memLeaks;
};
} // namespace Internal

31
src/plugins/autotest/boost/boosttestsettingspage.cpp
View File

@@ -27,6 +27,7 @@
#include "boosttestconstants.h"
#include "boosttestsettings.h"
#include "../testframeworkmanager.h"
#include "../autotestconstants.h"
#include "ui_boosttestsettingspage.h"
#include <coreplugin/icore.h>
@@ -59,26 +60,26 @@ BoostTestSettingsWidget::BoostTestSettingsWidget(BoostTestSettings *settings)
fillComboBoxes();
connect(m_ui.randomizeCB, &QCheckBox::toggled, m_ui.seedSB, &QSpinBox::setEnabled);
m_ui.logFormatCB->setCurrentIndex(int(m_settings->logLevel));
m_ui.reportLevelCB->setCurrentIndex(int(m_settings->reportLevel));
m_ui.randomizeCB->setChecked(m_settings->randomize);
m_ui.seedSB->setValue(m_settings->seed);
m_ui.systemErrorCB->setChecked(m_settings->systemErrors);
m_ui.fpExceptions->setChecked(m_settings->fpExceptions);
m_ui.memoryLeakCB->setChecked(m_settings->memLeaks);
m_ui.logFormatCB->setCurrentIndex(m_settings->logLevel.value());
m_ui.reportLevelCB->setCurrentIndex(m_settings->reportLevel.value());
m_ui.randomizeCB->setChecked(m_settings->randomize.value());
m_ui.seedSB->setValue(m_settings->seed.value());
m_ui.systemErrorCB->setChecked(m_settings->systemErrors.value());
m_ui.fpExceptions->setChecked(m_settings->fpExceptions.value());
m_ui.memoryLeakCB->setChecked(m_settings->memLeaks.value());
}
void BoostTestSettingsWidget::apply()
{
m_settings->logLevel = LogLevel(m_ui.logFormatCB->currentData().toInt());
m_settings->reportLevel = ReportLevel(m_ui.reportLevelCB->currentData().toInt());
m_settings->randomize = m_ui.randomizeCB->isChecked();
m_settings->seed = m_ui.seedSB->value();
m_settings->systemErrors = m_ui.systemErrorCB->isChecked();
m_settings->fpExceptions = m_ui.fpExceptions->isChecked();
m_settings->memLeaks = m_ui.memoryLeakCB->isChecked();
m_settings->logLevel.setValue(m_ui.logFormatCB->currentData().toInt());
m_settings->reportLevel.setValue(m_ui.reportLevelCB->currentData().toInt());
m_settings->randomize.setValue(m_ui.randomizeCB->isChecked());
m_settings->seed.setValue(m_ui.seedSB->value());
m_settings->systemErrors.setValue(m_ui.systemErrorCB->isChecked());
m_settings->fpExceptions.setValue(m_ui.fpExceptions->isChecked());
m_settings->memLeaks.setValue(m_ui.memoryLeakCB->isChecked());
m_settings->toSettings(Core::ICore::settings());
m_settings->writeSettings(Core::ICore::settings());
}
void BoostTestSettingsWidget::fillComboBoxes()

34
src/plugins/autotest/catch/catchconfiguration.cpp
View File

@@ -105,32 +105,32 @@ QStringList CatchConfiguration::argumentsForTestRunner(QStringList *omitted) con
' ', Qt::SkipEmptyParts), omitted);
}
auto settings = dynamic_cast<CatchTestSettings *>(framework()->testSettings());
auto settings = static_cast<CatchTestSettings *>(framework()->testSettings());
if (!settings)
return arguments;
if (settings->abortAfterChecked)
arguments << "-x" << QString::number(settings->abortAfter);
if (settings->samplesChecked)
arguments << "--benchmark-samples" << QString::number(settings->benchmarkSamples);
if (settings->resamplesChecked)
arguments << "--benchmark-resamples" << QString::number(settings->benchmarkResamples);
if (settings->warmupChecked)
arguments << "--benchmark-warmup-time" << QString::number(settings->benchmarkWarmupTime);
if (settings->confidenceIntervalChecked)
arguments << "--benchmark-confidence-interval" << QString::number(settings->confidenceInterval);
if (settings->noAnalysis)
if (settings->abortAfterChecked.value())
arguments << "-x" << QString::number(settings->abortAfter.value());
if (settings->samplesChecked.value())
arguments << "--benchmark-samples" << QString::number(settings->benchmarkSamples.value());
if (settings->resamplesChecked.value())
arguments << "--benchmark-resamples" << QString::number(settings->benchmarkResamples.value());
if (settings->warmupChecked.value())
arguments << "--benchmark-warmup-time" << QString::number(settings->benchmarkWarmupTime.value());
if (settings->confidenceIntervalChecked.value())
arguments << "--benchmark-confidence-interval" << QString::number(settings->confidenceInterval.value());
if (settings->noAnalysis.value())
arguments << "--benchmark-no-analysis";
if (settings->showSuccess)
if (settings->showSuccess.value())
arguments << "-s";
if (settings->noThrow)
if (settings->noThrow.value())
arguments << "-e";
if (settings->visibleWhitespace)
if (settings->visibleWhitespace.value())
arguments << "-i";
if (settings->warnOnEmpty)
if (settings->warnOnEmpty.value())
arguments << "-w" << "NoAssertions";
if (isDebugRunMode() && settings->breakOnFailure)
if (isDebugRunMode() && settings->breakOnFailure.value())
arguments << "-b";
return arguments;
}

110
src/plugins/autotest/catch/catchtestsettings.cpp
View File

@@ -28,66 +28,62 @@
namespace Autotest {
namespace Internal {
static const char abortAfterKey[] = "AbortAfter";
static const char abortAfterCheckedKey[] = "AbortChecked";
static const char benchmarkSamplesKey[] = "BenchSamples";
static const char samplesCheckedKey[] = "SamplesChecked";
static const char benchmarkResamplesKey[] = "BenchResamples";
static const char resamplesCheckedKey[] = "ResamplesChecked";
static const char benchmarConfidenceIntervalKey[] = "BenchConfInt";
static const char confIntCheckedKey[] = "ConfIntChecked";
static const char benchmarWarmupTimeKey[] = "BenchWarmup";
static const char warmupCheckedKey[] = "WarmupChecked";
static const char noAnalysisKey[] = "NoAnalysis";
static const char showSuccessKey[] = "ShowSuccess";
static const char breakOnFailureKey[] = "BreakOnFailure";
static const char noThrowKey[] = "NoThrow";
static const char visibleWhitespaceKey[] = "VisibleWS";
static const char warnOnEmptyKey[] = "WarnEmpty";
QString CatchTestSettings::name() const
CatchTestSettings::CatchTestSettings()
{
return QString("Catch2");
}
setSettingsGroups("Autotest", "Catch2");
setAutoApply(false);
void CatchTestSettings::toTestSettings(QSettings *s) const
{
s->setValue(abortAfterCheckedKey, abortAfterChecked);
s->setValue(abortAfterKey, abortAfter);
s->setValue(samplesCheckedKey, samplesChecked);
s->setValue(benchmarkSamplesKey, benchmarkSamples);
s->setValue(resamplesCheckedKey, resamplesChecked);
s->setValue(benchmarkResamplesKey, benchmarkResamples);
s->setValue(confIntCheckedKey, confidenceIntervalChecked);
s->setValue(benchmarConfidenceIntervalKey, confidenceInterval);
s->setValue(warmupCheckedKey, warmupChecked);
s->setValue(benchmarWarmupTimeKey, benchmarkWarmupTime);
s->setValue(noAnalysisKey, noAnalysis);
s->setValue(showSuccessKey, showSuccess);
s->setValue(breakOnFailureKey, breakOnFailure);
s->setValue(noThrowKey, noThrow);
s->setValue(visibleWhitespaceKey, visibleWhitespace);
s->setValue(warnOnEmptyKey, warnOnEmpty);
}
registerAspect(&abortAfter);
abortAfter.setSettingsKey("AbortAfter");
void CatchTestSettings::fromTestSettings(const QSettings *s)
{
abortAfterChecked = s->value(abortAfterCheckedKey, false).toBool();
abortAfter = s->value(abortAfterKey, 0).toInt();
samplesChecked = s->value(samplesCheckedKey, false).toBool();
benchmarkSamples = s->value(benchmarkSamplesKey, 100).toInt();
resamplesChecked = s->value(resamplesCheckedKey, false).toBool();
benchmarkResamples = s->value(benchmarkResamplesKey, 100000).toInt();
confidenceIntervalChecked = s->value(confIntCheckedKey, false).toBool();
confidenceInterval = s->value(benchmarConfidenceIntervalKey, 0.95).toDouble();
warmupChecked = s->value(warmupCheckedKey, false).toBool();
benchmarkWarmupTime = s->value(benchmarWarmupTimeKey, 0).toInt();
noAnalysis = s->value(noAnalysisKey, false).toBool();
showSuccess = s->value(showSuccessKey, false).toBool();
breakOnFailure = s->value(breakOnFailureKey, true).toBool();
noThrow = s->value(noThrowKey, false).toBool();
visibleWhitespace = s->value(visibleWhitespaceKey, false).toBool();
warnOnEmpty = s->value(warnOnEmptyKey, false).toBool();
registerAspect(&benchmarkSamples);
benchmarkSamples.setSettingsKey("BenchSamples");
benchmarkSamples.setDefaultValue(100);
registerAspect(&benchmarkResamples);
benchmarkResamples.setSettingsKey("BenchResamples");
benchmarkResamples.setDefaultValue(100000);
registerAspect(&confidenceInterval);
confidenceInterval.setSettingsKey("BenchConfInt");
confidenceInterval.setDefaultValue(0.95);
registerAspect(&benchmarkWarmupTime);
benchmarkWarmupTime.setSettingsKey("BenchWarmup");
registerAspect(&abortAfterChecked);
abortAfterChecked.setSettingsKey("AbortChecked");
registerAspect(&samplesChecked);
samplesChecked.setSettingsKey("SamplesChecked");
registerAspect(&resamplesChecked);
resamplesChecked.setSettingsKey("ResamplesChecked");
registerAspect(&confidenceIntervalChecked);
confidenceIntervalChecked.setSettingsKey("ConfIntChecked");
registerAspect(&warmupChecked);
warmupChecked.setSettingsKey("WarmupChecked");
registerAspect(&noAnalysis);
noAnalysis.setSettingsKey("NoAnalysis");
registerAspect(&showSuccess);
showSuccess.setSettingsKey("ShowSuccess");
registerAspect(&breakOnFailure);
breakOnFailure.setSettingsKey("BreakOnFailure");
breakOnFailure.setDefaultValue(true);
registerAspect(&noThrow);
noThrow.setSettingsKey("NoThrow");
registerAspect(&visibleWhitespace);
visibleWhitespace.setSettingsKey("VisibleWS");
registerAspect(&warnOnEmpty);
warnOnEmpty.setSettingsKey("WarnEmpty");
}
} // namespace Internal

43
src/plugins/autotest/catch/catchtestsettings.h
View File

@@ -25,37 +25,32 @@
#pragma once
#include "../itestsettings.h"
#include <utils/aspects.h>
namespace Autotest {
namespace Internal {
class CatchTestSettings : public ITestSettings
class CatchTestSettings : public Utils::AspectContainer
{
public:
CatchTestSettings() = default;
QString name() const override;
CatchTestSettings();
int abortAfter = 0;
int benchmarkSamples = 0;
int benchmarkResamples = 0;
double confidenceInterval = 0;
int benchmarkWarmupTime = 0;
bool abortAfterChecked = false;
bool samplesChecked = false;
bool resamplesChecked = false;
bool confidenceIntervalChecked = false;
bool warmupChecked = false;
bool noAnalysis = false;
bool showSuccess = false;
bool breakOnFailure = true;
bool noThrow = false;
bool visibleWhitespace = false;
bool warnOnEmpty = false;
protected:
void toTestSettings(QSettings *s) const override;
void fromTestSettings(const QSettings *s) override;
Utils::IntegerAspect abortAfter;
Utils::IntegerAspect benchmarkSamples;
Utils::IntegerAspect benchmarkResamples;
Utils::DoubleAspect confidenceInterval;
Utils::IntegerAspect benchmarkWarmupTime;
Utils::BoolAspect abortAfterChecked;
Utils::BoolAspect samplesChecked;
Utils::BoolAspect resamplesChecked;
Utils::BoolAspect confidenceIntervalChecked;
Utils::BoolAspect warmupChecked;
Utils::BoolAspect noAnalysis;
Utils::BoolAspect showSuccess;
Utils::BoolAspect breakOnFailure;
Utils::BoolAspect noThrow;
Utils::BoolAspect visibleWhitespace;
Utils::BoolAspect warnOnEmpty;
};
} // namespace Internal

76
src/plugins/autotest/catch/catchtestsettingspage.cpp
View File

@@ -49,11 +49,11 @@ CatchTestSettingsWidget::CatchTestSettingsWidget(CatchTestSettings *settings)
{
m_ui.setupUi(this);
m_ui.abortSB->setEnabled(m_settings->abortAfterChecked);
m_ui.samplesSB->setEnabled(m_settings->samplesChecked),
m_ui.resamplesSB->setEnabled(m_settings->resamplesChecked);
m_ui.confIntSB->setEnabled(m_settings->confidenceIntervalChecked);
m_ui.warmupSB->setEnabled(m_settings->warmupChecked);
m_ui.abortSB->setEnabled(m_settings->abortAfterChecked.value());
m_ui.samplesSB->setEnabled(m_settings->samplesChecked.value()),
m_ui.resamplesSB->setEnabled(m_settings->resamplesChecked.value());
m_ui.confIntSB->setEnabled(m_settings->confidenceIntervalChecked.value());
m_ui.warmupSB->setEnabled(m_settings->warmupChecked.value());
connect(m_ui.abortCB, &QCheckBox::toggled, m_ui.abortSB, &QSpinBox::setEnabled);
connect(m_ui.samplesCB, &QCheckBox::toggled, m_ui.samplesSB, &QSpinBox::setEnabled);
@@ -61,44 +61,44 @@ CatchTestSettingsWidget::CatchTestSettingsWidget(CatchTestSettings *settings)
connect(m_ui.confIntCB, &QCheckBox::toggled, m_ui.confIntSB, &QDoubleSpinBox::setEnabled);
connect(m_ui.warmupCB, &QCheckBox::toggled, m_ui.warmupSB, &QSpinBox::setEnabled);
m_ui.showSuccessCB->setChecked(m_settings->showSuccess);
m_ui.breakOnFailCB->setChecked(m_settings->breakOnFailure);
m_ui.noThrowCB->setChecked(m_settings->noThrow);
m_ui.visibleWhiteCB->setChecked(m_settings->visibleWhitespace);
m_ui.warnOnEmpty->setChecked(m_settings->warnOnEmpty);
m_ui.noAnalysisCB->setChecked(m_settings->noAnalysis);
m_ui.abortCB->setChecked(m_settings->abortAfterChecked);
m_ui.abortSB->setValue(m_settings->abortAfter);
m_ui.samplesCB->setChecked(m_settings->samplesChecked);
m_ui.samplesSB->setValue(m_settings->benchmarkSamples);
m_ui.resamplesCB->setChecked(m_settings->resamplesChecked);
m_ui.resamplesSB->setValue(m_settings->benchmarkResamples);
m_ui.confIntCB->setChecked(m_settings->confidenceIntervalChecked);
m_ui.confIntSB->setValue(m_settings->confidenceInterval);
m_ui.warmupCB->setChecked(m_settings->warmupChecked);
m_ui.warmupSB->setValue(m_settings->benchmarkWarmupTime);
m_ui.showSuccessCB->setChecked(m_settings->showSuccess.value());
m_ui.breakOnFailCB->setChecked(m_settings->breakOnFailure.value());
m_ui.noThrowCB->setChecked(m_settings->noThrow.value());
m_ui.visibleWhiteCB->setChecked(m_settings->visibleWhitespace.value());
m_ui.warnOnEmpty->setChecked(m_settings->warnOnEmpty.value());
m_ui.noAnalysisCB->setChecked(m_settings->noAnalysis.value());
m_ui.abortCB->setChecked(m_settings->abortAfterChecked.value());
m_ui.abortSB->setValue(m_settings->abortAfter.value());
m_ui.samplesCB->setChecked(m_settings->samplesChecked.value());
m_ui.samplesSB->setValue(m_settings->benchmarkSamples.value());
m_ui.resamplesCB->setChecked(m_settings->resamplesChecked.value());
m_ui.resamplesSB->setValue(m_settings->benchmarkResamples.value());
m_ui.confIntCB->setChecked(m_settings->confidenceIntervalChecked.value());
m_ui.confIntSB->setValue(m_settings->confidenceInterval.value());
m_ui.warmupCB->setChecked(m_settings->warmupChecked.value());
m_ui.warmupSB->setValue(m_settings->benchmarkWarmupTime.value());
}
void CatchTestSettingsWidget::apply()
{
m_settings->showSuccess = m_ui.showSuccessCB->isChecked();
m_settings->breakOnFailure = m_ui.breakOnFailCB->isChecked();
m_settings->noThrow = m_ui.noThrowCB->isChecked();
m_settings->visibleWhitespace = m_ui.visibleWhiteCB->isChecked();
m_settings->warnOnEmpty = m_ui.warnOnEmpty->isChecked();
m_settings->noAnalysis = m_ui.noAnalysisCB->isChecked();
m_settings->abortAfterChecked = m_ui.abortCB->isChecked();
m_settings->abortAfter = m_ui.abortSB->value();
m_settings->samplesChecked = m_ui.samplesCB->isChecked();
m_settings->benchmarkSamples = m_ui.samplesSB->value();
m_settings->resamplesChecked = m_ui.resamplesCB->isChecked();
m_settings->benchmarkResamples = m_ui.resamplesSB->value();
m_settings->confidenceIntervalChecked = m_ui.confIntCB->isChecked();
m_settings->confidenceInterval = m_ui.confIntSB->value();
m_settings->warmupChecked = m_ui.warmupCB->isChecked();
m_settings->benchmarkWarmupTime = m_ui.warmupSB->value();
m_settings->showSuccess.setValue(m_ui.showSuccessCB->isChecked());
m_settings->breakOnFailure.setValue(m_ui.breakOnFailCB->isChecked());
m_settings->noThrow.setValue(m_ui.noThrowCB->isChecked());
m_settings->visibleWhitespace.setValue(m_ui.visibleWhiteCB->isChecked());
m_settings->warnOnEmpty.setValue(m_ui.warnOnEmpty->isChecked());
m_settings->noAnalysis.setValue(m_ui.noAnalysisCB->isChecked());
m_settings->abortAfterChecked.setValue(m_ui.abortCB->isChecked());
m_settings->abortAfter.setValue(m_ui.abortSB->value());
m_settings->samplesChecked.setValue(m_ui.samplesCB->isChecked());
m_settings->benchmarkSamples.setValue(m_ui.samplesSB->value());
m_settings->resamplesChecked.setValue(m_ui.resamplesCB->isChecked());
m_settings->benchmarkResamples.setValue(m_ui.resamplesSB->value());
m_settings->confidenceIntervalChecked.setValue(m_ui.confIntCB->isChecked());
m_settings->confidenceInterval.setValue(m_ui.confIntSB->value());
m_settings->warmupChecked.setValue(m_ui.warmupCB->isChecked());
m_settings->benchmarkWarmupTime.setValue(m_ui.warmupSB->value());
m_settings->toSettings(Core::ICore::settings());
m_settings->writeSettings(Core::ICore::settings());
}
CatchTestSettingsPage::CatchTestSettingsPage(CatchTestSettings *settings, Utils::Id settingsId)

16
src/plugins/autotest/gtest/gtestconfiguration.cpp
View File

@@ -84,21 +84,21 @@ QStringList GTestConfiguration::argumentsForTestRunner(QStringList *omitted) con
if (!testSets.isEmpty())
arguments << "--gtest_filter=" + testSets.join(':');
auto gSettings = dynamic_cast<GTestSettings *>(framework()->testSettings());
auto gSettings = static_cast<GTestSettings *>(framework()->testSettings());
if (!gSettings)
return arguments;
if (gSettings->runDisabled)
if (gSettings->runDisabled.value())
arguments << "--gtest_also_run_disabled_tests";
if (gSettings->repeat)
arguments << QString("--gtest_repeat=%1").arg(gSettings->iterations);
if (gSettings->shuffle)
arguments << "--gtest_shuffle" << QString("--gtest_random_seed=%1").arg(gSettings->seed);
if (gSettings->throwOnFailure)
if (gSettings->repeat.value())
arguments << QString("--gtest_repeat=%1").arg(gSettings->iterations.value());
if (gSettings->shuffle.value())
arguments << "--gtest_shuffle" << QString("--gtest_random_seed=%1").arg(gSettings->seed.value());
if (gSettings->throwOnFailure.value())
arguments << "--gtest_throw_on_failure";
if (isDebugRunMode()) {
if (gSettings->breakOnFailure)
if (gSettings->breakOnFailure.value())
arguments << "--gtest_break_on_failure";
}
return arguments;

4
src/plugins/autotest/gtest/gtestframework.cpp
View File

@@ -65,7 +65,7 @@ unsigned GTestFramework::priority() const
QString GTestFramework::currentGTestFilter()
{
return g_settings->gtestFilter;
return g_settings->gtestFilter.value();
}
QString GTestFramework::groupingToolTip() const
@@ -77,7 +77,7 @@ QString GTestFramework::groupingToolTip() const
GTest::Constants::GroupMode GTestFramework::groupMode()
{
return g_settings->groupMode;
return GTest::Constants::GroupMode(g_settings->groupMode.value());
}
} // namespace Internal

86
src/plugins/autotest/gtest/gtestsettings.cpp
View File

@@ -29,50 +29,54 @@
namespace Autotest {
namespace Internal {
static const char breakOnFailureKey[] = "BreakOnFailure";
static const char iterationsKey[] = "Iterations";
static const char repeatKey[] = "Repeat";
static const char runDisabledKey[] = "RunDisabled";
static const char seedKey[] = "Seed";
static const char shuffleKey[] = "Shuffle";
static const char throwOnFailureKey[] = "ThrowOnFailure";
static const char groupModeKey[] = "GroupMode";
static const char gtestFilterKey[] = "GTestFilter";
QString GTestSettings::name() const
GTestSettings::GTestSettings()
{
return QString("GTest");
}
setSettingsGroups("Autotest", "GTest");
setAutoApply(false);
void GTestSettings::fromTestSettings(const QSettings *s)
{
runDisabled = s->value(runDisabledKey, false).toBool();
repeat = s->value(repeatKey, false).toBool();
shuffle = s->value(shuffleKey, false).toBool();
iterations = s->value(iterationsKey, 1).toInt();
seed = s->value(seedKey, 0).toInt();
breakOnFailure = s->value(breakOnFailureKey, true).toBool();
throwOnFailure = s->value(throwOnFailureKey, false).toBool();
// avoid problems if user messes around with the settings file
bool ok = false;
const int tmp = s->value(groupModeKey, GTest::Constants::Directory).toInt(&ok);
groupMode = ok ? static_cast<GTest::Constants::GroupMode>(tmp) : GTest::Constants::Directory;
gtestFilter = s->value(gtestFilterKey, GTest::Constants::DEFAULT_FILTER).toString();
if (!GTestUtils::isValidGTestFilter(gtestFilter))
gtestFilter = GTest::Constants::DEFAULT_FILTER;
}
registerAspect(&iterations);
iterations.setSettingsKey("Iterations");
iterations.setDefaultValue(1);
void GTestSettings::toTestSettings(QSettings *s) const
{
s->setValue(runDisabledKey, runDisabled);
s->setValue(repeatKey, repeat);
s->setValue(shuffleKey, shuffle);
s->setValue(iterationsKey, iterations);
s->setValue(seedKey, seed);
s->setValue(breakOnFailureKey, breakOnFailure);
s->setValue(throwOnFailureKey, throwOnFailure);
s->setValue(groupModeKey, groupMode);
s->setValue(gtestFilterKey, gtestFilter);
registerAspect(&seed);
seed.setSettingsKey("Seed");
registerAspect(&runDisabled);
runDisabled.setSettingsKey("RunDisabled");
registerAspect(&shuffle);
shuffle.setSettingsKey("Shuffle");
registerAspect(&repeat);
repeat.setSettingsKey("Repeat");
registerAspect(&throwOnFailure);
throwOnFailure.setSettingsKey("ThrowOnFailure");
registerAspect(&breakOnFailure);
breakOnFailure.setSettingsKey("BreakOnFailure");
breakOnFailure.setDefaultValue(true);
registerAspect(&groupMode);
groupMode.setDefaultValue(GTest::Constants::Directory);
groupMode.setSettingsKey("GroupMode");
groupMode.setFromSettingsTransformation([](const QVariant &savedValue) -> QVariant {
// avoid problems if user messes around with the settings file
bool ok = false;
const int tmp = savedValue.toInt(&ok);
return ok ? static_cast<GTest::Constants::GroupMode>(tmp) : GTest::Constants::Directory;
});
registerAspect(&gtestFilter);
gtestFilter.setSettingsKey("GTestFilter");
gtestFilter.setDefaultValue(GTest::Constants::DEFAULT_FILTER);
gtestFilter.setFromSettingsTransformation([](const QVariant &savedValue) -> QVariant {
// avoid problems if user messes around with the settings file
const QString tmp = savedValue.toString();
if (GTestUtils::isValidGTestFilter(tmp))
return tmp;
return GTest::Constants::DEFAULT_FILTER;
});
}
} // namespace Internal

30
src/plugins/autotest/gtest/gtestsettings.h
View File

@@ -25,31 +25,27 @@
#pragma once
#include "../itestsettings.h"
#include "gtestconstants.h"
#include <utils/aspects.h>
namespace Autotest {
namespace Internal {
class GTestSettings : public ITestSettings
class GTestSettings : public Utils::AspectContainer
{
public:
GTestSettings() {}
QString name() const override;
GTestSettings();
int iterations = 1;
int seed = 0;
bool runDisabled = false;
bool shuffle = false;
bool repeat = false;
bool throwOnFailure = false;
bool breakOnFailure = true;
GTest::Constants::GroupMode groupMode = GTest::Constants::Directory;
QString gtestFilter{GTest::Constants::DEFAULT_FILTER};
protected:
void fromTestSettings(const QSettings *s) override;
void toTestSettings(QSettings *s) const override;
Utils::IntegerAspect iterations;
Utils::IntegerAspect seed;
Utils::BoolAspect runDisabled;
Utils::BoolAspect shuffle;
Utils::BoolAspect repeat;
Utils::BoolAspect throwOnFailure;
Utils::BoolAspect breakOnFailure;
Utils::SelectionAspect groupMode;
Utils::StringAspect gtestFilter;
};
} // namespace Internal

50
src/plugins/autotest/gtest/gtestsettingspage.cpp
View File

@@ -71,39 +71,39 @@ GTestSettingsWidget::GTestSettingsWidget(GTestSettings *settings)
connect(m_ui.repeatGTestsCB, &QCheckBox::toggled, m_ui.repetitionSpin, &QSpinBox::setEnabled);
connect(m_ui.shuffleGTestsCB, &QCheckBox::toggled, m_ui.seedSpin, &QSpinBox::setEnabled);
m_ui.runDisabledGTestsCB->setChecked(m_settings->runDisabled);
m_ui.repeatGTestsCB->setChecked(m_settings->repeat);
m_ui.shuffleGTestsCB->setChecked(m_settings->shuffle);
m_ui.repetitionSpin->setValue(m_settings->iterations);
m_ui.seedSpin->setValue(m_settings->seed);
m_ui.breakOnFailureCB->setChecked(m_settings->breakOnFailure);
m_ui.throwOnFailureCB->setChecked(m_settings->throwOnFailure);
m_ui.groupModeCombo->setCurrentIndex(m_settings->groupMode - 1); // there's None for internal use
m_ui.filterLineEdit->setText(m_settings->gtestFilter);
m_currentGTestFilter = m_settings->gtestFilter; // store it temporarily (if edit is invalid)
m_ui.runDisabledGTestsCB->setChecked(m_settings->runDisabled.value());
m_ui.repeatGTestsCB->setChecked(m_settings->repeat.value());
m_ui.shuffleGTestsCB->setChecked(m_settings->shuffle.value());
m_ui.repetitionSpin->setValue(m_settings->iterations.value());
m_ui.seedSpin->setValue(m_settings->seed.value());
m_ui.breakOnFailureCB->setChecked(m_settings->breakOnFailure.value());
m_ui.throwOnFailureCB->setChecked(m_settings->throwOnFailure.value());
m_ui.groupModeCombo->setCurrentIndex(m_settings->groupMode.value() - 1); // there's None for internal use
m_ui.filterLineEdit->setText(m_settings->gtestFilter.value());
m_currentGTestFilter = m_settings->gtestFilter.value(); // store it temporarily (if edit is invalid)
}
void GTestSettingsWidget::apply()
{
GTest::Constants::GroupMode oldGroupMode = m_settings->groupMode;
const QString oldFilter = m_settings->gtestFilter;
GTest::Constants::GroupMode oldGroupMode = GTest::Constants::GroupMode(m_settings->groupMode.value());
const QString oldFilter = m_settings->gtestFilter.value();
m_settings->runDisabled = m_ui.runDisabledGTestsCB->isChecked();
m_settings->repeat = m_ui.repeatGTestsCB->isChecked();
m_settings->shuffle = m_ui.shuffleGTestsCB->isChecked();
m_settings->iterations = m_ui.repetitionSpin->value();
m_settings->seed = m_ui.seedSpin->value();
m_settings->breakOnFailure = m_ui.breakOnFailureCB->isChecked();
m_settings->throwOnFailure = m_ui.throwOnFailureCB->isChecked();
m_settings->groupMode = static_cast<GTest::Constants::GroupMode>(
m_ui.groupModeCombo->currentIndex() + 1);
m_settings->runDisabled.setValue(m_ui.runDisabledGTestsCB->isChecked());
m_settings->repeat.setValue(m_ui.repeatGTestsCB->isChecked());
m_settings->shuffle.setValue(m_ui.shuffleGTestsCB->isChecked());
m_settings->iterations.setValue(m_ui.repetitionSpin->value());
m_settings->seed.setValue(m_ui.seedSpin->value());
m_settings->breakOnFailure.setValue(m_ui.breakOnFailureCB->isChecked());
m_settings->throwOnFailure.setValue(m_ui.throwOnFailureCB->isChecked());
m_settings->groupMode.setValue(static_cast<GTest::Constants::GroupMode>(
m_ui.groupModeCombo->currentIndex() + 1));
if (m_ui.filterLineEdit->isValid())
m_settings->gtestFilter = m_ui.filterLineEdit->text();
m_settings->gtestFilter.setValue(m_ui.filterLineEdit->text());
else
m_settings->gtestFilter = m_currentGTestFilter;
m_settings->gtestFilter.setValue(m_currentGTestFilter);
m_settings->toSettings(Core::ICore::settings());
if (m_settings->groupMode == oldGroupMode && oldFilter == m_settings->gtestFilter)
m_settings->writeSettings(Core::ICore::settings());
if (m_settings->groupMode.value() == oldGroupMode && oldFilter == m_settings->gtestFilter.value())
return;
auto id = Utils::Id(Constants::FRAMEWORK_PREFIX).withSuffix(GTest::Constants::FRAMEWORK_NAME);

3
src/plugins/autotest/itestframework.h
View File

@@ -28,12 +28,13 @@
#include <utils/id.h>
namespace ProjectExplorer { struct TestCaseInfo; }
namespace Utils { class AspectContainer; }
namespace Autotest {
class ITestFramework;
class ITestParser;
class ITestSettings;
using ITestSettings = Utils::AspectContainer;
class ITestTool;
class ITestTreeItem;
class TestTreeItem;

65
src/plugins/autotest/itestsettings.h
View File

@@ -1,65 +0,0 @@
/****************************************************************************
**
** Copyright (C) 2016 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of Qt Creator.
**
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3 as published by the Free Software
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
**
****************************************************************************/
#pragma once
#include "autotestconstants.h"
#include <QSettings>
namespace Autotest {
class ITestSettings
{
public:
ITestSettings() {}
virtual ~ITestSettings() {}
virtual QString name() const = 0;
void toSettings(QSettings *s) const
{
s->beginGroup(Constants::SETTINGSGROUP);
s->beginGroup(name());
toTestSettings(s);
s->endGroup();
s->endGroup();
}
void fromSettings(QSettings *s)
{
s->beginGroup(Constants::SETTINGSGROUP);
s->beginGroup(name());
fromTestSettings(s);
s->endGroup();
s->endGroup();
}
protected:
virtual void toTestSettings(QSettings *s) const = 0;
virtual void fromTestSettings(const QSettings *s) = 0;
};
} // namespace Autotest

16
src/plugins/autotest/qtest/qttestconfiguration.cpp
View File

@@ -40,8 +40,8 @@ namespace Internal {
TestOutputReader *QtTestConfiguration::outputReader(const QFutureInterface<TestResultPtr> &fi,
QProcess *app) const
{
auto qtSettings = dynamic_cast<QtTestSettings *>(framework()->testSettings());
const QtTestOutputReader::OutputMode mode = qtSettings && qtSettings->useXMLOutput
auto qtSettings = static_cast<QtTestSettings *>(framework()->testSettings());
const QtTestOutputReader::OutputMode mode = qtSettings && qtSettings->useXMLOutput.value()
? QtTestOutputReader::XML
: QtTestOutputReader::PlainText;
return new QtTestOutputReader(fi, app, buildDirectory(), projectFile(), mode, TestType::QtTest);
@@ -55,25 +55,25 @@ QStringList QtTestConfiguration::argumentsForTestRunner(QStringList *omitted) co
runnable().commandLineArguments.split(' ', Qt::SkipEmptyParts),
omitted, false));
}
auto qtSettings = dynamic_cast<QtTestSettings *>(framework()->testSettings());
auto qtSettings = static_cast<QtTestSettings *>(framework()->testSettings());
if (!qtSettings)
return arguments;
if (qtSettings->useXMLOutput)
if (qtSettings->useXMLOutput.value())
arguments << "-xml";
if (!testCases().isEmpty())
arguments << testCases();
const QString &metricsOption = QtTestSettings::metricsTypeToOption(qtSettings->metrics);
const QString &metricsOption = QtTestSettings::metricsTypeToOption(MetricsType(qtSettings->metrics.value()));
if (!metricsOption.isEmpty())
arguments << metricsOption;
if (qtSettings->verboseBench)
if (qtSettings->verboseBench.value())
arguments << "-vb";
if (qtSettings->logSignalsSlots)
if (qtSettings->logSignalsSlots.value())
arguments << "-vs";
if (isDebugRunMode() && qtSettings->noCrashHandler)
if (isDebugRunMode() && qtSettings->noCrashHandler.value())
arguments << "-nocrashhandler";
return arguments;

43
src/plugins/autotest/qtest/qttestsettings.cpp
View File

@@ -28,12 +28,6 @@
namespace Autotest {
namespace Internal {
static const char metricsKey[] = "Metrics";
static const char noCrashhandlerKey[] = "NoCrashhandlerOnDebug";
static const char useXMLOutputKey[] = "UseXMLOutput";
static const char verboseBenchKey[] = "VerboseBench";
static const char logSignalsSlotsKey[] = "LogSignalsSlots";
static MetricsType intToMetrics(int value)
{
switch (value) {
@@ -52,27 +46,28 @@ static MetricsType intToMetrics(int value)
}
}
QString QtTestSettings::name() const
QtTestSettings::QtTestSettings()
{
return QString("QtTest");
}
setSettingsGroups("Autotest", "QtTest");
setAutoApply(false);
void QtTestSettings::fromTestSettings(const QSettings *s)
{
metrics = intToMetrics(s->value(metricsKey, Walltime).toInt());
noCrashHandler = s->value(noCrashhandlerKey, true).toBool();
useXMLOutput = s->value(useXMLOutputKey, true).toBool();
verboseBench = s->value(verboseBenchKey, false).toBool();
logSignalsSlots = s->value(logSignalsSlotsKey, false).toBool();
}
registerAspect(&metrics);
metrics.setSettingsKey("Metrics");
metrics.setDefaultValue(Walltime);
void QtTestSettings::toTestSettings(QSettings *s) const
{
s->setValue(metricsKey, metrics);
s->setValue(noCrashhandlerKey, noCrashHandler);
s->setValue(useXMLOutputKey, useXMLOutput);
s->setValue(verboseBenchKey, verboseBench);
s->setValue(logSignalsSlotsKey, logSignalsSlots);
registerAspect(&noCrashHandler);
noCrashHandler.setSettingsKey("NoCrashhandlerOnDebug");
noCrashHandler.setDefaultValue(true);
registerAspect(&useXMLOutput);
useXMLOutput.setSettingsKey("UseXMLOutput");
useXMLOutput.setDefaultValue(true);
registerAspect(&verboseBench);
verboseBench.setSettingsKey("VerboseBench");
registerAspect(&logSignalsSlots);
logSignalsSlots.setSettingsKey("LogSignalsSlots");
}
QString QtTestSettings::metricsTypeToOption(const MetricsType type)

22
src/plugins/autotest/qtest/qttestsettings.h
View File

@@ -25,7 +25,7 @@
#pragma once
#include "../itestsettings.h"
#include <utils/aspects.h>
namespace Autotest {
namespace Internal {
@@ -39,22 +39,18 @@ enum MetricsType
Perf
};
class QtTestSettings : public ITestSettings
class QtTestSettings : public Utils::AspectContainer
{
public:
QtTestSettings() {}
QString name() const override;
QtTestSettings();
static QString metricsTypeToOption(const MetricsType type);
MetricsType metrics = Walltime;
bool noCrashHandler = true;
bool useXMLOutput = true;
bool verboseBench = false;
bool logSignalsSlots = false;
protected:
void fromTestSettings(const QSettings *s) override;
void toTestSettings(QSettings *s) const override;
Utils::SelectionAspect metrics;
Utils::BoolAspect noCrashHandler;
Utils::BoolAspect useXMLOutput;
Utils::BoolAspect verboseBench;
Utils::BoolAspect logSignalsSlots;
};
} // namespace Internal

30
src/plugins/autotest/qtest/qttestsettingspage.cpp
View File

@@ -57,11 +57,11 @@ QtTestSettingsWidget::QtTestSettingsWidget(QtTestSettings *settings)
m_ui.callgrindRB->setEnabled(Utils::HostOsInfo::isAnyUnixHost()); // valgrind available on UNIX
m_ui.perfRB->setEnabled(Utils::HostOsInfo::isLinuxHost()); // according to docs perf Linux only
m_ui.disableCrashhandlerCB->setChecked(m_settings->noCrashHandler);
m_ui.useXMLOutputCB->setChecked(m_settings->useXMLOutput);
m_ui.verboseBenchmarksCB->setChecked(m_settings->verboseBench);
m_ui.logSignalsAndSlotsCB->setChecked(m_settings->logSignalsSlots);
switch (m_settings->metrics) {
m_ui.disableCrashhandlerCB->setChecked(m_settings->noCrashHandler.value());
m_ui.useXMLOutputCB->setChecked(m_settings->useXMLOutput.value());
m_ui.verboseBenchmarksCB->setChecked(m_settings->verboseBench.value());
m_ui.logSignalsAndSlotsCB->setChecked(m_settings->logSignalsSlots.value());
switch (m_settings->metrics.value()) {
case MetricsType::Walltime:
m_ui.walltimeRB->setChecked(true);
break;
@@ -82,22 +82,22 @@ QtTestSettingsWidget::QtTestSettingsWidget(QtTestSettings *settings)
void QtTestSettingsWidget::apply()
{
m_settings->noCrashHandler = m_ui.disableCrashhandlerCB->isChecked();
m_settings->useXMLOutput = m_ui.useXMLOutputCB->isChecked();
m_settings->verboseBench = m_ui.verboseBenchmarksCB->isChecked();
m_settings->logSignalsSlots = m_ui.logSignalsAndSlotsCB->isChecked();
m_settings->noCrashHandler.setValue(m_ui.disableCrashhandlerCB->isChecked());
m_settings->useXMLOutput.setValue(m_ui.useXMLOutputCB->isChecked());
m_settings->verboseBench.setValue(m_ui.verboseBenchmarksCB->isChecked());
m_settings->logSignalsSlots.setValue(m_ui.logSignalsAndSlotsCB->isChecked());
if (m_ui.walltimeRB->isChecked())
m_settings->metrics = MetricsType::Walltime;
m_settings->metrics.setValue(MetricsType::Walltime);
else if (m_ui.tickcounterRB->isChecked())
m_settings->metrics = MetricsType::TickCounter;
m_settings->metrics.setValue(MetricsType::TickCounter);
else if (m_ui.eventCounterRB->isChecked())
m_settings->metrics = MetricsType::EventCounter;
m_settings->metrics.setValue(MetricsType::EventCounter);
else if (m_ui.callgrindRB->isChecked())
m_settings->metrics = MetricsType::CallGrind;
m_settings->metrics.setValue(MetricsType::CallGrind);
else if (m_ui.perfRB->isChecked())
m_settings->metrics = MetricsType::Perf;
m_settings->metrics.setValue(MetricsType::Perf);
m_settings->toSettings(Core::ICore::settings());
m_settings->writeSettings(Core::ICore::settings());
}
QtTestSettingsPage::QtTestSettingsPage(QtTestSettings *settings, Utils::Id settingsId)

12
src/plugins/autotest/quick/quicktestconfiguration.cpp
View File

@@ -46,8 +46,8 @@ QuickTestConfiguration::QuickTestConfiguration(ITestFramework *framework)
TestOutputReader *QuickTestConfiguration::outputReader(const QFutureInterface<TestResultPtr> &fi,
QProcess *app) const
{
auto qtSettings = dynamic_cast<QtTestSettings *>(framework()->testSettings());
const QtTestOutputReader::OutputMode mode = qtSettings && qtSettings->useXMLOutput
auto qtSettings = static_cast<QtTestSettings *>(framework()->testSettings());
const QtTestOutputReader::OutputMode mode = qtSettings && qtSettings->useXMLOutput.value()
? QtTestOutputReader::XML
: QtTestOutputReader::PlainText;
return new QtTestOutputReader(fi, app, buildDirectory(), projectFile(),
@@ -63,20 +63,20 @@ QStringList QuickTestConfiguration::argumentsForTestRunner(QStringList *omitted)
omitted, true));
}
auto qtSettings = dynamic_cast<QtTestSettings *>(framework()->testSettings());
auto qtSettings = static_cast<QtTestSettings *>(framework()->testSettings());
if (!qtSettings)
return arguments;
if (qtSettings->useXMLOutput)
if (qtSettings->useXMLOutput.value())
arguments << "-xml";
if (!testCases().isEmpty())
arguments << testCases();
const QString &metricsOption = QtTestSettings::metricsTypeToOption(qtSettings->metrics);
const QString &metricsOption = QtTestSettings::metricsTypeToOption(MetricsType(qtSettings->metrics.value()));
if (!metricsOption.isEmpty())
arguments << metricsOption;
if (isDebugRunMode()) {
if (qtSettings->noCrashHandler)
if (qtSettings->noCrashHandler.value())
arguments << "-nocrashhandler";
}
return arguments;

4
src/plugins/autotest/testframeworkmanager.cpp
View File

@@ -27,9 +27,9 @@
#include "autotestconstants.h"
#include "autotestplugin.h"
#include "itestsettings.h"
#include "testsettings.h"
#include <utils/aspects.h>
#include <utils/algorithm.h>
#include <utils/qtcassert.h>
@@ -123,7 +123,7 @@ void TestFrameworkManager::synchronizeSettings(QSettings *s)
Internal::AutotestPlugin::settings()->fromSettings(s);
for (ITestFramework *framework : qAsConst(m_registeredFrameworks)) {
if (ITestSettings *fSettings = framework->testSettings())
fSettings->fromSettings(s);
fSettings->readSettings(s);
}
}