Enable ISISEnergyTransferPresenterTest

qt/scientific_interfaces/Indirect/Common/IndirectInstrumentConfig.h

@@ -17,6 +17,41 @@
 
 namespace MantidQt {
 namespace MantidWidgets {
+
+class IInstrumentConfig {
+public:
+  virtual ~IInstrumentConfig() = default;
+
+  virtual QStringList getTechniques() = 0;
+  virtual void setTechniques(const QStringList &techniques) = 0;
+
+  virtual QStringList getDisabledInstruments() = 0;
+  virtual void setDisabledInstruments(const QStringList &instrumentNames) = 0;
+
+  virtual QString getFacility() = 0;
+  virtual void setFacility(const QString &facilityName) = 0;
+
+  virtual bool isDiffractionEnabled() = 0;
+  virtual void enableDiffraction(bool enabled) = 0;
+
+  virtual bool isDiffractionForced() = 0;
+  virtual void forceDiffraction(bool forced) = 0;
+
+  virtual bool isInstrumentLabelShown() = 0;
+  virtual void setShowInstrumentLabel(bool visible) = 0;
+
+  virtual QString getInstrumentName() = 0;
+  virtual void setInstrument(const QString &instrumentName) = 0;
+
+  virtual QString getAnalyserName() = 0;
+  virtual void setAnalyser(const QString &analyserName) = 0;
+
+  virtual QString getReflectionName() = 0;
+  virtual void setReflection(const QString &reflectionName) = 0;
+
+  virtual void showAnalyserAndReflectionOptions(bool visible) = 0;
+};
+
 /**
 Widget used to select an instrument configuration for indirect geometry
 spectrometers
@@ -29,7 +64,7 @@ are populated by loading an empty instrument.
 @author Dan Nixon
 */
 
-class MANTIDQT_INDIRECT_DLL IndirectInstrumentConfig : public API::MantidWidget {
+class MANTIDQT_INDIRECT_DLL IndirectInstrumentConfig : public API::MantidWidget, public IInstrumentConfig {
   Q_OBJECT
 
   Q_PROPERTY(QStringList techniques READ getTechniques WRITE setTechniques)
@@ -44,41 +79,41 @@ class MANTIDQT_INDIRECT_DLL IndirectInstrumentConfig : public API::MantidWidget
   ~IndirectInstrumentConfig() override;
 
   /* Getters and setters for Qt properties */
-  QStringList getTechniques();
-  void setTechniques(const QStringList &techniques);
+  QStringList getTechniques() override;
+  void setTechniques(const QStringList &techniques) override;
 
-  QStringList getDisabledInstruments();
-  void setDisabledInstruments(const QStringList &instrumentNames);
+  QStringList getDisabledInstruments() override;
+  void setDisabledInstruments(const QStringList &instrumentNames) override;
 
-  QString getFacility();
-  void setFacility(const QString &facilityName);
+  QString getFacility() override;
+  void setFacility(const QString &facilityName) override;
 
-  bool isDiffractionEnabled();
-  void enableDiffraction(bool enabled);
+  bool isDiffractionEnabled() override;
+  void enableDiffraction(bool enabled) override;
 
-  bool isDiffractionForced();
-  void forceDiffraction(bool forced);
+  bool isDiffractionForced() override;
+  void forceDiffraction(bool forced) override;
 
-  bool isInstrumentLabelShown();
-  void setShowInstrumentLabel(bool visible);
+  bool isInstrumentLabelShown() override;
+  void setShowInstrumentLabel(bool visible) override;
 
   /// Gets the name of the selected instrument
-  QString getInstrumentName();
+  QString getInstrumentName() override;
   /// Set the displayed instrument (if exists)
-  void setInstrument(const QString &instrumentName);
+  void setInstrument(const QString &instrumentName) override;
 
   /// Gets the name of the selected analyser
-  QString getAnalyserName();
+  QString getAnalyserName() override;
   /// Set the displayed analyser bank (if exists)
-  void setAnalyser(const QString &analyserName);
+  void setAnalyser(const QString &analyserName) override;
 
   /// Gets the name of the selected reflection
-  QString getReflectionName();
+  QString getReflectionName() override;
   /// Set the displayed reflection mode (if exists)
-  void setReflection(const QString &reflectionName);
+  void setReflection(const QString &reflectionName) override;
 
   /// Controls where to show analyser and reflection options or not
-  void showAnalyserAndReflectionOptions(bool visible);
+  void showAnalyserAndReflectionOptions(bool visible) override;
 
 public slots:
   /// Called when an instrument configuration is selected

qt/scientific_interfaces/Indirect/Reduction/ILLEnergyTransfer.cpp

@@ -30,7 +30,7 @@ namespace MantidQt::CustomInterfaces {
 //----------------------------------------------------------------------------------------------
 /** Constructor
  */
-ILLEnergyTransfer::ILLEnergyTransfer(IndirectDataReduction *idrUI, QWidget *parent)
+ILLEnergyTransfer::ILLEnergyTransfer(IIndirectDataReduction *idrUI, QWidget *parent)
     : IndirectDataReductionTab(idrUI, parent) {
   m_uiForm.setupUi(parent);
 

qt/scientific_interfaces/Indirect/Reduction/ILLEnergyTransfer.h

@@ -13,16 +13,13 @@
 
 namespace MantidQt {
 namespace CustomInterfaces {
-/** ILLEnergyTransfer
+class IIndirectDataReduction;
 
-  @author Dan Nixon
-  @date 23/07/2014
-*/
 class MANTIDQT_INDIRECT_DLL ILLEnergyTransfer : public IndirectDataReductionTab {
   Q_OBJECT
 
 public:
-  ILLEnergyTransfer(IndirectDataReduction *idrUI, QWidget *parent = nullptr);
+  ILLEnergyTransfer(IIndirectDataReduction *idrUI, QWidget *parent = nullptr);
   ~ILLEnergyTransfer() override;
 
   void setup() override;

qt/scientific_interfaces/Indirect/Reduction/ISISCalibration.cpp

@@ -41,7 +41,7 @@ namespace MantidQt::CustomInterfaces {
 //----------------------------------------------------------------------------------------------
 /** Constructor
  */
-ISISCalibration::ISISCalibration(IndirectDataReduction *idrUI, QWidget *parent)
+ISISCalibration::ISISCalibration(IIndirectDataReduction *idrUI, QWidget *parent)
     : IndirectDataReductionTab(idrUI, parent), m_lastCalPlotFilename("") {
   m_uiForm.setupUi(parent);
   setOutputPlotOptionsPresenter(

qt/scientific_interfaces/Indirect/Reduction/ISISCalibration.h

@@ -13,6 +13,8 @@
 
 namespace MantidQt {
 namespace CustomInterfaces {
+class IIndirectDataReduction;
+
 /** ISISCalibration
   Handles vanadium run calibration for ISIS instruments.
 
@@ -23,7 +25,7 @@ class MANTIDQT_INDIRECT_DLL ISISCalibration : public IndirectDataReductionTab {
   Q_OBJECT
 
 public:
-  ISISCalibration(IndirectDataReduction *idrUI, QWidget *parent = nullptr);
+  ISISCalibration(IIndirectDataReduction *idrUI, QWidget *parent = nullptr);
   ~ISISCalibration() override;
 
   void setup() override;

qt/scientific_interfaces/Indirect/Reduction/ISISDiagnostics.cpp

@@ -24,7 +24,7 @@ namespace MantidQt::CustomInterfaces {
 //----------------------------------------------------------------------------------------------
 /** Constructor
  */
-ISISDiagnostics::ISISDiagnostics(IndirectDataReduction *idrUI, QWidget *parent)
+ISISDiagnostics::ISISDiagnostics(IIndirectDataReduction *idrUI, QWidget *parent)
     : IndirectDataReductionTab(idrUI, parent) {
   m_uiForm.setupUi(parent);
   setOutputPlotOptionsPresenter(

qt/scientific_interfaces/Indirect/Reduction/ISISDiagnostics.h

@@ -32,6 +32,8 @@
 
 namespace MantidQt {
 namespace CustomInterfaces {
+class IIndirectDataReduction;
+
 /** ISISDiagnostics
   Handles time integration diagnostics for ISIS instruments.
 
@@ -42,7 +44,7 @@ class MANTIDQT_INDIRECT_DLL ISISDiagnostics : public IndirectDataReductionTab {
   Q_OBJECT
 
 public:
-  ISISDiagnostics(IndirectDataReduction *idrUI, QWidget *parent = nullptr);
+  ISISDiagnostics(IIndirectDataReduction *idrUI, QWidget *parent = nullptr);
   ~ISISDiagnostics() override;
 
   void setup() override;

qt/scientific_interfaces/Indirect/Reduction/ISISEnergyTransferModel.cpp

@@ -16,7 +16,7 @@
 using namespace Mantid::API;
 
 namespace MantidQt::CustomInterfaces {
-IETModel::IETModel() {}
+IETModel::IETModel() : m_outputWorkspaces() {}
 
 std::vector<std::string> IETModel::validateRunData(IETRunData const &runData) {
   std::vector<std::string> errors;
@@ -110,7 +110,7 @@ void IETModel::setOutputProperties(IAlgorithmRuntimeProps &properties, IETOutput
   Mantid::API::AlgorithmProperties::update("OutputWorkspace", outputGroupName, properties);
 }
 
-std::string IETModel::getOuputGroupName(InstrumentData const &instData, std::string const &inputText) {
+std::string IETModel::getOutputGroupName(InstrumentData const &instData, std::string const &inputText) {
   std::string instrument = instData.getInstrument();
   std::string analyser = instData.getAnalyser();
   std::string reflection = instData.getReflection();
@@ -129,7 +129,7 @@ std::string IETModel::runIETAlgorithm(MantidQt::API::BatchAlgorithmRunner *batch
   setRebinProperties(*properties, runData.getRebinData());
   setAnalysisProperties(*properties, runData.getAnalysisData());
 
-  std::string outputGroupName = getOuputGroupName(instData, runData.getInputData().getInputText());
+  std::string outputGroupName = getOutputGroupName(instData, runData.getInputData().getInputText());
   setOutputProperties(*properties, runData.getOutputData(), outputGroupName);
 
   auto reductionAlg = AlgorithmManager::Instance().create("ISISIndirectEnergyTransfer");
@@ -274,11 +274,11 @@ double IETModel::loadDetailedBalance(std::string const &filename) {
 
 std::vector<std::string> IETModel::groupWorkspaces(std::string const &groupName, std::string const &instrument,
                                                    std::string const &groupOption, bool const shouldGroup) {
-  std::vector<std::string> outputWorkspaces;
+  m_outputWorkspaces.clear();
 
   if (WorkspaceUtils::doesExistInADS(groupName)) {
     if (auto const outputGroup = WorkspaceUtils::getADSWorkspace<WorkspaceGroup>(groupName)) {
-      outputWorkspaces = outputGroup->getNames();
+      m_outputWorkspaces = outputGroup->getNames();
 
       if (instrument == "OSIRIS") {
         if (!shouldGroup) {
@@ -296,7 +296,7 @@ std::vector<std::string> IETModel::groupWorkspaces(std::string const &groupName,
     }
   }
 
-  return outputWorkspaces;
+  return m_outputWorkspaces;
 }
 
 void IETModel::ungroupWorkspace(std::string const &workspaceName) {

qt/scientific_interfaces/Indirect/Reduction/ISISEnergyTransferModel.h

@@ -17,12 +17,58 @@ using namespace Mantid::API;
 
 namespace MantidQt {
 namespace CustomInterfaces {
-class MANTIDQT_INDIRECT_DLL IETModel {
+
+class MANTIDQT_INDIRECT_DLL IIETModel {
+public:
+  virtual ~IIETModel() = default;
+
+  virtual void setInstrumentProperties(IAlgorithmRuntimeProps &properties, InstrumentData const &instData) = 0;
+
+  virtual std::vector<std::string> validateRunData(IETRunData const &runData) = 0;
+  virtual std::vector<std::string> validatePlotData(IETPlotData const &plotData) = 0;
+
+  virtual std::string runIETAlgorithm(MantidQt::API::BatchAlgorithmRunner *batchAlgoRunner,
+                                      InstrumentData const &instData, IETRunData &runParams) = 0;
+  virtual std::deque<MantidQt::API::IConfiguredAlgorithm_sptr>
+  plotRawAlgorithmQueue(InstrumentData const &instData, IETPlotData const &plotData) const = 0;
+
+  virtual void saveWorkspace(std::string const &workspaceName, IETSaveData const &saveData) = 0;
+
+  virtual void createGroupingWorkspace(std::string const &instrumentName, std::string const &analyser,
+                                       std::string const &customGrouping, std::string const &outputName) = 0;
+  virtual double loadDetailedBalance(std::string const &filename) = 0;
+
+  virtual std::vector<std::string> groupWorkspaces(std::string const &groupName, std::string const &instrument,
+                                                   std::string const &groupOption, bool const shouldGroup) = 0;
+
+  virtual std::vector<std::string> outputWorkspaceNames() const = 0;
+};
+
+class MANTIDQT_INDIRECT_DLL IETModel : public IIETModel {
 public:
   IETModel();
   ~IETModel() = default;
 
-  void setInstrumentProperties(IAlgorithmRuntimeProps &properties, InstrumentData const &instData);
+  void setInstrumentProperties(IAlgorithmRuntimeProps &properties, InstrumentData const &instData) override;
+
+  std::vector<std::string> validateRunData(IETRunData const &runData) override;
+  std::vector<std::string> validatePlotData(IETPlotData const &plotData) override;
+
+  std::string runIETAlgorithm(MantidQt::API::BatchAlgorithmRunner *batchAlgoRunner, InstrumentData const &instData,
+                              IETRunData &runParams) override;
+  std::deque<MantidQt::API::IConfiguredAlgorithm_sptr>
+  plotRawAlgorithmQueue(InstrumentData const &instData, IETPlotData const &plotData) const override;
+
+  void saveWorkspace(std::string const &workspaceName, IETSaveData const &saveData) override;
+
+  void createGroupingWorkspace(std::string const &instrumentName, std::string const &analyser,
+                               std::string const &customGrouping, std::string const &outputName) override;
+  double loadDetailedBalance(std::string const &filename) override;
+
+  std::vector<std::string> groupWorkspaces(std::string const &groupName, std::string const &instrument,
+                                           std::string const &groupOption, bool const shouldGroup) override;
+
+  // Public for testing purposes
   void setInputProperties(IAlgorithmRuntimeProps &properties, IETInputData const &inputData);
   void setConversionProperties(IAlgorithmRuntimeProps &properties, IETConversionData const &conversionData,
                                std::string const &instrument);
@@ -31,36 +77,27 @@ class MANTIDQT_INDIRECT_DLL IETModel {
   void setAnalysisProperties(IAlgorithmRuntimeProps &properties, IETAnalysisData const &analysisData);
   void setOutputProperties(IAlgorithmRuntimeProps &properties, IETOutputData const &outputData,
                            std::string const &outputGroupName);
-  std::string getOuputGroupName(InstrumentData const &instData, std::string const &inputFiles);
-
-  std::vector<std::string> validateRunData(IETRunData const &runData);
-  std::vector<std::string> validatePlotData(IETPlotData const &plotData);
+  std::string getOutputGroupName(InstrumentData const &instData, std::string const &inputFiles);
 
-  std::string runIETAlgorithm(MantidQt::API::BatchAlgorithmRunner *batchAlgoRunner, InstrumentData const &instData,
-                              IETRunData &runParams);
-  std::deque<MantidQt::API::IConfiguredAlgorithm_sptr> plotRawAlgorithmQueue(InstrumentData const &instData,
-                                                                             IETPlotData const &plotData) const;
+  [[nodiscard]] inline std::vector<std::string> outputWorkspaceNames() const noexcept override {
+    return m_outputWorkspaces;
+  }
 
-  void saveWorkspace(std::string const &workspaceName, IETSaveData const &saveData);
+private:
   void saveDaveGroup(std::string const &workspaceName, std::string const &outputName);
   void saveAclimax(std::string const &workspaceName, std::string const &outputName,
                    std::string const &xUnits = "DeltaE_inWavenumber");
   void save(std::string const &algorithmName, std::string const &workspaceName, std::string const &outputName,
             int const version = -1, std::string const &separator = "");
 
-  void createGroupingWorkspace(std::string const &instrumentName, std::string const &analyser,
-                               std::string const &customGrouping, std::string const &outputName);
-  double loadDetailedBalance(std::string const &filename);
-
-  std::vector<std::string> groupWorkspaces(std::string const &groupName, std::string const &instrument,
-                                           std::string const &groupOption, bool const shouldGroup);
   void ungroupWorkspace(std::string const &workspaceName);
   void groupWorkspaceBySampleChanger(std::string const &workspaceName);
 
-private:
   std::deque<MantidQt::API::IConfiguredAlgorithm_sptr>
   plotRawAlgorithmQueue(std::string const &rawFile, std::string const &basename, std::string const &instrumentName,
                         std::vector<int> const &detectorList, IETBackgroundData const &backgroundData) const;
+
+  std::vector<std::string> m_outputWorkspaces;
 };
 } // namespace CustomInterfaces
 } // namespace MantidQt