Skip to content
Snippets Groups Projects
Commit f7aeba33 authored by Gemma Guest's avatar Gemma Guest
Browse files

Add mock object for experiment defaults 

Experiment presenter now uses the mock rather than testing values against the parameter file directly.

Re #23015
parent a8f70173
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
Showing
with 228 additions and 165 deletions
instrument/unit_testing/REFL_Parameters_Debug_Invalid.xml
+ 1
− 1
View file @ f7aeba33
......@@ -4,7 +4,7 @@
<component-link name="REFL" >
<parameter name="Debug">
<value val="badDebugOption"/>
<value val="99"/>
</parameter>
</component-link>
......
qt/scientific_interfaces/ISISReflectometry/GUI/Experiment/ExperimentOptionDefaults.cpp
+ 1
− 1
View file @ f7aeba33
......@@ -94,7 +94,7 @@ getExperimentDefaults(Mantid::Geometry::Instrument_const_sptr instrument) {
}
} // unnamed namespace
Experiment ExperimentOptionDefaults::operator()(
Experiment ExperimentOptionDefaults::get(
Mantid::Geometry::Instrument_const_sptr instrument) {
return getExperimentDefaults(instrument);
}
......
qt/scientific_interfaces/ISISReflectometry/GUI/Experiment/ExperimentOptionDefaults.h
+ 6
− 6
View file @ f7aeba33
......@@ -7,22 +7,22 @@
#ifndef MANTID_ISISREFLECTOMETRY_EXPERIMENTOPTIONDEFAULTS_H
#define MANTID_ISISREFLECTOMETRY_EXPERIMENTOPTIONDEFAULTS_H
#include "Common/DllConfig.h"
#include "MantidAPI/BoostOptionalToAlgorithmProperty.h"
#include "MantidGeometry/Instrument_fwd.h"
#include "Reduction/Experiment.h"
#include <string>
namespace MantidQt {
namespace CustomInterfaces {
class IExperimentOptionDefaults {
class MANTIDQT_ISISREFLECTOMETRY_DLL IExperimentOptionDefaults {
public:
virtual Experiment operator()(Mantid::Geometry::Instrument_const_sptr instrument) = 0;
virtual ~IExperimentOptionDefaults() = default;
virtual Experiment get(Mantid::Geometry::Instrument_const_sptr instrument) = 0;
};
class ExperimentOptionDefaults : public IExperimentOptionDefaults {
class MANTIDQT_ISISREFLECTOMETRY_DLL ExperimentOptionDefaults
: public IExperimentOptionDefaults {
public:
Experiment operator()(Mantid::Geometry::Instrument_const_sptr instrument) override;
Experiment get(Mantid::Geometry::Instrument_const_sptr instrument) override;
};
} // namespace CustomInterfaces
} // namespace MantidQt
......
qt/scientific_interfaces/ISISReflectometry/GUI/Experiment/ExperimentPresenter.cpp
+ 6
− 8
View file @ f7aeba33
......@@ -5,7 +5,6 @@
// & Institut Laue - Langevin
// SPDX - License - Identifier: GPL - 3.0 +
#include "ExperimentPresenter.h"
#include "ExperimentOptionDefaults.h"
#include "GUI/Batch/IBatchPresenter.h"
#include "MantidGeometry/Instrument_fwd.h"
#include "PerThetaDefaultsTableValidator.h"
......@@ -15,11 +14,11 @@
namespace MantidQt {
namespace CustomInterfaces {
ExperimentPresenter::ExperimentPresenter(IExperimentView *view,
Experiment experiment,
double defaultsThetaTolerance)
: m_view(view), m_model(std::move(experiment)),
m_thetaTolerance(defaultsThetaTolerance) {
ExperimentPresenter::ExperimentPresenter(
IExperimentView *view, Experiment experiment, double defaultsThetaTolerance,
std::unique_ptr<IExperimentOptionDefaults> experimentDefaults)
: m_experimentDefaults(std::move(experimentDefaults)), m_view(view),
m_model(std::move(experiment)), m_thetaTolerance(defaultsThetaTolerance) {
m_view->subscribe(this);
}
......@@ -113,8 +112,7 @@ void ExperimentPresenter::instrumentChanged(std::string const &instrumentName) {
}
void ExperimentPresenter::restoreDefaults() {
ExperimentOptionDefaults experimentDefaults;
m_model = experimentDefaults(m_mainPresenter->instrument());
m_model = m_experimentDefaults->get(m_mainPresenter->instrument());
updateViewFromModel();
}
......
qt/scientific_interfaces/ISISReflectometry/GUI/Experiment/ExperimentPresenter.h
+ 9
− 2
View file @ f7aeba33
......@@ -9,6 +9,7 @@
#include "Common/DllConfig.h"
#include "Common/ValidationResult.h"
#include "ExperimentOptionDefaults.h"
#include "IExperimentPresenter.h"
#include "IExperimentView.h"
#include "PerThetaDefaultsTableValidationError.h"
......@@ -45,8 +46,11 @@ class MANTIDQT_ISISREFLECTOMETRY_DLL ExperimentPresenter
: public ExperimentViewSubscriber,
public IExperimentPresenter {
public:
ExperimentPresenter(IExperimentView *view, Experiment experiment,
double defaultsThetaTolerance);
ExperimentPresenter(
IExperimentView *view, Experiment experiment,
double defaultsThetaTolerance,
std::unique_ptr<IExperimentOptionDefaults> experimentDefaults =
std::make_unique<ExperimentOptionDefaults>());
void acceptMainPresenter(IBatchPresenter *mainPresenter) override;
Experiment const &experiment() const override;
......@@ -64,6 +68,9 @@ public:
void autoreductionResumed() override;
void instrumentChanged(std::string const &instrumentName) override;
protected:
std::unique_ptr<IExperimentOptionDefaults> m_experimentDefaults;
private:
IBatchPresenter *m_mainPresenter;
......
qt/scientific_interfaces/test/ISISReflectometry/Experiment/ExperimentOptionDefaultsTest.h
+ 39
− 81
View file @ f7aeba33
......@@ -24,10 +24,6 @@ using testing::NiceMock;
using testing::Return;
using testing::_;
// The missing braces warning is a false positive -
// https://llvm.org/bugs/show_bug.cgi?id=21629
GNU_DIAG_OFF("missing-braces")
class ExperimentOptionDefaultsTest : public CxxTest::TestSuite {
public:
// This pair of boilerplate methods prevent the suite being created statically
......@@ -37,138 +33,100 @@ public:
}
static void destroySuite(ExperimentOptionDefaultsTest *suite) { delete suite; }
ExperimentOptionDefaultsTest() : m_view() {
ExperimentOptionDefaultsTest() {
Mantid::API::FrameworkManager::Instance();
}
void testValidAnalysisMode() {
auto presenter = makePresenter();
expectInstrumentWithParameters("Analysis");
presenter.notifyRestoreDefaultsRequested();
TS_ASSERT_EQUALS(presenter.experiment().analysisMode(),
void testValidAnalysisMode() {
auto result = getDefaults("Analysis");
TS_ASSERT_EQUALS(result.analysisMode(),
AnalysisMode::MultiDetector);
verifyAndClear();
}
void testInvalidAnalysisMode() {
auto presenter = makePresenter();
expectInstrumentWithParameters("Analysis_Invalid");
TS_ASSERT_THROWS(presenter.notifyRestoreDefaultsRequested(), std::invalid_argument);
getDefaultsThrows("Analysis_Invalid");
}
void testValidReductionOptions() {
auto presenter = makePresenter();
expectInstrumentWithParameters("Reduction");
presenter.notifyRestoreDefaultsRequested();
TS_ASSERT_EQUALS(presenter.experiment().summationType(),
auto result = getDefaults("Reduction");
TS_ASSERT_EQUALS(result.summationType(),
SummationType::SumInQ);
TS_ASSERT_EQUALS(presenter.experiment().reductionType(),
TS_ASSERT_EQUALS(result.reductionType(),
ReductionType::NonFlatSample);
TS_ASSERT_EQUALS(presenter.experiment().includePartialBins(), true);
verifyAndClear();
TS_ASSERT_EQUALS(result.includePartialBins(), true);
}
void testInvalidReductionOptions() {
auto presenter = makePresenter();
expectInstrumentWithParameters("Reduction_Invalid");
TS_ASSERT_THROWS(presenter.notifyRestoreDefaultsRequested(), std::invalid_argument);
getDefaultsThrows("Reduction_Invalid");
}
void testValidDebugOptions() {
auto presenter = makePresenter();
expectInstrumentWithParameters("Debug");
presenter.notifyRestoreDefaultsRequested();
TS_ASSERT_EQUALS(presenter.experiment().debug(), true);
verifyAndClear();
auto result = getDefaults("Debug");
TS_ASSERT_EQUALS(result.debug(), true);
}
void testInvalidDebugOptions() {
auto presenter = makePresenter();
expectInstrumentWithParameters("Debug_Invalid");
TS_ASSERT_THROWS(presenter.notifyRestoreDefaultsRequested(), std::invalid_argument);
getDefaultsThrows("Debug_Invalid");
}
void testValidPerThetaOptions() {
auto presenter = makePresenter();
expectInstrumentWithParameters("PerTheta");
presenter.notifyRestoreDefaultsRequested();
auto result = getDefaults("PerTheta");
auto expected = PerThetaDefaults(boost::none, TransmissionRunPair(),
RangeInQ(0.01, 0.03, 0.2), 0.7,
std::string("390-415"));
TS_ASSERT_EQUALS(presenter.experiment().perThetaDefaults().size(), 1);
TS_ASSERT_EQUALS(presenter.experiment().perThetaDefaults().front(),
TS_ASSERT_EQUALS(result.perThetaDefaults().size(), 1);
TS_ASSERT_EQUALS(result.perThetaDefaults().front(),
expected);
verifyAndClear();
}
void testInvalidPerThetaOptions() {
auto presenter = makePresenter();
expectInstrumentWithParameters("PerTheta_Invalid");
TS_ASSERT_THROWS(presenter.notifyRestoreDefaultsRequested(), std::invalid_argument);
getDefaultsThrows("PerTheta_Invalid");
}
void testValidTransmissionRunRange() {
auto presenter = makePresenter();
expectInstrumentWithParameters("TransmissionRunRange");
presenter.notifyRestoreDefaultsRequested();
auto result = getDefaults("TransmissionRunRange");
auto const expected = RangeInLambda{10.0, 12.0};
TS_ASSERT_EQUALS(presenter.experiment().transmissionRunRange(), expected);
verifyAndClear();
TS_ASSERT_EQUALS(result.transmissionRunRange(), expected);
}
void testInvalidTransmissionRunRange() {
auto presenter = makePresenter();
expectInstrumentWithParameters("TransmissionRunRange_Invalid");
TS_ASSERT_THROWS(presenter.notifyRestoreDefaultsRequested(), std::invalid_argument);
getDefaultsThrows("TransmissionRunRange_Invalid");
}
void testValidCorrectionOptions() {
auto presenter = makePresenter();
expectInstrumentWithParameters("Correction");
presenter.notifyRestoreDefaultsRequested();
auto result = getDefaults("Correction");
TS_ASSERT_EQUALS(
presenter.experiment().polarizationCorrections().correctionType(),
result.polarizationCorrections().correctionType(),
PolarizationCorrectionType::ParameterFile);
TS_ASSERT_EQUALS(presenter.experiment().floodCorrections().correctionType(),
TS_ASSERT_EQUALS(result.floodCorrections().correctionType(),
FloodCorrectionType::ParameterFile);
verifyAndClear();
}
void testInvalidCorrectionOptions() {
auto presenter = makePresenter();
expectInstrumentWithParameters("Correction_Invalid");
TS_ASSERT_THROWS(presenter.notifyRestoreDefaultsRequested(), std::invalid_argument);
getDefaultsThrows("Correction_Invalid");
}
private:
void verifyAndClear() {
TS_ASSERT(Mock::VerifyAndClearExpectations(&m_view));
TS_ASSERT(Mock::VerifyAndClearExpectations(&m_mainPresenter));
}
// Get a dummy reflectometry instrument with the given parameters file type.
// paramsType is appended to "REFL_Parameters_" to form the name for the file
// to load. See ReflectometryHelper.h for details.
void Mantid::Geometry::Instrument_const_sptr
getInstrumentWithParameters(std::string const &paramsType) {
Experiment getDefaults(std::string const &paramsType) {
// Get a dummy reflectometry instrument with the given parameters file type.
// paramsType is appended to "REFL_Parameters_" to form the name for the file
// to load. See ReflectometryHelper.h for details.
auto workspace = Mantid::TestHelpers::createREFL_WS(
5, 100.0, 500.0, {1.0, 2.0, 3.0, 4.0, 5.0}, paramsType);
return workspace->getInstrument();
auto instrument = workspace->getInstrument();
ExperimentOptionDefaults experimentDefaults;
return experimentDefaults.get(instrument);
}
void expectInstrumentWithDefaultParameters() {
// Use the default REFL_Parameters.xml file, which is empty
expectInstrumentWithParameters("");
}
void expectInstrumentWithParameters(std::string const &paramsType) {
// Use the REFL_Parameters_<paramsType> file
auto instrument = getInstrumentWithParameters(paramsType);
EXPECT_CALL(m_mainPresenter, instrument())
.Times(1)
.WillOnce(Return(instrument));
void getDefaultsThrows(std::string const &paramsType) {
auto workspace = Mantid::TestHelpers::createREFL_WS(
5, 100.0, 500.0, {1.0, 2.0, 3.0, 4.0, 5.0}, paramsType);
auto instrument = workspace->getInstrument();
ExperimentOptionDefaults experimentDefaults;
TS_ASSERT_THROWS(experimentDefaults.get(instrument), std::invalid_argument);
}
GNU_DIAG_ON("missing-braces")
};
#endif // MANTID_CUSTOMINTERFACES_EXPERIMENTOPTIONDEFAULTSTEST_H_
qt/scientific_interfaces/test/ISISReflectometry/Experiment/ExperimentPresenterTest.h
+ 143
− 66
View file @ f7aeba33
......@@ -14,6 +14,7 @@
#include "MantidGeometry/Instrument.h"
#include "MantidTestHelpers/ReflectometryHelper.h"
#include "MockExperimentView.h"
#include "MockExperimentOptionDefaults.h"
#include <cxxtest/TestSuite.h>
#include <gmock/gmock.h>
......@@ -434,24 +435,26 @@ public:
}
void testRestoreDefaultsNotifiesMainPresenter() {
auto presenter = makePresenter();
expectInstrumentWithDefaultParameters();
auto defaultOptions = expectDefaults(makeModel());
auto presenter = makePresenter(std::move(defaultOptions));
EXPECT_CALL(m_mainPresenter, notifySettingsChanged()).Times(AtLeast(1));
presenter.notifyRestoreDefaultsRequested();
verifyAndClear();
}
void testRestoreDefaultsUpdatesAnalysisModeInView() {
auto presenter = makePresenter();
expectInstrumentWithParameters("Analysis");
auto model = makeModelWithAnalysisMode(AnalysisMode::MultiDetector);
auto defaultOptions = expectDefaults(model);
auto presenter = makePresenter(std::move(defaultOptions));
EXPECT_CALL(m_view, setAnalysisMode("MultiDetectorAnalysis")).Times(1);
presenter.notifyRestoreDefaultsRequested();
verifyAndClear();
}
void testRestoreDefaultsUpdatesAnalysisModeInModel() {
auto presenter = makePresenter();
expectInstrumentWithParameters("Analysis");
auto model = makeModelWithAnalysisMode(AnalysisMode::MultiDetector);
auto defaultOptions = expectDefaults(model);
auto presenter = makePresenter(std::move(defaultOptions));
presenter.notifyRestoreDefaultsRequested();
TS_ASSERT_EQUALS(presenter.experiment().analysisMode(),
AnalysisMode::MultiDetector);
......@@ -459,8 +462,10 @@ public:
}
void testRestoreDefaultsUpdatesReductionOptionsInView() {
auto presenter = makePresenter();
expectInstrumentWithParameters("Reduction");
auto model = makeModelWithReduction(SummationType::SumInQ,
ReductionType::NonFlatSample, true);
auto defaultOptions = expectDefaults(model);
auto presenter = makePresenter(std::move(defaultOptions));
EXPECT_CALL(m_view, setSummationType("SumInQ")).Times(1);
EXPECT_CALL(m_view, setReductionType("NonFlatSample")).Times(1);
EXPECT_CALL(m_view, setIncludePartialBins(true)).Times(1);
......@@ -469,8 +474,10 @@ public:
}
void testRestoreDefaultsUpdatesReductionOptionsInModel() {
auto presenter = makePresenter();
expectInstrumentWithParameters("Reduction");
auto model = makeModelWithReduction(SummationType::SumInQ,
ReductionType::NonFlatSample, true);
auto defaultOptions = expectDefaults(model);
auto presenter = makePresenter(std::move(defaultOptions));
presenter.notifyRestoreDefaultsRequested();
TS_ASSERT_EQUALS(presenter.experiment().summationType(),
SummationType::SumInQ);
......@@ -481,24 +488,30 @@ public:
}
void testRestoreDefaultsUpdatesDebugOptionsInView() {
auto presenter = makePresenter();
expectInstrumentWithParameters("Debug");
auto model = makeModelWithDebug(true);
auto defaultOptions = expectDefaults(model);
auto presenter = makePresenter(std::move(defaultOptions));
EXPECT_CALL(m_view, setDebugOption(true)).Times(1);
presenter.notifyRestoreDefaultsRequested();
verifyAndClear();
}
void testRestoreDefaultsUpdatesDebugOptionsInModel() {
auto presenter = makePresenter();
expectInstrumentWithParameters("Debug");
auto model = makeModelWithDebug(true);
auto defaultOptions = expectDefaults(model);
auto presenter = makePresenter(std::move(defaultOptions));
presenter.notifyRestoreDefaultsRequested();
TS_ASSERT_EQUALS(presenter.experiment().debug(), true);
verifyAndClear();
}
void testRestoreDefaultsUpdatesPerThetaInView() {
auto presenter = makePresenter();
expectInstrumentWithParameters("PerTheta");
auto perThetaDefaults = PerThetaDefaults(boost::none, TransmissionRunPair(),
RangeInQ(0.01, 0.03, 0.2),
0.7, std::string("390-415"));
auto model = makeModelWithPerThetaDefaults(std::move(perThetaDefaults));
auto defaultOptions = expectDefaults(model);
auto presenter = makePresenter(std::move(defaultOptions));
auto const expected = std::vector<std::array<std::string, 8>>{
{"", "", "", "0.010000", "0.200000", "0.030000", "0.700000",
"390-415"}};
......@@ -508,8 +521,12 @@ public:
}
void testRestoreDefaultsUpdatesPerThetaInModel() {
auto presenter = makePresenter();
expectInstrumentWithParameters("PerTheta");
auto model = makeModelWithPerThetaDefaults(PerThetaDefaults(boost::none,
TransmissionRunPair(),
RangeInQ(0.01, 0.03, 0.2),
0.7, std::string("390-415")));
auto defaultOptions = expectDefaults(model);
auto presenter = makePresenter(std::move(defaultOptions));
presenter.notifyRestoreDefaultsRequested();
auto expected = PerThetaDefaults(boost::none, TransmissionRunPair(),
RangeInQ(0.01, 0.03, 0.2), 0.7,
......@@ -521,8 +538,9 @@ public:
}
void testRestoreDefaultsUpdatesTransmissionRunRangeInView() {
auto presenter = makePresenter();
expectInstrumentWithParameters("TransmissionRunRange");
auto model = makeModelWithTransmissionRunRange(RangeInLambda{10.0, 12.0});
auto defaultOptions = expectDefaults(model);
auto presenter = makePresenter(std::move(defaultOptions));
EXPECT_CALL(m_view, setTransmissionStartOverlap(10.0)).Times(1);
EXPECT_CALL(m_view, setTransmissionEndOverlap(12.0)).Times(1);
EXPECT_CALL(m_view, showTransmissionRangeValid()).Times(1);
......@@ -531,8 +549,9 @@ public:
}
void testRestoreDefaultsUpdatesTransmissionRunRangeInModel() {
auto presenter = makePresenter();
expectInstrumentWithParameters("TransmissionRunRange");
auto model = makeModelWithTransmissionRunRange(RangeInLambda{10.0, 12.0});
auto defaultOptions = expectDefaults(model);
auto presenter = makePresenter(std::move(defaultOptions));
presenter.notifyRestoreDefaultsRequested();
auto const expected = RangeInLambda{10.0, 12.0};
TS_ASSERT_EQUALS(presenter.experiment().transmissionRunRange(), expected);
......@@ -540,8 +559,11 @@ public:
}
void testRestoreDefaultsUpdatesCorrectionInView() {
auto presenter = makePresenter();
expectInstrumentWithParameters("Correction");
auto model = makeModelWithCorrections(
PolarizationCorrections(PolarizationCorrectionType::ParameterFile),
FloodCorrections(FloodCorrectionType::ParameterFile));
auto defaultOptions = expectDefaults(model);
auto presenter = makePresenter(std::move(defaultOptions));
EXPECT_CALL(m_view, setPolarizationCorrectionType("ParameterFile"))
.Times(1);
EXPECT_CALL(m_view, setFloodCorrectionType("ParameterFile")).Times(1);
......@@ -550,8 +572,10 @@ public:
}
void testRestoreDefaultsUpdatesCorrectionInModel() {
auto presenter = makePresenter();
expectInstrumentWithParameters("Correction");
auto model = makeModelWithCorrections(PolarizationCorrections(PolarizationCorrectionType::ParameterFile),
FloodCorrections(FloodCorrectionType::ParameterFile));
auto defaultOptions = expectDefaults(model);
auto presenter = makePresenter(std::move(defaultOptions));
presenter.notifyRestoreDefaultsRequested();
TS_ASSERT_EQUALS(
presenter.experiment().polarizationCorrections().correctionType(),
......@@ -564,33 +588,100 @@ public:
private:
NiceMock<MockExperimentView> m_view;
NiceMock<MockBatchPresenter> m_mainPresenter;
NiceMock<MockExperimentOptionDefaults> m_defaultOptions;
double m_thetaTolerance{0.01};
PolarizationCorrections makePolarizationCorrections() {
return PolarizationCorrections(PolarizationCorrectionType::None);
}
FloodCorrections makeFloodCorrections() {
return FloodCorrections(FloodCorrectionType::Workspace);
}
RangeInLambda makeTransmissionRunRange() {
return RangeInLambda{0, 0};
}
std::map<std::string, std::string> makeStitchParameters() {
return std::map<std::string, std::string>();
}
std::vector<PerThetaDefaults> makePerThetaDefaults() {
auto perThetaDefaults = PerThetaDefaults(boost::none, TransmissionRunPair(),
RangeInQ(boost::none, boost::none, boost::none),
boost::none, boost::none);
return std::vector<PerThetaDefaults>{std::move(perThetaDefaults)};
}
Experiment makeModel() {
auto polarizationCorrections =
PolarizationCorrections(PolarizationCorrectionType::None);
auto floodCorrections = FloodCorrections(FloodCorrectionType::Workspace);
auto transmissionRunRange = RangeInLambda{0, 0};
auto stitchParameters = std::map<std::string, std::string>();
auto perThetaDefaults =
PerThetaDefaults(boost::none, TransmissionRunPair(),
RangeInQ(boost::none, boost::none, boost::none),
boost::none, boost::none);
auto perThetaDefaultsList =
std::vector<PerThetaDefaults>{std::move(perThetaDefaults)};
return Experiment(AnalysisMode::PointDetector, ReductionType::Normal,
SummationType::SumInLambda, false, false,
makePolarizationCorrections(),
makeFloodCorrections(), makeTransmissionRunRange(),
makeStitchParameters(), makePerThetaDefaults());
}
Experiment makeModelWithAnalysisMode(AnalysisMode analysisMode) {
return Experiment(analysisMode, ReductionType::Normal,
SummationType::SumInLambda, false, false,
makePolarizationCorrections(),
makeFloodCorrections(), makeTransmissionRunRange(),
makeStitchParameters(), makePerThetaDefaults());
}
Experiment makeModelWithReduction(SummationType summationType,
ReductionType reductionType,
bool includePartialBins) {
return Experiment(AnalysisMode::PointDetector, reductionType,
summationType, includePartialBins, false,
makePolarizationCorrections(),
makeFloodCorrections(), makeTransmissionRunRange(),
makeStitchParameters(), makePerThetaDefaults());
}
Experiment makeModelWithDebug(bool debug) {
return Experiment(AnalysisMode::PointDetector, ReductionType::Normal,
SummationType::SumInLambda, false, debug,
makePolarizationCorrections(),
makeFloodCorrections(), makeTransmissionRunRange(),
makeStitchParameters(), makePerThetaDefaults());
}
Experiment makeModelWithPerThetaDefaults(PerThetaDefaults perThetaDefaults) {
auto perThetaList = std::vector<PerThetaDefaults>();
perThetaList.emplace_back(std::move(perThetaDefaults));
return Experiment(AnalysisMode::PointDetector, ReductionType::Normal,
SummationType::SumInLambda, false, false,
makePolarizationCorrections(),
makeFloodCorrections(), makeTransmissionRunRange(),
makeStitchParameters(), std::move(perThetaList));
}
Experiment makeModelWithTransmissionRunRange(RangeInLambda range) {
return Experiment(AnalysisMode::PointDetector, ReductionType::Normal,
SummationType::SumInLambda, false, false,
makePolarizationCorrections(),
makeFloodCorrections(), std::move(range),
makeStitchParameters(), makePerThetaDefaults());
}
Experiment makeModelWithCorrections(PolarizationCorrections polarizationCorrections,
FloodCorrections floodCorrections) {
return Experiment(AnalysisMode::PointDetector, ReductionType::Normal,
SummationType::SumInLambda, false, false,
std::move(polarizationCorrections),
std::move(floodCorrections), transmissionRunRange,
std::move(stitchParameters),
std::move(perThetaDefaultsList));
std::move(floodCorrections), makeTransmissionRunRange(),
makeStitchParameters(), makePerThetaDefaults());
}
ExperimentPresenter makePresenter() {
ExperimentPresenter
makePresenter(std::unique_ptr<IExperimentOptionDefaults> defaultOptions =
std::make_unique<MockExperimentOptionDefaults>()) {
// The presenter gets values from the view on construction so the view must
// return something sensible
auto presenter =
ExperimentPresenter(&m_view, makeModel(), m_thetaTolerance);
auto presenter = ExperimentPresenter(&m_view, makeModel(), m_thetaTolerance,
std::move(defaultOptions));
presenter.acceptMainPresenter(&m_mainPresenter);
return presenter;
}
......@@ -628,6 +719,15 @@ private:
.WillOnce(Return(std::string("DivergentBeam")));
}
std::unique_ptr<IExperimentOptionDefaults>
expectDefaults(Experiment const &model) {
// Create a defaults object, set expectations on it, and return it so
// that it can be passed to the presenter
auto defaultOptions = std::make_unique<MockExperimentOptionDefaults>();
EXPECT_CALL(*defaultOptions, get(_)).Times(1).WillOnce(Return(model));
return defaultOptions;
}
void runWithPolarizationCorrectionInputsDisabled(std::string const &type) {
auto presenter = makePresenter();
......@@ -747,29 +847,6 @@ private:
return {"", "", "", "", "", "", "", "bad"};
}
// Get a dummy reflectometry instrument with the given parameters file type.
// paramsType is appended to "REFL_Parameters_" to form the name for the file
// to load. See ReflectometryHelper.h for details.
Mantid::Geometry::Instrument_const_sptr
getInstrumentWithParameters(std::string const &paramsType) {
auto workspace = Mantid::TestHelpers::createREFL_WS(
5, 100.0, 500.0, {1.0, 2.0, 3.0, 4.0, 5.0}, paramsType);
return workspace->getInstrument();
}
void expectInstrumentWithDefaultParameters() {
// Use the default REFL_Parameters.xml file, which is empty
expectInstrumentWithParameters("");
}
void expectInstrumentWithParameters(std::string const &paramsType) {
// Use the REFL_Parameters_<paramsType> file
auto instrument = getInstrumentWithParameters(paramsType);
EXPECT_CALL(m_mainPresenter, instrument())
.Times(1)
.WillOnce(Return(instrument));
}
void runTestForValidPerAngleOptions(OptionsTable const &optionsTable) {
auto presenter = makePresenter();
EXPECT_CALL(m_view, getPerAngleOptions()).WillOnce(Return(optionsTable));
......
qt/scientific_interfaces/test/ISISReflectometry/Experiment/MockExperimentOptionDefaults.h 0 → 100644
+ 23
− 0
View file @ f7aeba33
// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright &copy; 2019 ISIS Rutherford Appleton Laboratory UKRI,
// NScD Oak Ridge National Laboratory, European Spallation Source
// & Institut Laue - Langevin
// SPDX - License - Identifier: GPL - 3.0 +
#include "../../../ISISReflectometry/GUI/Experiment/ExperimentOptionDefaults.h"
#include "MantidKernel/WarningSuppressions.h"
#include <gmock/gmock.h>
GNU_DIAG_OFF_SUGGEST_OVERRIDE
namespace MantidQt {
namespace CustomInterfaces {
class MockExperimentOptionDefaults : public IExperimentOptionDefaults {
public:
MOCK_METHOD1(get, Experiment(
Mantid::Geometry::Instrument_const_sptr instrument));
};
} // namespace CustomInterfaces
} // namespace MantidQt
GNU_DIAG_ON_SUGGEST_OVERRIDE
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment