diff --git a/src/plugins/autotest/CMakeLists.txt b/src/plugins/autotest/CMakeLists.txt index 275544653dc..60bca246c21 100644 --- a/src/plugins/autotest/CMakeLists.txt +++ b/src/plugins/autotest/CMakeLists.txt @@ -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 diff --git a/src/plugins/autotest/autotest.pro b/src/plugins/autotest/autotest.pro index 3ca8ca2d421..2c08e32d890 100644 --- a/src/plugins/autotest/autotest.pro +++ b/src/plugins/autotest/autotest.pro @@ -89,7 +89,6 @@ HEADERS += \ itemdatacache.h \ itestframework.h \ itestparser.h \ - itestsettings.h \ projectsettingswidget.h \ testcodeparser.h \ testconfiguration.h \ diff --git a/src/plugins/autotest/autotest.qbs b/src/plugins/autotest/autotest.qbs index 08adf7c2152..cd9d0a55080 100644 --- a/src/plugins/autotest/autotest.qbs +++ b/src/plugins/autotest/autotest.qbs @@ -79,7 +79,6 @@ QtcPlugin { "itestparser.h", "itestframework.cpp", "itestframework.h", - "itestsettings.h", "testframeworkmanager.cpp", "testframeworkmanager.h", "testrunconfiguration.h" diff --git a/src/plugins/autotest/boost/boosttestconfiguration.cpp b/src/plugins/autotest/boost/boosttestconfiguration.cpp index c559c2c6bd2..eef1bb58908 100644 --- a/src/plugins/autotest/boost/boosttestconfiguration.cpp +++ b/src/plugins/autotest/boost/boosttestconfiguration.cpp @@ -40,9 +40,10 @@ namespace Internal { TestOutputReader *BoostTestConfiguration::outputReader(const QFutureInterface &fi, QProcess *app) const { - auto settings = dynamic_cast(framework()->testSettings()); + auto settings = static_cast(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(framework()->testSettings()); + auto boostSettings = static_cast(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 diff --git a/src/plugins/autotest/boost/boosttestsettings.cpp b/src/plugins/autotest/boost/boosttestsettings.cpp index 333ae57891e..4b6d7e0374b 100644 --- a/src/plugins/autotest/boost/boosttestsettings.cpp +++ b/src/plugins/autotest/boost/boosttestsettings.cpp @@ -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) diff --git a/src/plugins/autotest/boost/boosttestsettings.h b/src/plugins/autotest/boost/boosttestsettings.h index 081f8acc899..cb01db0b664 100644 --- a/src/plugins/autotest/boost/boosttestsettings.h +++ b/src/plugins/autotest/boost/boosttestsettings.h @@ -25,7 +25,7 @@ #pragma once -#include "../itestsettings.h" +#include 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 diff --git a/src/plugins/autotest/boost/boosttestsettingspage.cpp b/src/plugins/autotest/boost/boosttestsettingspage.cpp index 955d50683db..17721d15089 100644 --- a/src/plugins/autotest/boost/boosttestsettingspage.cpp +++ b/src/plugins/autotest/boost/boosttestsettingspage.cpp @@ -27,6 +27,7 @@ #include "boosttestconstants.h" #include "boosttestsettings.h" #include "../testframeworkmanager.h" +#include "../autotestconstants.h" #include "ui_boosttestsettingspage.h" #include @@ -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() diff --git a/src/plugins/autotest/catch/catchconfiguration.cpp b/src/plugins/autotest/catch/catchconfiguration.cpp index 4fb235e0351..3d01b58bd01 100644 --- a/src/plugins/autotest/catch/catchconfiguration.cpp +++ b/src/plugins/autotest/catch/catchconfiguration.cpp @@ -105,32 +105,32 @@ QStringList CatchConfiguration::argumentsForTestRunner(QStringList *omitted) con ' ', Qt::SkipEmptyParts), omitted); } - auto settings = dynamic_cast(framework()->testSettings()); + auto settings = static_cast(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; } diff --git a/src/plugins/autotest/catch/catchtestsettings.cpp b/src/plugins/autotest/catch/catchtestsettings.cpp index d7eabb9affa..abb46518456 100644 --- a/src/plugins/autotest/catch/catchtestsettings.cpp +++ b/src/plugins/autotest/catch/catchtestsettings.cpp @@ -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 diff --git a/src/plugins/autotest/catch/catchtestsettings.h b/src/plugins/autotest/catch/catchtestsettings.h index 0706611cd07..061ef80a139 100644 --- a/src/plugins/autotest/catch/catchtestsettings.h +++ b/src/plugins/autotest/catch/catchtestsettings.h @@ -25,37 +25,32 @@ #pragma once -#include "../itestsettings.h" +#include 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 diff --git a/src/plugins/autotest/catch/catchtestsettingspage.cpp b/src/plugins/autotest/catch/catchtestsettingspage.cpp index 0bb597b8b01..736beaf1076 100644 --- a/src/plugins/autotest/catch/catchtestsettingspage.cpp +++ b/src/plugins/autotest/catch/catchtestsettingspage.cpp @@ -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) diff --git a/src/plugins/autotest/gtest/gtestconfiguration.cpp b/src/plugins/autotest/gtest/gtestconfiguration.cpp index b4fdde3f9bb..4556aceb0dd 100644 --- a/src/plugins/autotest/gtest/gtestconfiguration.cpp +++ b/src/plugins/autotest/gtest/gtestconfiguration.cpp @@ -84,21 +84,21 @@ QStringList GTestConfiguration::argumentsForTestRunner(QStringList *omitted) con if (!testSets.isEmpty()) arguments << "--gtest_filter=" + testSets.join(':'); - auto gSettings = dynamic_cast(framework()->testSettings()); + auto gSettings = static_cast(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; diff --git a/src/plugins/autotest/gtest/gtestframework.cpp b/src/plugins/autotest/gtest/gtestframework.cpp index 9480ee5732b..72aed152122 100644 --- a/src/plugins/autotest/gtest/gtestframework.cpp +++ b/src/plugins/autotest/gtest/gtestframework.cpp @@ -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 diff --git a/src/plugins/autotest/gtest/gtestsettings.cpp b/src/plugins/autotest/gtest/gtestsettings.cpp index c0cbba9729c..13ff8577213 100644 --- a/src/plugins/autotest/gtest/gtestsettings.cpp +++ b/src/plugins/autotest/gtest/gtestsettings.cpp @@ -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(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(tmp) : GTest::Constants::Directory; + }); + + registerAspect(>estFilter); + 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 diff --git a/src/plugins/autotest/gtest/gtestsettings.h b/src/plugins/autotest/gtest/gtestsettings.h index e8b75d63310..d549ddcb1b5 100644 --- a/src/plugins/autotest/gtest/gtestsettings.h +++ b/src/plugins/autotest/gtest/gtestsettings.h @@ -25,31 +25,27 @@ #pragma once -#include "../itestsettings.h" #include "gtestconstants.h" +#include + 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 diff --git a/src/plugins/autotest/gtest/gtestsettingspage.cpp b/src/plugins/autotest/gtest/gtestsettingspage.cpp index 3bd28433ad7..6924b1f59bc 100644 --- a/src/plugins/autotest/gtest/gtestsettingspage.cpp +++ b/src/plugins/autotest/gtest/gtestsettingspage.cpp @@ -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( - 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( + 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); diff --git a/src/plugins/autotest/itestframework.h b/src/plugins/autotest/itestframework.h index 6e36ecfe3c4..6b30c70dd0e 100644 --- a/src/plugins/autotest/itestframework.h +++ b/src/plugins/autotest/itestframework.h @@ -28,12 +28,13 @@ #include 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; diff --git a/src/plugins/autotest/itestsettings.h b/src/plugins/autotest/itestsettings.h deleted file mode 100644 index 7e868b53b65..00000000000 --- a/src/plugins/autotest/itestsettings.h +++ /dev/null @@ -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 - -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 diff --git a/src/plugins/autotest/qtest/qttestconfiguration.cpp b/src/plugins/autotest/qtest/qttestconfiguration.cpp index b02daed554f..edc58a90900 100644 --- a/src/plugins/autotest/qtest/qttestconfiguration.cpp +++ b/src/plugins/autotest/qtest/qttestconfiguration.cpp @@ -40,8 +40,8 @@ namespace Internal { TestOutputReader *QtTestConfiguration::outputReader(const QFutureInterface &fi, QProcess *app) const { - auto qtSettings = dynamic_cast(framework()->testSettings()); - const QtTestOutputReader::OutputMode mode = qtSettings && qtSettings->useXMLOutput + auto qtSettings = static_cast(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(framework()->testSettings()); + auto qtSettings = static_cast(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; diff --git a/src/plugins/autotest/qtest/qttestsettings.cpp b/src/plugins/autotest/qtest/qttestsettings.cpp index 2e953661ea6..d3804e2298e 100644 --- a/src/plugins/autotest/qtest/qttestsettings.cpp +++ b/src/plugins/autotest/qtest/qttestsettings.cpp @@ -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) diff --git a/src/plugins/autotest/qtest/qttestsettings.h b/src/plugins/autotest/qtest/qttestsettings.h index cedd821d39a..75ca120fb0d 100644 --- a/src/plugins/autotest/qtest/qttestsettings.h +++ b/src/plugins/autotest/qtest/qttestsettings.h @@ -25,7 +25,7 @@ #pragma once -#include "../itestsettings.h" +#include 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 diff --git a/src/plugins/autotest/qtest/qttestsettingspage.cpp b/src/plugins/autotest/qtest/qttestsettingspage.cpp index bed1930baa8..5335bf8fd44 100644 --- a/src/plugins/autotest/qtest/qttestsettingspage.cpp +++ b/src/plugins/autotest/qtest/qttestsettingspage.cpp @@ -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) diff --git a/src/plugins/autotest/quick/quicktestconfiguration.cpp b/src/plugins/autotest/quick/quicktestconfiguration.cpp index 2d8e01484f9..aa2bdc18acb 100644 --- a/src/plugins/autotest/quick/quicktestconfiguration.cpp +++ b/src/plugins/autotest/quick/quicktestconfiguration.cpp @@ -46,8 +46,8 @@ QuickTestConfiguration::QuickTestConfiguration(ITestFramework *framework) TestOutputReader *QuickTestConfiguration::outputReader(const QFutureInterface &fi, QProcess *app) const { - auto qtSettings = dynamic_cast(framework()->testSettings()); - const QtTestOutputReader::OutputMode mode = qtSettings && qtSettings->useXMLOutput + auto qtSettings = static_cast(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(framework()->testSettings()); + auto qtSettings = static_cast(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; diff --git a/src/plugins/autotest/testframeworkmanager.cpp b/src/plugins/autotest/testframeworkmanager.cpp index d6edee794c5..b7ec3dc0221 100644 --- a/src/plugins/autotest/testframeworkmanager.cpp +++ b/src/plugins/autotest/testframeworkmanager.cpp @@ -27,9 +27,9 @@ #include "autotestconstants.h" #include "autotestplugin.h" -#include "itestsettings.h" #include "testsettings.h" +#include #include #include @@ -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); } }