Re #22515 Initial Unit test commit -not finished

Framework/Algorithms/CMakeLists.txt

@@ -930,6 +930,7 @@ set ( TEST_FILES
 	SofQWTest.h
 	SolidAngleTest.h
 	SortEventsTest.h
+	SortXAxisTest.h
 	SparseInstrumentTest.h
 	SpatialGroupingTest.h
 	SpecularReflectionCalculateTheta2Test.h

Framework/Algorithms/src/SortXAxis.cpp

@@ -5,9 +5,13 @@
 #include "MantidKernel/ListValidator.h"
 #include "MantidKernel/System.h"
 #include "MantidKernel/make_unique.h"
-
-using namespace Mantid::Kernel;
+#include "MantidHistogramData/Histogram.h"
+using namespace Mantid;
 using namespace Mantid::API;
+using namespace Mantid::Kernel;
+using namespace Mantid::Algorithms;
+using namespace Mantid::DataObjects;
+using namespace Mantid::HistogramData;
 
 namespace Mantid {
 namespace Algorithms {

Framework/Algorithms/test/SortXAxisTest.h

 #ifndef MANTID_ALGORITHMS_SORTXAXISTEST_H_
 #define MANTID_ALGORITHMS_SORTXAXISTEST_H_
 
+#include "MantidAPI/AnalysisDataService.h"
 #include "MantidAPI/MatrixWorkspace.h"
 #include "MantidAlgorithms/SortXAxis.h"
-#include "MantidKernel/Workspace.h"
+#include "MantidDataObjects/Workspace2D.h"
+#include "MantidDataObjects/WorkspaceCreation.h"
+#include "MantidHistogramData/Histogram.h"
 #include <cxxtest/TestSuite.h>
 
+using namespace Mantid;
+using namespace Mantid::API;
+using namespace Mantid::Kernel;
+using namespace Mantid::Algorithms;
+using namespace Mantid::DataObjects;
+using namespace Mantid::HistogramData;
+
 namespace {
-MatrixWorkspace_sptr createWorkspace(const HistogramX &xData,
-                                     const HistogramY &yData,
-                                     const HistogramE &eData,
-                                     const int nSpec = 1) {
+MatrixWorkspace_sptr createWorkspaceE(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;
+}
+
+MatrixWorkspace_sptr createHistoWorkspaceE(const std::vector<double> xData,
+                                           const std::vector<double> yData,
+                                           const std::vector<double> eData,
+                                           const int nSpec = 1) {
 
-  Workspace2D_sptr outWS = boost::make_shared<Workspace2D>();
-  outWS->initialize(nSpec, xData.size(), yData.size());
+  Workspace2D_sptr outputWorkspace = create<DataObjects::Workspace2D>(
+      nSpec, Mantid::HistogramData::Histogram(
+                 Mantid::HistogramData::BinEdges(xData.size())));
   for (int i = 0; i < nSpec; ++i) {
-    outWS->mutableY(i) = yData;
-    outWS->mutableE(i) = eData;
-    outWS->mutableX(i) = xData;
+    outputWorkspace->mutableY(i) = yData;
+    outputWorkspace->mutableE(i) = eData;
+    outputWorkspace->mutableX(i) = xData;
   }
+  return outputWorkspace;
+}
+
+MatrixWorkspace_sptr createWorkspaceDx(const std::vector<double> xData,
+                                       const std::vector<double> yData,
+                                       const std::vector<double> dxData,
+                                       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->mutableX(i) = xData;
+    outputWorkspace->setPointStandardDeviations(i, dxData);
+  }
+  return outputWorkspace;
+}
+
+MatrixWorkspace_sptr createHistoWorkspaceDx(const std::vector<double> xData,
+                                            const std::vector<double> yData,
+                                            const std::vector<double> dxData,
+                                            const int nSpec = 1) {
+
+  Workspace2D_sptr outputWorkspace = create<DataObjects::Workspace2D>(
+      nSpec, Mantid::HistogramData::Histogram(
+                 Mantid::HistogramData::BinEdges(xData.size())));
+  for (int i = 0; i < nSpec; ++i) {
+    outputWorkspace->mutableY(i) = yData;
+    outputWorkspace->mutableX(i) = xData;
+    outputWorkspace->setPointStandardDeviations(i, dxData);
+  }
+  return outputWorkspace;
+}
+
+MatrixWorkspace_sptr createHistoWorkspace(const std::vector<double> xData,
+                                          const std::vector<double> yData,
+                                          const int nSpec = 1) {
+
+  Workspace2D_sptr outputWorkspace = create<DataObjects::Workspace2D>(
+      nSpec, Mantid::HistogramData::Histogram(
+                 Mantid::HistogramData::BinEdges(xData.size())));
+  for (int i = 0; i < nSpec; ++i) {
+    outputWorkspace->mutableY(i) = yData;
+    outputWorkspace->mutableX(i) = xData;
+  }
+  return outputWorkspace;
+}
+
+bool operator==(const std::vector<double> &lhs, const HistogramX &rhs) {
+  return lhs == rhs.rawData();
+}
 
-  outWS->getAxis(0)->unit() = UnitFactory::Instance().create("Wavelength");
+bool operator==(const std::vector<double> &lhs, const HistogramY &rhs) {
+  return lhs == rhs.rawData();
+}
 
-  return outWS;
+bool operator==(const std::vector<double> &lhs, const HistogramDx &rhs) {
+  return lhs == rhs.rawData();
 }
+} // namespace
 
 class SortXAxisTest : public CxxTest::TestSuite {
+public:
   // This pair of boilerplate methods prevent the suite being created statically
   // This means the constructor isn't called when running other tests
   static SortXAxisTest *createSuite() { return new SortXAxisTest(); }
@@ -36,30 +120,259 @@ class SortXAxisTest : public CxxTest::TestSuite {
     std::vector<double> yData = {1, 2, 3};
     std::vector<double> eData = {1, 2, 3};
 
-    MatrixWorkspace_sptr unsortedws = createWorkspace(xData, yData, eData);
+    MatrixWorkspace_sptr unsortedws = createWorkspaceE(xData, yData, eData);
 
     SortXAxis alg;
-    alg.setProperty("InputWorkspacd", "unsortedws");
-    alg.setProperty("OutputWorkspace", "sortedws");
-    alg.execute();
-    MatrixWorkspace_sptr sortedws =
+    TS_ASSERT_THROWS_NOTHING(alg.initialize())
+    TS_ASSERT(alg.isInitialized())
+    TS_ASSERT_THROWS_NOTHING(alg.setProperty("InputWorkspace", unsortedws));
+    TS_ASSERT_THROWS_NOTHING(alg.setProperty("OutputWorkspace", "sortedws"));
+    TS_ASSERT_THROWS_NOTHING(alg.execute());
+
+    MatrixWorkspace_sptr sortedws;
+    TS_ASSERT_THROWS_NOTHING(
+        sortedws = AnalysisDataService::Instance().retrieveWS<MatrixWorkspace>(
+            "sortedws"));
+    TS_ASSERT(sortedws);
+
+    TS_ASSERT_EQUALS(sortedws->x(0), xData);
+    TS_ASSERT_EQUALS(sortedws->y(0), yData);
+    TS_ASSERT_EQUALS(sortedws->e(0), eData);
+
+    TS_ASSERT_THROWS_NOTHING(
+        AnalysisDataService::Instance().remove("unsortedws"));
+    TS_ASSERT_THROWS_NOTHING(
+        AnalysisDataService::Instance().remove("sortedws"));
   }
 
-  void testXDescending() {}
+  void testXDescending() {
+    std::vector<double> xData = {3, 2, 1};
+    std::vector<double> sortedXData = {1, 2, 3};
+    std::vector<double> yData = {1, 2, 3};
+    std::vector<double> reverseYData = {3, 2, 1};
+    std::vector<double> eData = {1, 2, 3};
+    std::vector<double> reverseEData = {3, 2, 1};
 
-  void testOnMultipleSpectrum() {}
+    MatrixWorkspace_sptr unsortedws = createWorkspaceE(xData, yData, eData);
 
-  void testSortsXHistogramAscending() {}
+    SortXAxis alg;
+    TS_ASSERT_THROWS_NOTHING(alg.initialize())
+    TS_ASSERT(alg.isInitialized())
+    TS_ASSERT_THROWS_NOTHING(alg.setProperty("InputWorkspace", unsortedws));
+    TS_ASSERT_THROWS_NOTHING(alg.setProperty("OutputWorkspace", "sortedws"));
+    TS_ASSERT_THROWS_NOTHING(alg.execute());
 
-  void testSortsXHistogramDescending() {}
+    MatrixWorkspace_sptr sortedws;
+    TS_ASSERT_THROWS_NOTHING(
+        sortedws = AnalysisDataService::Instance().retrieveWS<MatrixWorkspace>(
+            "sortedws"));
+    TS_ASSERT(sortedws);
 
-  void testSortXWorksChild() {}
+    TS_ASSERT_EQUALS(sortedws->x(0), sortedXData);
+    TS_ASSERT_EQUALS(sortedws->y(0), reverseYData);
+    TS_ASSERT_EQUALS(sortedws->e(0), reverseEData);
 
-  void testDxMultipleSpectrum() {}
+    TS_ASSERT_THROWS_NOTHING(
+        AnalysisDataService::Instance().remove("unsortedws"));
+    TS_ASSERT_THROWS_NOTHING(
+        AnalysisDataService::Instance().remove("sortedws"));
+  }
 
-  void testDxHistogramAscending() {}
+  void testOnMultipleSpectrum() {
+    std::vector<double> xData = {3, 2, 1};
+    std::vector<double> sortedXData = {1, 2, 3};
+    std::vector<double> yData = {1, 2, 3};
+    std::vector<double> reverseYData = {3, 2, 1};
+    std::vector<double> eData = {1, 2, 3};
+    std::vector<double> reverseEData = {3, 2, 1};
 
-  void testSortDescending() {}
-};
+    MatrixWorkspace_sptr unsortedws = createWorkspaceE(xData, yData, eData, 2);
+
+    SortXAxis alg;
+    TS_ASSERT_THROWS_NOTHING(alg.initialize())
+    TS_ASSERT(alg.isInitialized())
+    TS_ASSERT_THROWS_NOTHING(alg.setProperty("InputWorkspace", unsortedws));
+    TS_ASSERT_THROWS_NOTHING(alg.setProperty("OutputWorkspace", "sortedws"));
+    TS_ASSERT_THROWS_NOTHING(alg.execute());
+
+    MatrixWorkspace_sptr sortedws;
+    TS_ASSERT_THROWS_NOTHING(
+        sortedws = AnalysisDataService::Instance().retrieveWS<MatrixWorkspace>(
+            "sortedws"));
+    TS_ASSERT(sortedws);
+
+    TS_ASSERT_EQUALS(sortedws->x(0), sortedXData);
+    TS_ASSERT_EQUALS(sortedws->y(0), reverseYData);
+    TS_ASSERT_EQUALS(sortedws->e(0), reverseEData);
+
+    TS_ASSERT_EQUALS(sortedws->x(1), sortedXData);
+    TS_ASSERT_EQUALS(sortedws->y(1), reverseYData);
+    TS_ASSERT_EQUALS(sortedws->e(1), reverseEData);
+
+    TS_ASSERT_THROWS_NOTHING(
+        AnalysisDataService::Instance().remove("unsortedws"));
+    TS_ASSERT_THROWS_NOTHING(
+        AnalysisDataService::Instance().remove("sortedws"));
+  }
+
+  void testSortsXHistogramAscending() {
+    std::vector<double> xData = {1, 2, 3, 4};
+    std::vector<double> yData = {1, 2, 3};
+    std::vector<double> eData = {1, 2, 3};
+
+    MatrixWorkspace_sptr unsortedws =
+        createHistoWorkspaceE(xData, yData, eData);
 
+    SortXAxis alg;
+    TS_ASSERT_THROWS_NOTHING(alg.initialize())
+    TS_ASSERT(alg.isInitialized())
+    TS_ASSERT_THROWS_NOTHING(alg.setProperty("InputWorkspace", unsortedws));
+    TS_ASSERT_THROWS_NOTHING(alg.setProperty("OutputWorkspace", "sortedws"));
+    TS_ASSERT_THROWS_NOTHING(alg.execute());
+
+    MatrixWorkspace_sptr sortedws;
+    TS_ASSERT_THROWS_NOTHING(
+        sortedws = AnalysisDataService::Instance().retrieveWS<MatrixWorkspace>(
+            "sortedws"));
+    TS_ASSERT(sortedws);
+
+    TS_ASSERT_EQUALS(sortedws->x(0), xData);
+    TS_ASSERT_EQUALS(sortedws->y(0), yData);
+    TS_ASSERT_EQUALS(sortedws->e(0), eData);
+
+    TS_ASSERT_THROWS_NOTHING(
+        AnalysisDataService::Instance().remove("unsortedws"));
+    TS_ASSERT_THROWS_NOTHING(
+        AnalysisDataService::Instance().remove("sortedws"));
+  }
+
+  void testSortsXHistogramDescending() {
+    std::vector<double> xData = {4, 3, 2, 1};
+    std::vector<double> sortedXData = {1, 2, 3, 4};
+    std::vector<double> yData = {1, 2, 3};
+    std::vector<double> reverseYData = {3, 2, 1};
+    std::vector<double> eData = {1, 2, 3};
+    std::vector<double> reverseEData = {3, 2, 1};
+
+    MatrixWorkspace_sptr unsortedws =
+        createHistoWorkspaceE(xData, yData, eData);
+
+    SortXAxis alg;
+    TS_ASSERT_THROWS_NOTHING(alg.initialize())
+    TS_ASSERT(alg.isInitialized())
+    TS_ASSERT_THROWS_NOTHING(alg.setProperty("InputWorkspace", unsortedws));
+    TS_ASSERT_THROWS_NOTHING(alg.setProperty("OutputWorkspace", "sortedws"));
+    TS_ASSERT_THROWS_NOTHING(alg.execute());
+
+    MatrixWorkspace_sptr sortedws;
+    TS_ASSERT_THROWS_NOTHING(
+        sortedws = AnalysisDataService::Instance().retrieveWS<MatrixWorkspace>(
+            "sortedws"));
+    TS_ASSERT(sortedws);
+
+    TS_ASSERT_EQUALS(sortedws->x(0), sortedXData);
+    TS_ASSERT_EQUALS(sortedws->y(0), reverseYData);
+    TS_ASSERT_EQUALS(sortedws->e(0), reverseEData);
+
+    TS_ASSERT_THROWS_NOTHING(
+        AnalysisDataService::Instance().remove("unsortedws"));
+    TS_ASSERT_THROWS_NOTHING(
+        AnalysisDataService::Instance().remove("sortedws"));
+  }
+
+  void testDxMultipleSpectrum() {
+    std::vector<double> xData = {3, 2, 1};
+    std::vector<double> yData = {1, 2, 3};
+    std::vector<double> dxData = {1, 2, 3};
+    std::vector<double> reverseDxData = {3, 2, 1};
+
+    MatrixWorkspace_sptr unsortedws =
+        createWorkspaceDx(xData, yData, dxData, 2);
+
+    SortXAxis alg;
+    TS_ASSERT_THROWS_NOTHING(alg.initialize())
+    TS_ASSERT(alg.isInitialized())
+    TS_ASSERT_THROWS_NOTHING(alg.setProperty("InputWorkspace", unsortedws));
+    TS_ASSERT_THROWS_NOTHING(alg.setProperty("OutputWorkspace", "sortedws"));
+    TS_ASSERT_THROWS_NOTHING(alg.execute());
+
+    MatrixWorkspace_sptr sortedws;
+    TS_ASSERT_THROWS_NOTHING(
+        sortedws = AnalysisDataService::Instance().retrieveWS<MatrixWorkspace>(
+            "sortedws"));
+    TS_ASSERT(sortedws);
+
+    TS_ASSERT_EQUALS(sortedws->dx(0), reverseDxData);
+    TS_ASSERT_EQUALS(sortedws->dx(1), reverseDxData);
+
+    TS_ASSERT_THROWS_NOTHING(
+        AnalysisDataService::Instance().remove("unsortedws"));
+    TS_ASSERT_THROWS_NOTHING(
+        AnalysisDataService::Instance().remove("sortedws"));
+  }
+
+  void testDxHistogramAscending() {
+    std::vector<double> xData = {1, 2, 3, 4};
+    std::vector<double> yData = {1, 2, 3};
+    std::vector<double> dxData = {1, 2, 3};
+    std::vector<double> reverseDxData = {3, 2, 1};
+
+    MatrixWorkspace_sptr unsortedws =
+        createHistoWorkspaceDx(xData, yData, dxData, 2);
+
+    SortXAxis alg;
+    TS_ASSERT_THROWS_NOTHING(alg.initialize())
+    TS_ASSERT(alg.isInitialized())
+    TS_ASSERT_THROWS_NOTHING(alg.setProperty("InputWorkspace", unsortedws));
+    TS_ASSERT_THROWS_NOTHING(alg.setProperty("OutputWorkspace", "sortedws"));
+    TS_ASSERT_THROWS_NOTHING(alg.execute());
+
+    MatrixWorkspace_sptr sortedws;
+    TS_ASSERT_THROWS_NOTHING(
+        sortedws = AnalysisDataService::Instance().retrieveWS<MatrixWorkspace>(
+            "sortedws"));
+    TS_ASSERT(sortedws);
+
+    HistogramDx wsDxData = sortedws->dx(0);
+
+    TS_ASSERT_EQUALS(reverseDxData, wsDxData);
+
+    TS_ASSERT_THROWS_NOTHING(
+        AnalysisDataService::Instance().remove("unsortedws"));
+    TS_ASSERT_THROWS_NOTHING(
+        AnalysisDataService::Instance().remove("sortedws"));
+  }
+
+  void testSortDescending() {
+    std::vector<double> xData = {1, 2, 3, 4};
+    std::vector<double> reverseXData = {4, 3, 2, 1};
+    std::vector<double> yData = {1, 2, 3};
+    std::vector<double> reverseYData = {3, 2, 1};
+
+    MatrixWorkspace_sptr unsortedws = createHistoWorkspace(xData, yData, 2);
+
+    SortXAxis alg;
+    TS_ASSERT_THROWS_NOTHING(alg.initialize())
+    TS_ASSERT(alg.isInitialized())
+    TS_ASSERT_THROWS_NOTHING(alg.setProperty("InputWorkspace", unsortedws));
+    TS_ASSERT_THROWS_NOTHING(alg.setProperty("OutputWorkspace", "sortedws"));
+    TS_ASSERT_THROWS_NOTHING(alg.setProperty("Ordering", "Descending"));
+    TS_ASSERT_THROWS_NOTHING(alg.execute());
+
+    MatrixWorkspace_sptr sortedws;
+    TS_ASSERT_THROWS_NOTHING(
+        sortedws = AnalysisDataService::Instance().retrieveWS<MatrixWorkspace>(
+            "sortedws"));
+    TS_ASSERT(sortedws);
+
+    TS_ASSERT_EQUALS(reverseXData, sortedws->x(0));
+    TS_ASSERT_EQUALS(reverseYData, sortedws->y(0));
+
+    TS_ASSERT_THROWS_NOTHING(
+        AnalysisDataService::Instance().remove("unsortedws"));
+    TS_ASSERT_THROWS_NOTHING(
+        AnalysisDataService::Instance().remove("sortedws"));
+  }
+}
+};
 #endif /*MANTID_ALGORITHMS_SORTXAXISTEST_H_*/

Framework/HistogramData/inc/MantidHistogramData/HistogramDx.h

@@ -50,7 +50,9 @@ public:
   HistogramDx(HistogramDx &&) = default;
   HistogramDx &operator=(const HistogramDx &) & = default;
   HistogramDx &operator=(HistogramDx &&) & = default;
-
+  bool operator==(const HistogramDx &rhs) const {
+    return this->rawData() == rhs.rawData();
+  }
   // These classes are friends, such that they can modify the length.
   friend class Histogram;
   friend class detail::VectorOf<PointVariances, HistogramDx>;

Framework/HistogramData/inc/MantidHistogramData/HistogramE.h

@@ -66,7 +66,9 @@ public:
   HistogramE(HistogramE &&) = default;
   HistogramE &operator=(const HistogramE &) & = default;
   HistogramE &operator=(HistogramE &&) & = default;
-
+  bool operator==(const HistogramE &rhs) const {
+    return this->rawData() == rhs.rawData();
+  }
   // These classes are friends, such that they can modify the length.
   friend class Histogram;
   friend class detail::VectorOf<CountStandardDeviations, HistogramE>;

Framework/HistogramData/inc/MantidHistogramData/HistogramX.h

@@ -62,7 +62,9 @@ public:
   HistogramX(HistogramX &&) = default;
   HistogramX &operator=(const HistogramX &) & = default;
   HistogramX &operator=(HistogramX &&) & = default;
-
+  bool operator==(const HistogramX &rhs) const {
+    return this->rawData() == rhs.rawData();
+  }
   // These classes are friends, such that they can modify the length.
   friend class Histogram;
   friend class detail::VectorOf<BinEdges, HistogramX>;

Framework/HistogramData/inc/MantidHistogramData/HistogramY.h

@@ -64,6 +64,9 @@ public:
   HistogramY(HistogramY &&) = default;
   HistogramY &operator=(const HistogramY &) & = default;
   HistogramY &operator=(HistogramY &&) & = default;
+  bool operator==(const HistogramY &rhs) const {
+    return this->rawData() == rhs.rawData();
+  }
   // Multiple inheritance causes ambiguous overload, bring operators into scope.
   using detail::Addable<HistogramY>::operator+;
   using detail::Addable<HistogramY>::operator+=;

Framework/PythonInterface/test/python/plugins/algorithms/CMakeLists.txt

@@ -84,7 +84,6 @@ set ( TEST_PY_FILES
   SetDetScaleTest.py
   SortByQVectorsTest.py
   SortDetectorsTest.py
-  SortXAxisTest.py
   StatisticsOfTableWorkspaceTest.py
   StringToPngTest.py
   SuggestTibCNCSTest.py

Framework/PythonInterface/test/python/plugins/algorithms/SortXAxisTest.py

-from __future__ import (absolute_import, division, print_function)
-
-import unittest
-from mantid.simpleapi import AlgorithmManager, CreateWorkspace, DeleteWorkspace, SortXAxis
-
-
-class SortXAxisTest(unittest.TestCase):
-
-
-    def test_x_ascending(self):
-        dataX = [1., 2., 3.] # In ascending order, so y and e will need to be reversed.
-        dataY = [1., 2., 3.]
-        dataE = [1., 2., 3.]
-        unsortedws = CreateWorkspace(DataX=dataX,DataY=dataY,DataE=dataE,UnitX='TOF',Distribution=True)
-        # Run the algorithm
-        sortedws = SortXAxis(InputWorkspace=unsortedws)
-        sortedX = sortedws.readX(0)
-        sortedY = sortedws.readY(0)
-        sortedE = sortedws.readE(0)
-        # Check the resulting data values. Sorting operation should have resulted in no changes
-        self.assertEqual(dataX, sortedX.tolist())
-        self.assertEqual(dataY, sortedY.tolist())
-        self.assertEqual(dataE, sortedE.tolist())
-        DeleteWorkspace(unsortedws)
-        DeleteWorkspace(sortedws)
-
-    def test_x_descending(self):
-        dataX = [3., 2., 1.] # In descending order, so y and e will need to be reversed.
-        dataY = [1., 2., 3.]
-        dataE = [1., 2., 3.]
-        unsortedws = CreateWorkspace(DataX=dataX,DataY=dataY,DataE=dataE,UnitX='TOF',Distribution=True)
-        # Run the algorithm
-        sortedws = SortXAxis(InputWorkspace=unsortedws)
-        sortedX = sortedws.readX(0)
-        sortedY = sortedws.readY(0)
-        sortedE = sortedws.readE(0)
-        # Check the resulting data values.
-        self.assertEqual(sorted(dataX), sortedX.tolist())
-        dataY.reverse()
-        dataE.reverse()
-        self.assertEqual(dataY, sortedY.tolist())
-        self.assertEqual(dataE, sortedE.tolist())
-        DeleteWorkspace(unsortedws)
-        DeleteWorkspace(sortedws)
-
-    def test_on_multiple_spectrum(self):
-        dataX = [3., 2., 1., 3., 2., 1.] # In descending order, so y and e will need to be reversed.
-        dataY = [1., 2., 3., 1., 2., 3.]
-        dataE = [1., 2., 3., 1., 2., 3.]
-        unsortedws = CreateWorkspace(DataX=dataX,DataY=dataY,DataE=dataE,UnitX='TOF',Distribution=True, NSpec=2)
-        dataY.reverse()
-        dataE.reverse()
-        # Run the algorithm
-        sortedws = SortXAxis(InputWorkspace=unsortedws)
-        # Check the resulting data values for 1st spectrum.
-        sortedX = sortedws.readX(0)
-        sortedY = sortedws.readY(0)
-        sortedE = sortedws.readE(0)
-        self.assertEqual(sorted(dataX[0:3]), sortedX.tolist())
-        self.assertEqual(dataY[0:3], sortedY.tolist())
-        self.assertEqual(dataE[0:3], sortedE.tolist())
-        # Check the resulting data values for 2nd spectrum.
-        sortedX = sortedws.readX(1)
-        sortedY = sortedws.readY(1)
-        sortedE = sortedws.readE(1)
-        self.assertEqual(sorted(dataX[3:]), sortedX.tolist())
-        self.assertEqual(dataY[3:], sortedY.tolist())
-        self.assertEqual(dataE[3:], sortedE.tolist())
-        DeleteWorkspace(unsortedws)
-        DeleteWorkspace(sortedws)
-
-    def test_sorts_x_histogram_ascending(self):
-        dataX = [1., 2., 3., 4.]
-        dataY = [1., 2., 3.]
-        dataE = [1., 2., 3.]
-        unsortedws = CreateWorkspace(DataX=dataX,DataY=dataY,DataE=dataE,UnitX='TOF',Distribution=False)
-        # Run the algorithm
-        sortedws = SortXAxis(InputWorkspace=unsortedws)
-        sortedX = sortedws.readX(0)
-        sortedY = sortedws.readY(0)
-        sortedE = sortedws.readE(0)
-        # Check the resulting data values. Sorting operation should have resulted in no changes
-        self.assertEqual(dataX, sortedX.tolist())
-        self.assertEqual(dataY, sortedY.tolist())
-        self.assertEqual(dataE, sortedE.tolist())
-
-        DeleteWorkspace(unsortedws)
-        DeleteWorkspace(sortedws)
-
-    def test_sorts_x_histogram_descending(self):
-        dataX = [4., 3., 2., 1.]
-        dataY = [1., 2., 3.]
-        dataE = [1., 2., 3.]
-        unsortedws = CreateWorkspace(DataX=dataX,DataY=dataY,DataE=dataE,UnitX='TOF',Distribution=False)
-        # Run the algorithm
-        sortedws = SortXAxis(InputWorkspace=unsortedws)
-        sortedX = sortedws.readX(0)
-        sortedY = sortedws.readY(0)
-        sortedE = sortedws.readE(0)
-        # Check the resulting data values. Sorting operation should have resulted in no changes
-        self.assertEqual(sorted(dataX), sortedX.tolist())
-        dataY.reverse()
-        dataE.reverse()
-        self.assertEqual(dataY, sortedY.tolist())
-        self.assertEqual(dataE, sortedE.tolist())
-
-        DeleteWorkspace(unsortedws)
-        DeleteWorkspace(sortedws)
-
-    def test_sort_x_works_child(self):
-        # Create unsorted workspace
-        parent = AlgorithmManager.createUnmanaged('Load')
-        create_ws_alg = parent.createChildAlgorithm("CreateWorkspace")
-        dataX = [4., 3., 2., 1.]
-        dataY = [1., 2., 3.]
-        dataE = [1., 2., 3.]
-        create_ws_alg.setProperty("DataX", dataX)
-        create_ws_alg.setProperty("DataY", dataY)
-        create_ws_alg.setProperty("DataE", dataE)
-        create_ws_alg.setProperty("UnitX",'TOF')
-        create_ws_alg.setProperty("Distribution", False)
-        create_ws_alg.execute()
-        # Run the algorithm
-        sort_alg = parent.createChildAlgorithm("SortXAxis")
-        sort_alg.setProperty("InputWorkspace", create_ws_alg.getProperty("OutputWorkspace").value)
-        sort_alg.execute()
-        # Check the resulting data values. Sorting operation should have resulted in no changes
-        sortedws = sort_alg.getProperty("OutputWorkspace").value
-        sortedX = sortedws.readX(0)
-        sortedY = sortedws.readY(0)
-        sortedE = sortedws.readE(0)
-        self.assertEqual(sorted(dataX), sortedX.tolist())
-        dataY.reverse()
-        dataE.reverse()
-        self.assertEqual(dataY, sortedY.tolist())
-        self.assertEqual(dataE, sortedE.tolist())
-
-    def test_dx_multiple_spectrum(self):
-        dataX = [3, 2, 1, 3, 2, 1]  # In descending order, so y and e will need to be reversed.
-        dataY = [1, 2, 3, 1, 2, 3]
-        dx = [1, 2, 3, 1, 2, 3]
-        unsortedws = CreateWorkspace(DataX=dataX, DataY=dataY, Dx=dx, UnitX='TOF', Distribution=True, NSpec=2)
-        dx.reverse()
-        # Run the algorithm
-        sortedws = SortXAxis(InputWorkspace=unsortedws)
-        # Check the resulting data values for 1st spectrum.
-        sortedDx = sortedws.readDx(0)
-        self.assertEqual(dx[0:3], sortedDx.tolist())
-        # Check the resulting data values for 2nd spectrum.
-        sortedDx = sortedws.readDx(1)
-        self.assertEqual(dx[3:], sortedDx.tolist())
-        DeleteWorkspace(unsortedws)
-        DeleteWorkspace(sortedws)
-
-    def test_dx_histogram_ascending(self):
-        dataX = [1., 2., 3., 4.]
-        dataY = [1., 2., 3.]
-        dx = [1., 2., 3.]
-        unsortedws = CreateWorkspace(DataX=dataX, DataY=dataY, Dx=dx, UnitX='TOF', Distribution=False)
-        # Run the algorithm
-        sortedws = SortXAxis(InputWorkspace=unsortedws)
-        sortedDx = sortedws.readDx(0)
-        # Check the resulting data values. Sorting operation should have resulted in no changes
-        self.assertEqual(dx, sortedDx.tolist())
-        DeleteWorkspace(unsortedws)
-        DeleteWorkspace(sortedws)
-
-    def test_sort_descending(self):
-        dataX = [1., 2., 3., 4.]
-        dataY = [1., 2., 3.]
-        unsortedws = CreateWorkspace(DataX=dataX, DataY=dataY, UnitX='TOF', Distribution=False)
-        # Run the algorithm
-        sortedws = SortXAxis(InputWorkspace=unsortedws, Ordering="Descending")
-        sortedX = sortedws.readX(0)
-        sortedY = sortedws.readY(0)
-        # Check the resulting data values. Sorting operation should have resulted in no changes
-        self.assertEqual([4., 3., 2., 1.], sortedX.tolist())
-        self.assertEqual([3., 2., 1.], sortedY.tolist())
-        DeleteWorkspace(unsortedws)
-        DeleteWorkspace(sortedws)
-
-if __name__ == '__main__':
-    unittest.main()