Newer
Older
#ifndef MANTID_ALGORITHMS_GENERATEPYTHONSCRIPTTEST_H_
#define MANTID_ALGORITHMS_GENERATEPYTHONSCRIPTTEST_H_
#include <cxxtest/TestSuite.h>
#include "MantidAPI/AlgorithmManager.h"
#include "MantidAPI/MatrixWorkspace.h"
#include "MantidAPI/WorkspaceHistory.h"
#include "MantidAlgorithms/CreateWorkspace.h"
#include "MantidAlgorithms/CropWorkspace.h"
#include "MantidAlgorithms/GeneratePythonScript.h"
#include "MantidAlgorithms/GroupWorkspaces.h"
#include "MantidDataObjects/Workspace2D.h"
#include "MantidDataObjects/WorkspaceCreation.h"
#include "MantidHistogramData/Histogram.h"
#include "MantidKernel/System.h"
#include "MantidKernel/Timer.h"
#include "MantidKernel/make_unique.h"
#include <Poco/File.h>
#include <fstream>
using namespace Mantid;
using namespace Mantid::Algorithms;
using namespace Mantid::API;
using namespace Mantid::DataObjects;
using namespace Mantid::HistogramData;
class NonExistingAlgorithm : public Algorithm {
const std::string name() const override { return "NonExistingAlgorithm"; }
/// Algorithm's version for identification overriding a virtual method
int version() const override { return 1; }
/// Algorithm's category for identification overriding a virtual method
const std::string category() const override { return "Rubbish"; }
/// Summary of algorithms purpose
const std::string summary() const override {
return "I do not exist, or do I?";
}
declareProperty(
Kernel::make_unique<WorkspaceProperty<API::MatrixWorkspace>>(
"InputWorkspace", "", Kernel::Direction::Input),
"A workspace with units of TOF");
declareProperty(
Kernel::make_unique<WorkspaceProperty<API::MatrixWorkspace>>(
"OutputWorkspace", "", Kernel::Direction::Output),
"The name to use for the output workspace");
declareProperty("MissingProperty", "rubbish", Kernel::Direction::Input);
class GeneratePythonScriptTest : public CxxTest::TestSuite {
void test_Init() {
GeneratePythonScript alg;
TS_ASSERT_THROWS_NOTHING(alg.initialize())
TS_ASSERT(alg.isInitialized())
}
void test_exec() {
// Create test workspace
std::string workspaceName = "testGeneratePython";
create_test_workspace(workspaceName);
std::string result[] = {
"#####################################################################"
"#",
"#Python Script Generated by GeneratePythonScript Algorithm",
"#####################################################################"
"#",
"NonExistingAlgorithm()",
"CreateWorkspace(OutputWorkspace='"
"testGeneratePython', DataX='1,2,3,5,6', "
"DataY='7,9,16,4,3', DataE='2,3,4,2,1', "
"WorkspaceTitle='Test Workspace')",
"CropWorkspace(InputWorkspace='testGeneratePython', "
"OutputWorkspace='testGeneratePython', XMin=2, XMax=5)",
"Power(InputWorkspace='testGeneratePython', "
"OutputWorkspace='testGeneratePython', Exponent=1.5)",
""};
// Set up and execute the algorithm.
GeneratePythonScript alg;
TS_ASSERT_THROWS_NOTHING(alg.initialize());
TS_ASSERT(alg.isInitialized());
TS_ASSERT_THROWS_NOTHING(
alg.setPropertyValue("InputWorkspace", workspaceName));
TS_ASSERT_THROWS_NOTHING(
alg.setPropertyValue("Filename", "GeneratePythonScriptTest.py"));
TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("ScriptText", ""));
TS_ASSERT_THROWS_NOTHING(alg.execute(););
TS_ASSERT(alg.isExecuted());
// Compare the contents of the file to the expected result line-by-line.
std::string filename = alg.getProperty("Filename");
std::ifstream file(filename.c_str(), std::ifstream::in);
std::string scriptLine;
int lineCount = 0;
while (std::getline(file, scriptLine)) {
TS_ASSERT_EQUALS(result[lineCount], scriptLine)
lineCount++;
// Verify that if we set the content of ScriptText that it is set correctly.
alg.setPropertyValue("ScriptText", result[5]);
TS_ASSERT_EQUALS(alg.getPropertyValue("ScriptText"),
"CropWorkspace(InputWorkspace='testGeneratePython', "
"OutputWorkspace='testGeneratePython', XMin=2, XMax=5)");
file.close();
if (Poco::File(filename).exists())
Poco::File(filename).remove();
// Clean the ADS
Mantid::API::AnalysisDataService::Instance().clear();
}
void test_project_recovery_option() {
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
Mantid::Algorithms::CreateWorkspace creator;
creator.initialize();
creator.setPropertyValue("OutputWorkspace", "ws1");
creator.setPropertyValue("DataX", "1,2,3");
creator.setPropertyValue("DataY", "1,2,3");
creator.setPropertyValue("DataE", "1,2,3");
creator.setRethrows(true);
TS_ASSERT_THROWS_NOTHING(creator.execute());
TS_ASSERT_EQUALS(creator.isExecuted(), true);
Mantid::Algorithms::GroupWorkspaces mkGroup;
mkGroup.initialize();
mkGroup.setProperty("InputWorkspaces", "ws1");
mkGroup.setProperty("OutputWorkspace", "wsGroup");
TS_ASSERT_THROWS_NOTHING(mkGroup.execute());
TS_ASSERT(mkGroup.isExecuted());
std::string result[] = {
"#####################################################################"
"#",
"#Python Script Generated by GeneratePythonScript Algorithm",
"#####################################################################"
"#",
"CreateWorkspace(OutputWorkspace='ws1', DataX='1,2,3', DataY='1,2,3', "
"DataE='1,2,3')",
""};
// Set up and execute the algorithm.
GeneratePythonScript alg;
TS_ASSERT_THROWS_NOTHING(alg.initialize());
TS_ASSERT(alg.isInitialized());
TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("InputWorkspace", "wsGroup"));
TS_ASSERT_THROWS_NOTHING(
alg.setPropertyValue("Filename", "GeneratePythonScriptTest.py"));
TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("ScriptText", ""));
TS_ASSERT_THROWS_NOTHING(alg.setProperty("ProjectRecovery", true));
TS_ASSERT_THROWS_NOTHING(alg.execute(););
TS_ASSERT(alg.isExecuted());
// Compare the contents of the file to the expected result line-by-line.
std::string filename = alg.getProperty("Filename");
std::ifstream file(filename.c_str(), std::ifstream::in);
std::string scriptLine;
int lineCount = 0;
while (std::getline(file, scriptLine)) {
TS_ASSERT_EQUALS(result[lineCount], scriptLine)
lineCount++;
}
file.close();
if (Poco::File(filename).exists())
Poco::File(filename).remove();
Mantid::API::AnalysisDataService::Instance().clear();
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
}
void create_test_workspace(const std::string &wsName) {
Mantid::Algorithms::CreateWorkspace creator;
Mantid::Algorithms::CropWorkspace cropper;
Mantid::Algorithms::Power powerer;
// Set up and execute creation of the workspace
creator.initialize();
creator.setPropertyValue("OutputWorkspace", wsName);
creator.setPropertyValue("DataX", "1,2,3,5,6");
creator.setPropertyValue("DataY", "7,9,16,4,3");
creator.setPropertyValue("DataE", "2,3,4,2,1");
creator.setPropertyValue("WorkspaceTitle", "Test Workspace");
creator.setRethrows(true);
TS_ASSERT_THROWS_NOTHING(creator.execute());
TS_ASSERT_EQUALS(creator.isExecuted(), true);
// Set up and execute the cropping of the workspace
cropper.initialize();
cropper.setPropertyValue("InputWorkspace", wsName);
cropper.setPropertyValue("OutputWorkspace", wsName);
cropper.setPropertyValue("XMin", "2");
cropper.setPropertyValue("XMax", "5");
cropper.setRethrows(true);
TS_ASSERT_THROWS_NOTHING(cropper.execute());
TS_ASSERT_EQUALS(cropper.isExecuted(), true);
// Set up and execute Power algorithm on the workspace
powerer.initialize();
powerer.setPropertyValue("InputWorkspace", wsName);
powerer.setPropertyValue("OutputWorkspace", wsName);
powerer.setPropertyValue("Exponent", "1.5");
powerer.setRethrows(true);
TS_ASSERT_THROWS_NOTHING(powerer.execute());
TS_ASSERT_EQUALS(powerer.isExecuted(), true);
// set up history for the algorithn which is presumably removed from Mantid
auto ws = API::FrameworkManager::Instance().getWorkspace(wsName);
API::WorkspaceHistory &history = ws->history();
auto pAlg = Mantid::Kernel::make_unique<NonExistingAlgorithm>();
pAlg->initialize();
history.addHistory(boost::make_shared<AlgorithmHistory>(
API::AlgorithmHistory(pAlg.get())));
pAlg.reset(nullptr);
MatrixWorkspace_sptr createSimpleWorkspace(const std::vector<double> xData,
const std::vector<double> yData,
const std::vector<double> eData,
const int nSpec = 1) {
Workspace2D_sptr outputWorkspace = create<DataObjects::Workspace2D>(
nSpec, Mantid::HistogramData::Histogram(
Mantid::HistogramData::Points(xData.size())));
for (int i = 0; i < nSpec; ++i) {
outputWorkspace->mutableY(i) = yData;
outputWorkspace->mutableE(i) = eData;
outputWorkspace->mutableX(i) = xData;
}
return outputWorkspace;
}
};
#endif /* MANTID_ALGORITHMS_GENERATEPYTHONSCRIPTTEST_H_ */