def testExecute(self):
        """
        """
        self.run()
        plugin = self.getPlugin()
        ################################################################################
        # Compare XSDataResults
        ################################################################################
        strExpectedOutput = self.readAndParseFile(
            self.getReferenceDataOutputFile())
        EDVerbose.DEBUG("Checking obtained result...")

        xsDataResultObtained = plugin.getDataOutput()
        EDAssert.strAlmostEqual(self.xsDataResultReference.marshal(),
                                xsDataResultObtained.marshal(),
                                "XSDataResult output are the same")
        ################################################################################
        # Compare image Files
        ################################################################################
        outputData = Image.open(self.outputFile)
        referenceData = Image.open(
            os.path.join(self.getTestsDataImagesHome(),
                         os.path.basename(self.outputFile)))
        delta = ImageChops.difference(outputData, referenceData)
        deltaColor = delta.getextrema()
        i = 0
        for color in deltaColor:
            EDAssert.lowerThan(
                color[1], 12, "Maximum tone variation is %s for channel %s" %
                (color[1], "RGBA"[i]))
            i += 1
    def testExecute(self):
        """
        """
        self.run()

        # Checks that there are no error messages

        plugin = self.getPlugin()
        plugin.killAllWorkers()
        if EDVerbose.isVerboseDebug():
            plugin.cleanDispMat(plugin.getWorkingDirectory())
        else:
            plugin.cleanDispMat()

# Checking obtained results
        xsDataResultSPD = plugin.getDataOutput()
        outputData = EDF(
            xsDataResultSPD.getCakedFile().getPath().getValue()).GetData(0)
        referenceData = EDF(
            os.path.join(self.getTestsDataImagesHome(),
                         self.refOutput)).GetData(0)
        relError = 100 * (abs(outputData - referenceData).max() -
                          referenceData.min()) / (referenceData.max() -
                                                  referenceData.min())
        absError = abs(outputData - referenceData).max()
        if relError > 5:
            EDAssert.lowerThan(
                relError, 5,
                "Maximum relative error = %.2f%%, Maximum Absolute Error %.2f"
                % (relError, absError))
        else:
            EDAssert.lowerThan(
                absError, 5,
                "Maximum relative error = %.2f%%, Maximum Absolute Error %.2f "
                % (relError, absError))
    def testExecute(self):
        self.run()

        xsDataResultBest = self.getPlugin().getDataOutput()
        fDistance = xsDataResultBest.getCollectionPlan()[0].getStrategySummary(
        ).getDistance().getValue()
        EDAssert.lowerThan(fDistance, 500.0,
                           "Distance shorter than max distance 500 mm")
 def testExecute(self):
     """
     """
     self.run()
     xsdOut = self.getPlugin().getDataOutput()
     EDAssert.strAlmostEqual(XSDataResultDatcmp.parseFile(self.getReferenceDataOutputFile()).marshal(),
                             xsdOut.marshal() , "XSData are almost the same", _fAbsError=0.1)
     EDAssert.lowerThan(xsdOut.chi.value, 1.0, "Chi2 is lower than 1")
     EDAssert.equal(xsdOut.fidelity.value, 1.0, "Fidelity is 1")