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 itemdatacache.h
itestframework.cpp itestframework.h itestframework.cpp itestframework.h
itestparser.cpp itestparser.h itestparser.cpp itestparser.h
itestsettings.h
projectsettingswidget.cpp projectsettingswidget.h projectsettingswidget.cpp projectsettingswidget.h
qtest/qttest_utils.cpp qtest/qttest_utils.h qtest/qttest_utils.cpp qtest/qttest_utils.h
qtest/qttestconfiguration.cpp qtest/qttestconfiguration.h qtest/qttestconfiguration.cpp qtest/qttestconfiguration.h

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

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

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

@@ -79,7 +79,6 @@ QtcPlugin {
"itestparser.h", "itestparser.h",
"itestframework.cpp", "itestframework.cpp",
"itestframework.h", "itestframework.h",
"itestsettings.h",
"testframeworkmanager.cpp", "testframeworkmanager.cpp",
"testframeworkmanager.h", "testframeworkmanager.h",
"testrunconfiguration.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, TestOutputReader *BoostTestConfiguration::outputReader(const QFutureInterface<TestResultPtr> &fi,
QProcess *app) const QProcess *app) const
{ {
auto settings = dynamic_cast<BoostTestSettings *>(framework()->testSettings()); auto settings = static_cast<BoostTestSettings *>(framework()->testSettings());
return new BoostTestOutputReader(fi, app, buildDirectory(), projectFile(), return new BoostTestOutputReader(fi, app, buildDirectory(), projectFile(),
settings->logLevel, settings->reportLevel); LogLevel(settings->logLevel.value()),
ReportLevel(settings->reportLevel.value()));
} }
enum class InterferingType { Options, EnvironmentVariables }; enum class InterferingType { Options, EnvironmentVariables };
@@ -107,19 +108,19 @@ static QStringList filterInterfering(const QStringList &provided, QStringList *o
QStringList BoostTestConfiguration::argumentsForTestRunner(QStringList *omitted) const QStringList BoostTestConfiguration::argumentsForTestRunner(QStringList *omitted) const
{ {
auto boostSettings = dynamic_cast<BoostTestSettings *>(framework()->testSettings()); auto boostSettings = static_cast<BoostTestSettings *>(framework()->testSettings());
QStringList arguments; QStringList arguments;
arguments << "-l" << BoostTestSettings::logLevelToOption(boostSettings->logLevel); arguments << "-l" << BoostTestSettings::logLevelToOption(LogLevel(boostSettings->logLevel.value()));
arguments << "-r" << BoostTestSettings::reportLevelToOption(boostSettings->reportLevel); arguments << "-r" << BoostTestSettings::reportLevelToOption(ReportLevel(boostSettings->reportLevel.value()));
if (boostSettings->randomize) if (boostSettings->randomize.value())
arguments << QString("--random=").append(QString::number(boostSettings->seed)); arguments << QString("--random=").append(QString::number(boostSettings->seed.value()));
if (boostSettings->systemErrors) if (boostSettings->systemErrors.value())
arguments << "-s"; arguments << "-s";
if (boostSettings->fpExceptions) if (boostSettings->fpExceptions.value())
arguments << "--detect_fp_exceptions"; arguments << "--detect_fp_exceptions";
if (!boostSettings->memLeaks) if (!boostSettings->memLeaks.value())
arguments << "--detect_memory_leaks=0"; arguments << "--detect_memory_leaks=0";
// TODO improve the test case gathering and arguments building to avoid too long command lines // 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 Autotest {
namespace Internal { namespace Internal {
static const char logLevelKey[] = "LogLevel"; BoostTestSettings::BoostTestSettings()
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
{ {
return QString("BoostTest"); setSettingsGroups("Autotest", "BoostTest");
} setAutoApply(false);
void BoostTestSettings::fromTestSettings(const QSettings *s) registerAspect(&logLevel);
logLevel.setSettingsKey("LogLevel");
logLevel.setDefaultValue(int(LogLevel::Warning));
{ registerAspect(&reportLevel);
logLevel = LogLevel((s->value(logLevelKey, int(LogLevel::All)).toInt())); reportLevel.setSettingsKey("ReportLevel");
reportLevel = ReportLevel((s->value(reportLevelKey, int(ReportLevel::Confirm)).toInt())); reportLevel.setDefaultValue(int(ReportLevel::Confirm));
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();
}
void BoostTestSettings::toTestSettings(QSettings *s) const registerAspect(&seed);
{ seed.setSettingsKey("Seed");
s->setValue(logLevelKey, int(logLevel));
s->setValue(reportLevelKey, int(reportLevel)); registerAspect(&randomize);
s->setValue(systemErrorsKey, systemErrors); randomize.setSettingsKey("Randomize");
s->setValue(fpExceptionsKey, fpExceptions);
s->setValue(memLeaksKey, memLeaks); registerAspect(&systemErrors);
s->setValue(randomizeKey, randomize); systemErrors.setSettingsKey("SystemErrors");
s->setValue(seedKey, seed);
registerAspect(&fpExceptions);
fpExceptions.setSettingsKey("FPExceptions");
registerAspect(&memLeaks);
memLeaks.setSettingsKey("MemoryLeaks");
memLeaks.setDefaultValue(true);
} }
QString BoostTestSettings::logLevelToOption(const LogLevel logLevel) QString BoostTestSettings::logLevelToOption(const LogLevel logLevel)

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

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

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

@@ -27,6 +27,7 @@
#include "boosttestconstants.h" #include "boosttestconstants.h"
#include "boosttestsettings.h" #include "boosttestsettings.h"
#include "../testframeworkmanager.h" #include "../testframeworkmanager.h"
#include "../autotestconstants.h"
#include "ui_boosttestsettingspage.h" #include "ui_boosttestsettingspage.h"
#include <coreplugin/icore.h> #include <coreplugin/icore.h>
@@ -59,26 +60,26 @@ BoostTestSettingsWidget::BoostTestSettingsWidget(BoostTestSettings *settings)
fillComboBoxes(); fillComboBoxes();
connect(m_ui.randomizeCB, &QCheckBox::toggled, m_ui.seedSB, &QSpinBox::setEnabled); connect(m_ui.randomizeCB, &QCheckBox::toggled, m_ui.seedSB, &QSpinBox::setEnabled);
m_ui.logFormatCB->setCurrentIndex(int(m_settings->logLevel)); m_ui.logFormatCB->setCurrentIndex(m_settings->logLevel.value());
m_ui.reportLevelCB->setCurrentIndex(int(m_settings->reportLevel)); m_ui.reportLevelCB->setCurrentIndex(m_settings->reportLevel.value());
m_ui.randomizeCB->setChecked(m_settings->randomize); m_ui.randomizeCB->setChecked(m_settings->randomize.value());
m_ui.seedSB->setValue(m_settings->seed); m_ui.seedSB->setValue(m_settings->seed.value());
m_ui.systemErrorCB->setChecked(m_settings->systemErrors); m_ui.systemErrorCB->setChecked(m_settings->systemErrors.value());
m_ui.fpExceptions->setChecked(m_settings->fpExceptions); m_ui.fpExceptions->setChecked(m_settings->fpExceptions.value());
m_ui.memoryLeakCB->setChecked(m_settings->memLeaks); m_ui.memoryLeakCB->setChecked(m_settings->memLeaks.value());
} }
void BoostTestSettingsWidget::apply() void BoostTestSettingsWidget::apply()
{ {
m_settings->logLevel = LogLevel(m_ui.logFormatCB->currentData().toInt()); m_settings->logLevel.setValue(m_ui.logFormatCB->currentData().toInt());
m_settings->reportLevel = ReportLevel(m_ui.reportLevelCB->currentData().toInt()); m_settings->reportLevel.setValue(m_ui.reportLevelCB->currentData().toInt());
m_settings->randomize = m_ui.randomizeCB->isChecked(); m_settings->randomize.setValue(m_ui.randomizeCB->isChecked());
m_settings->seed = m_ui.seedSB->value(); m_settings->seed.setValue(m_ui.seedSB->value());
m_settings->systemErrors = m_ui.systemErrorCB->isChecked(); m_settings->systemErrors.setValue(m_ui.systemErrorCB->isChecked());
m_settings->fpExceptions = m_ui.fpExceptions->isChecked(); m_settings->fpExceptions.setValue(m_ui.fpExceptions->isChecked());
m_settings->memLeaks = m_ui.memoryLeakCB->isChecked(); m_settings->memLeaks.setValue(m_ui.memoryLeakCB->isChecked());
m_settings->toSettings(Core::ICore::settings()); m_settings->writeSettings(Core::ICore::settings());
} }
void BoostTestSettingsWidget::fillComboBoxes() 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); ' ', Qt::SkipEmptyParts), omitted);
} }
auto settings = dynamic_cast<CatchTestSettings *>(framework()->testSettings()); auto settings = static_cast<CatchTestSettings *>(framework()->testSettings());
if (!settings) if (!settings)
return arguments; return arguments;
if (settings->abortAfterChecked) if (settings->abortAfterChecked.value())
arguments << "-x" << QString::number(settings->abortAfter); arguments << "-x" << QString::number(settings->abortAfter.value());
if (settings->samplesChecked) if (settings->samplesChecked.value())
arguments << "--benchmark-samples" << QString::number(settings->benchmarkSamples); arguments << "--benchmark-samples" << QString::number(settings->benchmarkSamples.value());
if (settings->resamplesChecked) if (settings->resamplesChecked.value())
arguments << "--benchmark-resamples" << QString::number(settings->benchmarkResamples); arguments << "--benchmark-resamples" << QString::number(settings->benchmarkResamples.value());
if (settings->warmupChecked) if (settings->warmupChecked.value())
arguments << "--benchmark-warmup-time" << QString::number(settings->benchmarkWarmupTime); arguments << "--benchmark-warmup-time" << QString::number(settings->benchmarkWarmupTime.value());
if (settings->confidenceIntervalChecked) if (settings->confidenceIntervalChecked.value())
arguments << "--benchmark-confidence-interval" << QString::number(settings->confidenceInterval); arguments << "--benchmark-confidence-interval" << QString::number(settings->confidenceInterval.value());
if (settings->noAnalysis) if (settings->noAnalysis.value())
arguments << "--benchmark-no-analysis"; arguments << "--benchmark-no-analysis";
if (settings->showSuccess) if (settings->showSuccess.value())
arguments << "-s"; arguments << "-s";
if (settings->noThrow) if (settings->noThrow.value())
arguments << "-e"; arguments << "-e";
if (settings->visibleWhitespace) if (settings->visibleWhitespace.value())
arguments << "-i"; arguments << "-i";
if (settings->warnOnEmpty) if (settings->warnOnEmpty.value())
arguments << "-w" << "NoAssertions"; arguments << "-w" << "NoAssertions";
if (isDebugRunMode() && settings->breakOnFailure) if (isDebugRunMode() && settings->breakOnFailure.value())
arguments << "-b"; arguments << "-b";
return arguments; return arguments;
} }

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

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

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

@@ -25,37 +25,32 @@
#pragma once #pragma once
#include "../itestsettings.h" #include <utils/aspects.h>
namespace Autotest { namespace Autotest {
namespace Internal { namespace Internal {
class CatchTestSettings : public ITestSettings class CatchTestSettings : public Utils::AspectContainer
{ {
public: public:
CatchTestSettings() = default; CatchTestSettings();
QString name() const override;
int abortAfter = 0; Utils::IntegerAspect abortAfter;
int benchmarkSamples = 0; Utils::IntegerAspect benchmarkSamples;
int benchmarkResamples = 0; Utils::IntegerAspect benchmarkResamples;
double confidenceInterval = 0; Utils::DoubleAspect confidenceInterval;
int benchmarkWarmupTime = 0; Utils::IntegerAspect benchmarkWarmupTime;
bool abortAfterChecked = false; Utils::BoolAspect abortAfterChecked;
bool samplesChecked = false; Utils::BoolAspect samplesChecked;
bool resamplesChecked = false; Utils::BoolAspect resamplesChecked;
bool confidenceIntervalChecked = false; Utils::BoolAspect confidenceIntervalChecked;
bool warmupChecked = false; Utils::BoolAspect warmupChecked;
bool noAnalysis = false; Utils::BoolAspect noAnalysis;
bool showSuccess = false; Utils::BoolAspect showSuccess;
bool breakOnFailure = true; Utils::BoolAspect breakOnFailure;
bool noThrow = false; Utils::BoolAspect noThrow;
bool visibleWhitespace = false; Utils::BoolAspect visibleWhitespace;
bool warnOnEmpty = false; Utils::BoolAspect warnOnEmpty;
protected:
void toTestSettings(QSettings *s) const override;
void fromTestSettings(const QSettings *s) override;
}; };
} // namespace Internal } // 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.setupUi(this);
m_ui.abortSB->setEnabled(m_settings->abortAfterChecked); m_ui.abortSB->setEnabled(m_settings->abortAfterChecked.value());
m_ui.samplesSB->setEnabled(m_settings->samplesChecked), m_ui.samplesSB->setEnabled(m_settings->samplesChecked.value()),
m_ui.resamplesSB->setEnabled(m_settings->resamplesChecked); m_ui.resamplesSB->setEnabled(m_settings->resamplesChecked.value());
m_ui.confIntSB->setEnabled(m_settings->confidenceIntervalChecked); m_ui.confIntSB->setEnabled(m_settings->confidenceIntervalChecked.value());
m_ui.warmupSB->setEnabled(m_settings->warmupChecked); m_ui.warmupSB->setEnabled(m_settings->warmupChecked.value());
connect(m_ui.abortCB, &QCheckBox::toggled, m_ui.abortSB, &QSpinBox::setEnabled); connect(m_ui.abortCB, &QCheckBox::toggled, m_ui.abortSB, &QSpinBox::setEnabled);
connect(m_ui.samplesCB, &QCheckBox::toggled, m_ui.samplesSB, &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.confIntCB, &QCheckBox::toggled, m_ui.confIntSB, &QDoubleSpinBox::setEnabled);
connect(m_ui.warmupCB, &QCheckBox::toggled, m_ui.warmupSB, &QSpinBox::setEnabled); connect(m_ui.warmupCB, &QCheckBox::toggled, m_ui.warmupSB, &QSpinBox::setEnabled);
m_ui.showSuccessCB->setChecked(m_settings->showSuccess); m_ui.showSuccessCB->setChecked(m_settings->showSuccess.value());
m_ui.breakOnFailCB->setChecked(m_settings->breakOnFailure); m_ui.breakOnFailCB->setChecked(m_settings->breakOnFailure.value());
m_ui.noThrowCB->setChecked(m_settings->noThrow); m_ui.noThrowCB->setChecked(m_settings->noThrow.value());
m_ui.visibleWhiteCB->setChecked(m_settings->visibleWhitespace); m_ui.visibleWhiteCB->setChecked(m_settings->visibleWhitespace.value());
m_ui.warnOnEmpty->setChecked(m_settings->warnOnEmpty); m_ui.warnOnEmpty->setChecked(m_settings->warnOnEmpty.value());
m_ui.noAnalysisCB->setChecked(m_settings->noAnalysis); m_ui.noAnalysisCB->setChecked(m_settings->noAnalysis.value());
m_ui.abortCB->setChecked(m_settings->abortAfterChecked); m_ui.abortCB->setChecked(m_settings->abortAfterChecked.value());
m_ui.abortSB->setValue(m_settings->abortAfter); m_ui.abortSB->setValue(m_settings->abortAfter.value());
m_ui.samplesCB->setChecked(m_settings->samplesChecked); m_ui.samplesCB->setChecked(m_settings->samplesChecked.value());
m_ui.samplesSB->setValue(m_settings->benchmarkSamples); m_ui.samplesSB->setValue(m_settings->benchmarkSamples.value());
m_ui.resamplesCB->setChecked(m_settings->resamplesChecked); m_ui.resamplesCB->setChecked(m_settings->resamplesChecked.value());
m_ui.resamplesSB->setValue(m_settings->benchmarkResamples); m_ui.resamplesSB->setValue(m_settings->benchmarkResamples.value());
m_ui.confIntCB->setChecked(m_settings->confidenceIntervalChecked); m_ui.confIntCB->setChecked(m_settings->confidenceIntervalChecked.value());
m_ui.confIntSB->setValue(m_settings->confidenceInterval); m_ui.confIntSB->setValue(m_settings->confidenceInterval.value());
m_ui.warmupCB->setChecked(m_settings->warmupChecked); m_ui.warmupCB->setChecked(m_settings->warmupChecked.value());
m_ui.warmupSB->setValue(m_settings->benchmarkWarmupTime); m_ui.warmupSB->setValue(m_settings->benchmarkWarmupTime.value());
} }
void CatchTestSettingsWidget::apply() void CatchTestSettingsWidget::apply()
{ {
m_settings->showSuccess = m_ui.showSuccessCB->isChecked(); m_settings->showSuccess.setValue(m_ui.showSuccessCB->isChecked());
m_settings->breakOnFailure = m_ui.breakOnFailCB->isChecked(); m_settings->breakOnFailure.setValue(m_ui.breakOnFailCB->isChecked());
m_settings->noThrow = m_ui.noThrowCB->isChecked(); m_settings->noThrow.setValue(m_ui.noThrowCB->isChecked());
m_settings->visibleWhitespace = m_ui.visibleWhiteCB->isChecked(); m_settings->visibleWhitespace.setValue(m_ui.visibleWhiteCB->isChecked());
m_settings->warnOnEmpty = m_ui.warnOnEmpty->isChecked(); m_settings->warnOnEmpty.setValue(m_ui.warnOnEmpty->isChecked());
m_settings->noAnalysis = m_ui.noAnalysisCB->isChecked(); m_settings->noAnalysis.setValue(m_ui.noAnalysisCB->isChecked());
m_settings->abortAfterChecked = m_ui.abortCB->isChecked(); m_settings->abortAfterChecked.setValue(m_ui.abortCB->isChecked());
m_settings->abortAfter = m_ui.abortSB->value(); m_settings->abortAfter.setValue(m_ui.abortSB->value());
m_settings->samplesChecked = m_ui.samplesCB->isChecked(); m_settings->samplesChecked.setValue(m_ui.samplesCB->isChecked());
m_settings->benchmarkSamples = m_ui.samplesSB->value(); m_settings->benchmarkSamples.setValue(m_ui.samplesSB->value());
m_settings->resamplesChecked = m_ui.resamplesCB->isChecked(); m_settings->resamplesChecked.setValue(m_ui.resamplesCB->isChecked());
m_settings->benchmarkResamples = m_ui.resamplesSB->value(); m_settings->benchmarkResamples.setValue(m_ui.resamplesSB->value());
m_settings->confidenceIntervalChecked = m_ui.confIntCB->isChecked(); m_settings->confidenceIntervalChecked.setValue(m_ui.confIntCB->isChecked());
m_settings->confidenceInterval = m_ui.confIntSB->value(); m_settings->confidenceInterval.setValue(m_ui.confIntSB->value());
m_settings->warmupChecked = m_ui.warmupCB->isChecked(); m_settings->warmupChecked.setValue(m_ui.warmupCB->isChecked());
m_settings->benchmarkWarmupTime = m_ui.warmupSB->value(); 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) 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()) if (!testSets.isEmpty())
arguments << "--gtest_filter=" + testSets.join(':'); arguments << "--gtest_filter=" + testSets.join(':');
auto gSettings = dynamic_cast<GTestSettings *>(framework()->testSettings()); auto gSettings = static_cast<GTestSettings *>(framework()->testSettings());
if (!gSettings) if (!gSettings)
return arguments; return arguments;
if (gSettings->runDisabled) if (gSettings->runDisabled.value())
arguments << "--gtest_also_run_disabled_tests"; arguments << "--gtest_also_run_disabled_tests";
if (gSettings->repeat) if (gSettings->repeat.value())
arguments << QString("--gtest_repeat=%1").arg(gSettings->iterations); arguments << QString("--gtest_repeat=%1").arg(gSettings->iterations.value());
if (gSettings->shuffle) if (gSettings->shuffle.value())
arguments << "--gtest_shuffle" << QString("--gtest_random_seed=%1").arg(gSettings->seed); arguments << "--gtest_shuffle" << QString("--gtest_random_seed=%1").arg(gSettings->seed.value());
if (gSettings->throwOnFailure) if (gSettings->throwOnFailure.value())
arguments << "--gtest_throw_on_failure"; arguments << "--gtest_throw_on_failure";
if (isDebugRunMode()) { if (isDebugRunMode()) {
if (gSettings->breakOnFailure) if (gSettings->breakOnFailure.value())
arguments << "--gtest_break_on_failure"; arguments << "--gtest_break_on_failure";
} }
return arguments; return arguments;

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

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

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

@@ -29,50 +29,54 @@
namespace Autotest { namespace Autotest {
namespace Internal { namespace Internal {
static const char breakOnFailureKey[] = "BreakOnFailure"; GTestSettings::GTestSettings()
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
{ {
return QString("GTest"); setSettingsGroups("Autotest", "GTest");
} setAutoApply(false);
void GTestSettings::fromTestSettings(const QSettings *s) registerAspect(&iterations);
{ iterations.setSettingsKey("Iterations");
runDisabled = s->value(runDisabledKey, false).toBool(); iterations.setDefaultValue(1);
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;
}
void GTestSettings::toTestSettings(QSettings *s) const registerAspect(&seed);
{ seed.setSettingsKey("Seed");
s->setValue(runDisabledKey, runDisabled);
s->setValue(repeatKey, repeat); registerAspect(&runDisabled);
s->setValue(shuffleKey, shuffle); runDisabled.setSettingsKey("RunDisabled");
s->setValue(iterationsKey, iterations);
s->setValue(seedKey, seed); registerAspect(&shuffle);
s->setValue(breakOnFailureKey, breakOnFailure); shuffle.setSettingsKey("Shuffle");
s->setValue(throwOnFailureKey, throwOnFailure);
s->setValue(groupModeKey, groupMode); registerAspect(&repeat);
s->setValue(gtestFilterKey, gtestFilter); 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 } // namespace Internal

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

@@ -25,31 +25,27 @@
#pragma once #pragma once
#include "../itestsettings.h"
#include "gtestconstants.h" #include "gtestconstants.h"
#include <utils/aspects.h>
namespace Autotest { namespace Autotest {
namespace Internal { namespace Internal {
class GTestSettings : public ITestSettings class GTestSettings : public Utils::AspectContainer
{ {
public: public:
GTestSettings() {} GTestSettings();
QString name() const override;
int iterations = 1; Utils::IntegerAspect iterations;
int seed = 0; Utils::IntegerAspect seed;
bool runDisabled = false; Utils::BoolAspect runDisabled;
bool shuffle = false; Utils::BoolAspect shuffle;
bool repeat = false; Utils::BoolAspect repeat;
bool throwOnFailure = false; Utils::BoolAspect throwOnFailure;
bool breakOnFailure = true; Utils::BoolAspect breakOnFailure;
GTest::Constants::GroupMode groupMode = GTest::Constants::Directory; Utils::SelectionAspect groupMode;
QString gtestFilter{GTest::Constants::DEFAULT_FILTER}; Utils::StringAspect gtestFilter;
protected:
void fromTestSettings(const QSettings *s) override;
void toTestSettings(QSettings *s) const override;
}; };
} // namespace Internal } // 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.repeatGTestsCB, &QCheckBox::toggled, m_ui.repetitionSpin, &QSpinBox::setEnabled);
connect(m_ui.shuffleGTestsCB, &QCheckBox::toggled, m_ui.seedSpin, &QSpinBox::setEnabled); connect(m_ui.shuffleGTestsCB, &QCheckBox::toggled, m_ui.seedSpin, &QSpinBox::setEnabled);
m_ui.runDisabledGTestsCB->setChecked(m_settings->runDisabled); m_ui.runDisabledGTestsCB->setChecked(m_settings->runDisabled.value());
m_ui.repeatGTestsCB->setChecked(m_settings->repeat); m_ui.repeatGTestsCB->setChecked(m_settings->repeat.value());
m_ui.shuffleGTestsCB->setChecked(m_settings->shuffle); m_ui.shuffleGTestsCB->setChecked(m_settings->shuffle.value());
m_ui.repetitionSpin->setValue(m_settings->iterations); m_ui.repetitionSpin->setValue(m_settings->iterations.value());
m_ui.seedSpin->setValue(m_settings->seed); m_ui.seedSpin->setValue(m_settings->seed.value());
m_ui.breakOnFailureCB->setChecked(m_settings->breakOnFailure); m_ui.breakOnFailureCB->setChecked(m_settings->breakOnFailure.value());
m_ui.throwOnFailureCB->setChecked(m_settings->throwOnFailure); m_ui.throwOnFailureCB->setChecked(m_settings->throwOnFailure.value());
m_ui.groupModeCombo->setCurrentIndex(m_settings->groupMode - 1); // there's None for internal use m_ui.groupModeCombo->setCurrentIndex(m_settings->groupMode.value() - 1); // there's None for internal use
m_ui.filterLineEdit->setText(m_settings->gtestFilter); m_ui.filterLineEdit->setText(m_settings->gtestFilter.value());
m_currentGTestFilter = m_settings->gtestFilter; // store it temporarily (if edit is invalid) m_currentGTestFilter = m_settings->gtestFilter.value(); // store it temporarily (if edit is invalid)
} }
void GTestSettingsWidget::apply() void GTestSettingsWidget::apply()
{ {
GTest::Constants::GroupMode oldGroupMode = m_settings->groupMode; GTest::Constants::GroupMode oldGroupMode = GTest::Constants::GroupMode(m_settings->groupMode.value());
const QString oldFilter = m_settings->gtestFilter; const QString oldFilter = m_settings->gtestFilter.value();
m_settings->runDisabled = m_ui.runDisabledGTestsCB->isChecked(); m_settings->runDisabled.setValue(m_ui.runDisabledGTestsCB->isChecked());
m_settings->repeat = m_ui.repeatGTestsCB->isChecked(); m_settings->repeat.setValue(m_ui.repeatGTestsCB->isChecked());
m_settings->shuffle = m_ui.shuffleGTestsCB->isChecked(); m_settings->shuffle.setValue(m_ui.shuffleGTestsCB->isChecked());
m_settings->iterations = m_ui.repetitionSpin->value(); m_settings->iterations.setValue(m_ui.repetitionSpin->value());
m_settings->seed = m_ui.seedSpin->value(); m_settings->seed.setValue(m_ui.seedSpin->value());
m_settings->breakOnFailure = m_ui.breakOnFailureCB->isChecked(); m_settings->breakOnFailure.setValue(m_ui.breakOnFailureCB->isChecked());
m_settings->throwOnFailure = m_ui.throwOnFailureCB->isChecked(); m_settings->throwOnFailure.setValue(m_ui.throwOnFailureCB->isChecked());
m_settings->groupMode = static_cast<GTest::Constants::GroupMode>( m_settings->groupMode.setValue(static_cast<GTest::Constants::GroupMode>(
m_ui.groupModeCombo->currentIndex() + 1); m_ui.groupModeCombo->currentIndex() + 1));
if (m_ui.filterLineEdit->isValid()) if (m_ui.filterLineEdit->isValid())
m_settings->gtestFilter = m_ui.filterLineEdit->text(); m_settings->gtestFilter.setValue(m_ui.filterLineEdit->text());
else else
m_settings->gtestFilter = m_currentGTestFilter; m_settings->gtestFilter.setValue(m_currentGTestFilter);
m_settings->toSettings(Core::ICore::settings()); m_settings->writeSettings(Core::ICore::settings());
if (m_settings->groupMode == oldGroupMode && oldFilter == m_settings->gtestFilter) if (m_settings->groupMode.value() == oldGroupMode && oldFilter == m_settings->gtestFilter.value())
return; return;
auto id = Utils::Id(Constants::FRAMEWORK_PREFIX).withSuffix(GTest::Constants::FRAMEWORK_NAME); 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> #include <utils/id.h>
namespace ProjectExplorer { struct TestCaseInfo; } namespace ProjectExplorer { struct TestCaseInfo; }
namespace Utils { class AspectContainer; }
namespace Autotest { namespace Autotest {
class ITestFramework; class ITestFramework;
class ITestParser; class ITestParser;
class ITestSettings; using ITestSettings = Utils::AspectContainer;
class ITestTool; class ITestTool;
class ITestTreeItem; class ITestTreeItem;
class TestTreeItem; 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, TestOutputReader *QtTestConfiguration::outputReader(const QFutureInterface<TestResultPtr> &fi,
QProcess *app) const QProcess *app) const
{ {
auto qtSettings = dynamic_cast<QtTestSettings *>(framework()->testSettings()); auto qtSettings = static_cast<QtTestSettings *>(framework()->testSettings());
const QtTestOutputReader::OutputMode mode = qtSettings && qtSettings->useXMLOutput const QtTestOutputReader::OutputMode mode = qtSettings && qtSettings->useXMLOutput.value()
? QtTestOutputReader::XML ? QtTestOutputReader::XML
: QtTestOutputReader::PlainText; : QtTestOutputReader::PlainText;
return new QtTestOutputReader(fi, app, buildDirectory(), projectFile(), mode, TestType::QtTest); 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), runnable().commandLineArguments.split(' ', Qt::SkipEmptyParts),
omitted, false)); omitted, false));
} }
auto qtSettings = dynamic_cast<QtTestSettings *>(framework()->testSettings()); auto qtSettings = static_cast<QtTestSettings *>(framework()->testSettings());
if (!qtSettings) if (!qtSettings)
return arguments; return arguments;
if (qtSettings->useXMLOutput) if (qtSettings->useXMLOutput.value())
arguments << "-xml"; arguments << "-xml";
if (!testCases().isEmpty()) if (!testCases().isEmpty())
arguments << testCases(); arguments << testCases();
const QString &metricsOption = QtTestSettings::metricsTypeToOption(qtSettings->metrics); const QString &metricsOption = QtTestSettings::metricsTypeToOption(MetricsType(qtSettings->metrics.value()));
if (!metricsOption.isEmpty()) if (!metricsOption.isEmpty())
arguments << metricsOption; arguments << metricsOption;
if (qtSettings->verboseBench) if (qtSettings->verboseBench.value())
arguments << "-vb"; arguments << "-vb";
if (qtSettings->logSignalsSlots) if (qtSettings->logSignalsSlots.value())
arguments << "-vs"; arguments << "-vs";
if (isDebugRunMode() && qtSettings->noCrashHandler) if (isDebugRunMode() && qtSettings->noCrashHandler.value())
arguments << "-nocrashhandler"; arguments << "-nocrashhandler";
return arguments; return arguments;

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

@@ -28,12 +28,6 @@
namespace Autotest { namespace Autotest {
namespace Internal { 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) static MetricsType intToMetrics(int value)
{ {
switch (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) registerAspect(&metrics);
{ metrics.setSettingsKey("Metrics");
metrics = intToMetrics(s->value(metricsKey, Walltime).toInt()); metrics.setDefaultValue(Walltime);
noCrashHandler = s->value(noCrashhandlerKey, true).toBool();
useXMLOutput = s->value(useXMLOutputKey, true).toBool();
verboseBench = s->value(verboseBenchKey, false).toBool();
logSignalsSlots = s->value(logSignalsSlotsKey, false).toBool();
}
void QtTestSettings::toTestSettings(QSettings *s) const registerAspect(&noCrashHandler);
{ noCrashHandler.setSettingsKey("NoCrashhandlerOnDebug");
s->setValue(metricsKey, metrics); noCrashHandler.setDefaultValue(true);
s->setValue(noCrashhandlerKey, noCrashHandler);
s->setValue(useXMLOutputKey, useXMLOutput); registerAspect(&useXMLOutput);
s->setValue(verboseBenchKey, verboseBench); useXMLOutput.setSettingsKey("UseXMLOutput");
s->setValue(logSignalsSlotsKey, logSignalsSlots); useXMLOutput.setDefaultValue(true);
registerAspect(&verboseBench);
verboseBench.setSettingsKey("VerboseBench");
registerAspect(&logSignalsSlots);
logSignalsSlots.setSettingsKey("LogSignalsSlots");
} }
QString QtTestSettings::metricsTypeToOption(const MetricsType type) QString QtTestSettings::metricsTypeToOption(const MetricsType type)

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

@@ -25,7 +25,7 @@
#pragma once #pragma once
#include "../itestsettings.h" #include <utils/aspects.h>
namespace Autotest { namespace Autotest {
namespace Internal { namespace Internal {
@@ -39,22 +39,18 @@ enum MetricsType
Perf Perf
}; };
class QtTestSettings : public ITestSettings class QtTestSettings : public Utils::AspectContainer
{ {
public: public:
QtTestSettings() {} QtTestSettings();
QString name() const override;
static QString metricsTypeToOption(const MetricsType type); static QString metricsTypeToOption(const MetricsType type);
MetricsType metrics = Walltime; Utils::SelectionAspect metrics;
bool noCrashHandler = true; Utils::BoolAspect noCrashHandler;
bool useXMLOutput = true; Utils::BoolAspect useXMLOutput;
bool verboseBench = false; Utils::BoolAspect verboseBench;
bool logSignalsSlots = false; Utils::BoolAspect logSignalsSlots;
protected:
void fromTestSettings(const QSettings *s) override;
void toTestSettings(QSettings *s) const override;
}; };
} // namespace Internal } // 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.callgrindRB->setEnabled(Utils::HostOsInfo::isAnyUnixHost()); // valgrind available on UNIX
m_ui.perfRB->setEnabled(Utils::HostOsInfo::isLinuxHost()); // according to docs perf Linux only m_ui.perfRB->setEnabled(Utils::HostOsInfo::isLinuxHost()); // according to docs perf Linux only
m_ui.disableCrashhandlerCB->setChecked(m_settings->noCrashHandler); m_ui.disableCrashhandlerCB->setChecked(m_settings->noCrashHandler.value());
m_ui.useXMLOutputCB->setChecked(m_settings->useXMLOutput); m_ui.useXMLOutputCB->setChecked(m_settings->useXMLOutput.value());
m_ui.verboseBenchmarksCB->setChecked(m_settings->verboseBench); m_ui.verboseBenchmarksCB->setChecked(m_settings->verboseBench.value());
m_ui.logSignalsAndSlotsCB->setChecked(m_settings->logSignalsSlots); m_ui.logSignalsAndSlotsCB->setChecked(m_settings->logSignalsSlots.value());
switch (m_settings->metrics) { switch (m_settings->metrics.value()) {
case MetricsType::Walltime: case MetricsType::Walltime:
m_ui.walltimeRB->setChecked(true); m_ui.walltimeRB->setChecked(true);
break; break;
@@ -82,22 +82,22 @@ QtTestSettingsWidget::QtTestSettingsWidget(QtTestSettings *settings)
void QtTestSettingsWidget::apply() void QtTestSettingsWidget::apply()
{ {
m_settings->noCrashHandler = m_ui.disableCrashhandlerCB->isChecked(); m_settings->noCrashHandler.setValue(m_ui.disableCrashhandlerCB->isChecked());
m_settings->useXMLOutput = m_ui.useXMLOutputCB->isChecked(); m_settings->useXMLOutput.setValue(m_ui.useXMLOutputCB->isChecked());
m_settings->verboseBench = m_ui.verboseBenchmarksCB->isChecked(); m_settings->verboseBench.setValue(m_ui.verboseBenchmarksCB->isChecked());
m_settings->logSignalsSlots = m_ui.logSignalsAndSlotsCB->isChecked(); m_settings->logSignalsSlots.setValue(m_ui.logSignalsAndSlotsCB->isChecked());
if (m_ui.walltimeRB->isChecked()) if (m_ui.walltimeRB->isChecked())
m_settings->metrics = MetricsType::Walltime; m_settings->metrics.setValue(MetricsType::Walltime);
else if (m_ui.tickcounterRB->isChecked()) else if (m_ui.tickcounterRB->isChecked())
m_settings->metrics = MetricsType::TickCounter; m_settings->metrics.setValue(MetricsType::TickCounter);
else if (m_ui.eventCounterRB->isChecked()) else if (m_ui.eventCounterRB->isChecked())
m_settings->metrics = MetricsType::EventCounter; m_settings->metrics.setValue(MetricsType::EventCounter);
else if (m_ui.callgrindRB->isChecked()) else if (m_ui.callgrindRB->isChecked())
m_settings->metrics = MetricsType::CallGrind; m_settings->metrics.setValue(MetricsType::CallGrind);
else if (m_ui.perfRB->isChecked()) 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) 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, TestOutputReader *QuickTestConfiguration::outputReader(const QFutureInterface<TestResultPtr> &fi,
QProcess *app) const QProcess *app) const
{ {
auto qtSettings = dynamic_cast<QtTestSettings *>(framework()->testSettings()); auto qtSettings = static_cast<QtTestSettings *>(framework()->testSettings());
const QtTestOutputReader::OutputMode mode = qtSettings && qtSettings->useXMLOutput const QtTestOutputReader::OutputMode mode = qtSettings && qtSettings->useXMLOutput.value()
? QtTestOutputReader::XML ? QtTestOutputReader::XML
: QtTestOutputReader::PlainText; : QtTestOutputReader::PlainText;
return new QtTestOutputReader(fi, app, buildDirectory(), projectFile(), return new QtTestOutputReader(fi, app, buildDirectory(), projectFile(),
@@ -63,20 +63,20 @@ QStringList QuickTestConfiguration::argumentsForTestRunner(QStringList *omitted)
omitted, true)); omitted, true));
} }
auto qtSettings = dynamic_cast<QtTestSettings *>(framework()->testSettings()); auto qtSettings = static_cast<QtTestSettings *>(framework()->testSettings());
if (!qtSettings) if (!qtSettings)
return arguments; return arguments;
if (qtSettings->useXMLOutput) if (qtSettings->useXMLOutput.value())
arguments << "-xml"; arguments << "-xml";
if (!testCases().isEmpty()) if (!testCases().isEmpty())
arguments << testCases(); arguments << testCases();
const QString &metricsOption = QtTestSettings::metricsTypeToOption(qtSettings->metrics); const QString &metricsOption = QtTestSettings::metricsTypeToOption(MetricsType(qtSettings->metrics.value()));
if (!metricsOption.isEmpty()) if (!metricsOption.isEmpty())
arguments << metricsOption; arguments << metricsOption;
if (isDebugRunMode()) { if (isDebugRunMode()) {
if (qtSettings->noCrashHandler) if (qtSettings->noCrashHandler.value())
arguments << "-nocrashhandler"; arguments << "-nocrashhandler";
} }
return arguments; return arguments;

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

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