def testExecute(self): """ """ self.run() plugin = self.getPlugin() ################################################################################ # Compare XSDataResults ################################################################################ strExpectedOutput = self.readAndParseFile (self.getReferenceDataOutputFile()) # strObtainedOutput = self.readAndParseFile (self.m_edObtainedOutputDataFile) EDVerbose.DEBUG("Checking obtained result...") xsDataResultReference = XSDataResultBioSaxsAsciiExportv1_0.parseString(strExpectedOutput) xsDataResultObtained = plugin.getDataOutput() EDAssert.strAlmostEqual(xsDataResultReference.marshal(), xsDataResultObtained.marshal(), "XSDataResult output are the same", _strExcluded="bioSaxs") ################################################################################ # Compare spectrum ascii Files ################################################################################ outputData = open(xsDataResultObtained.getIntegratedCurve().getPath().value, "rb").read() referenceData = open(os.path.join(self.getTestsDataImagesHome(), "bioSaxsAsciiExportv1_1.dat"), "rb").read() EDAssert.strAlmostEqual(referenceData, outputData, _strComment="3-column ascii spectra files are the same", _fRelError=0.1, _fAbsError=0.1, _strExcluded="bioSaxs")
def testExecute(self): """ """ self.run() plugin = self.getPlugin() strExpectedOutput = self.readAndParseFile( self.getReferenceDataOutputFile()) # strObtainedOutput = self.readAndParseFile (self.m_edObtainedOutputDataFile) EDVerbose.DEBUG("Checking obtained result...") xsDataResultReference = XSDataResultSaxsMacv1_0.parseString( strExpectedOutput) xsDataResultObtained = plugin.getDataOutput() EDAssert.strAlmostEqual(xsDataResultReference.marshal(), xsDataResultObtained.marshal(), "XSDataResult output are the same") outputData = openimage( xsDataResultObtained.getOutputImage().getPath().getValue()).data referenceData = openimage( os.path.join(self.getTestsDataImagesHome(), "moke.edf")).data EDAssert.arraySimilar(outputData, referenceData, _fAbsMaxDelta=0.8, _fScaledMaxDelta=0.05, _fRfactor=5, _fRelMaxDelta=1.5, _strComment="Images are the same")
def testExecute(self): """ """ self.run() plugin = self.getPlugin() EDVerbose.DEBUG("Checking obtained result...") strExpectedOutput = self.readAndParseFile (self.getReferenceDataOutputFile()) xsDataResultReference = XSDataResultSPDCake.parseString(strExpectedOutput) xsDataResultObtained = plugin.getDataOutput() # EDVerbose.DEBUG("Reference XML:%s" + xsDataResultReference.marshal()) # EDVerbose.DEBUG("Obtained XML:%s" + xsDataResultObtained.marshal()) EDAssert.strAlmostEqual(xsDataResultReference.marshal(), xsDataResultObtained.marshal(), "XSDataResult output are the same") # Checking obtained results xsDataResultsSPDCake = plugin.getDataOutput() strPathToChiOutput = xsDataResultsSPDCake.getCakedFile().getPath().getValue() strPathToChiReference = os.path.join(self.getTestsDataImagesHome(), "EDPluginSPDCakev1_0.chi") Xref, Yref = readChiPlot(strPathToChiReference) Xobt, Yobt = readChiPlot(strPathToChiOutput) EDVerbose.DEBUG("Output File: %s, Reference file: %s" % (strPathToChiOutput, strPathToChiReference)) bigX = Xref + Xobt bigX.sort() bigYobt = numpy.interp(bigX, Xobt, Yobt) bigYref = numpy.interp(bigX, Xref, Yref) EDVerbose.DEBUG("ref.shape= %s, obt.shape=%s" % (bigYobt.shape, bigYref.shape)) EDVerbose.DEBUG("Type of object ref= %s, obt=%s" % (bigYobt.__class__, bigYref.__class__)) EDAssert.arraySimilar(bigYobt, bigYref, _fAbsMaxDelta=0.1, _fScaledMaxDelta=0.1, _strComment="Comparing ChiPlot files")
def testExecute(self): """ """ self.run() plugin = self.getPlugin() strExpectedOutput = self.readAndParseFile( self.getReferenceDataOutputFile()) xsDataResultReference = XSDataResultSPDCake.parseString( strExpectedOutput) xsDataResultObtained = plugin.getDataOutput() # EDVerbose.DEBUG("Reference XML:%s" + xsDataResultReference.marshal()) # EDVerbose.DEBUG("Obtained XML:%s" + xsDataResultObtained.marshal()) EDAssert.strAlmostEqual(xsDataResultReference.marshal(), xsDataResultObtained.marshal(), "XSDataResult output are the same") # Checking obtained results xsDataResultsSPDCake = plugin.getDataOutput() strPathToChiOutput = xsDataResultsSPDCake.getCakedFile().getPath( ).getValue() strDataObtained = EDUtilsFile.readFile(strPathToChiOutput) strDataReference = EDUtilsFile.readFile( os.path.join(self.getTestsDataImagesHome(), "EDPluginSPDCakev1_1.cif")) EDAssert.strAlmostEqual(strDataReference, strDataObtained, "Comparing PowderCIF output", _fAbsError=2e-3)
def testExecute(self): """ """ self.run() plugin = self.getPlugin() ################################################################################ # Compare XSDataResults ################################################################################ strExpectedOutput = self.readAndParseFile (self.getReferenceDataOutputFile()) EDVerbose.DEBUG("Checking obtained result...") xsDataResultReference = XSDataResultBioSaxsProcessOneFilev1_0.parseString(strExpectedOutput) xsDataResultObtained = plugin.getDataOutput() EDAssert.strAlmostEqual(xsDataResultReference.marshal(), xsDataResultObtained.marshal(), "XSDataResult output are the same", _strExcluded="bioSaxs") ################################################################################ # Compare Ascii HEADER files ################################################################################ asciiObt = os.linesep.join([i.strip() for i in open(xsDataResultObtained.integratedCurve.path.value) if i.startswith("#") and "Raster" not in i]) asciiRef = os.linesep.join([i.strip() for i in open(os.path.join(self.getTestsDataImagesHome(), "bioSaxsProcessIntegrated1_2.dat")) if i.startswith("#") and "Raster" not in i]) EDAssert.strAlmostEqual(asciiObt, asciiRef, _strComment="ascii header files are the same", _fRelError=0.1, _strExcluded=os.environ["USER"]) dataObt = numpy.loadtxt(xsDataResultObtained.integratedCurve.path.value) dataRef = numpy.loadtxt(os.path.join(self.getTestsDataImagesHome(), "bioSaxsProcessIntegrated1_2.dat")) EDAssert.curveSimilar((dataObt[:, 0], dataObt[:, 1]), (dataRef[:, 0], dataRef[:, 1]), "data are the same", 0.6) EDAssert.curveSimilar((dataObt[:, 0], dataObt[:, 2]), (dataRef[:, 0], dataRef[:, 2]), "errors are the same", 0.6) EDVerbose.screen("Execution time for %s: %.3fs" % (plugin.getClassName(), plugin.getRunTime()))
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() # Checks the expected result strExpectedOutput = self.readAndParseFile (self.getReferenceDataOutputFile()) # strObtainedOutput = plugin.getDataOutput().marshal() # EDUtilsTest.readAndParseFile ( self.m_edObtainedOutputDataFile ) EDVerbose.DEBUG("Checking obtained result...") xsDataResultReference = XSDataResultDiffractionCT.parseString(strExpectedOutput) xsDataResultObtained = plugin.getDataOutput()# XSDataResultDiffractionCT.parseString(strObtainedOutput) EDAssert.equal(xsDataResultReference.marshal(), xsDataResultObtained.marshal()) ref = self.readAndParseFile(os.path.join(self.getTestsDataImagesHome(), "DCT2011March.chi")) obt = self.readAndParseFile(xsDataResultObtained.getIntegratedIntensities().getPath().getValue()) EDAssert.strAlmostEqual(ref, obt, "Chi files are the same", 0.001) # clean up SPD when finished EDFactoryPluginStatic.loadPlugin("EDPluginSPDCorrectv10").killAllWorkers()
def testExecute(self): """ """ self.run() plugin = self.getPlugin() ################################################################################ # Compare XSDataResults ################################################################################ strExpectedOutput = self.readAndParseFile (self.getReferenceDataOutputFile()) # strObtainedOutput = self.readAndParseFile (self.m_edObtainedOutputDataFile) EDVerbose.DEBUG("Checking obtained result...") xsDataResultReference = XSDataResultBioSaxsAzimutIntv1_0.parseString(strExpectedOutput) xsDataResultObtained = plugin.getDataOutput() EDAssert.strAlmostEqual(xsDataResultReference.marshal(), xsDataResultObtained.marshal(), "XSDataResult output are the same", _strExcluded="bioSaxs") ################################################################################ # Compare spectrum ascii Files ################################################################################ outputData = open(xsDataResultObtained.getIntegratedCurve().getPath().value, "rb").read().split(os.linesep) referenceData = EDUtilsFile.readFileAndParseVariables(os.path.join(self.getTestsDataImagesHome(), "bioSaxsIntegratedv1_3.dat"), EDUtilsPath.getDictOfPaths()).split(os.linesep) outputData = os.linesep.join([i for i in outputData if not i.startswith("# History")]) referenceData = os.linesep.join([i for i in referenceData if not i.startswith("# History")]) EDAssert.strAlmostEqual(referenceData, outputData, _strComment="3column ascii spectra files are the same", _fRelError=0.1, _fAbsError=0.1, _strExcluded="bioSaxs")
def testExecute(self): """ """ plugin = self.getPlugin() plugin.__class__.lastBuffer = XSDataFile( XSDataString( os.path.join(EDUtilsPath.EDNA_TESTIMAGES, "buffer_before.dat"))) plugin.__class__.lastSample = XSDataFile( XSDataString( os.path.join(EDUtilsPath.EDNA_TESTIMAGES, "bioSaxsAveraged.dat"))) self.run() plugin = self.getPlugin() xsdRef = XSDataResultBioSaxsSmartMergev1_0.parseString( self.readAndParseFile(self.getReferenceDataOutputFile())) xsdRef.autoRg = None xsdObt = plugin.getDataOutput() xsdObt.status = None #Executive summary is too complicated to test EDAssert.strAlmostEqual(xsdRef.marshal(), xsdObt.marshal(), "XML output structures are the same", _fAbsError=0.1) # ref = " ".join([" ".join(i.split()) for i in open(self.destFile)]) # obt = " ".join([" ".join(i.split()) for i in open(xsdObt.mergedCurve.path.value)]) # EDAssert.strAlmostEqual(ref, obt, "Files are the same", _fAbsError=0.1) print plugin.__class__.lastBuffer.path.value print plugin.__class__.lastSample.path.value
def testExecute(self): """ """ self.run() plugin = self.getPlugin() ################################################################################ # Compare XSDataResults ################################################################################ strExpectedOutput = self.readAndParseFile (self.getReferenceDataOutputFile()) EDVerbose.DEBUG("Checking obtained result...") xsDataResultReference = XSDataResultMatrixInvertFile.parseString(strExpectedOutput) xsDataResultObtained = plugin.getDataOutput() EDAssert.strAlmostEqual(xsDataResultReference.marshal(), xsDataResultObtained.marshal(), _strComment="XSDataResult output are the same") ################################################################################ # Check that outputData * inputData - Id = 0 ################################################################################ outputData = openimage(self.outputFile).data size = outputData.shape[0] inputData = openimage(self.inputFile).data EDAssert.arraySimilar(numpy.matrix(outputData) * numpy.matrix(inputData), numpy.identity(size), _fAbsMaxDelta=2e-4, _strComment="output x input = Id ") ################################################################################ # Compare image Files ################################################################################ referenceData = openimage(os.path.join(self.getTestsDataImagesHome(), os.path.basename(self.outputFile))).data EDAssert.arraySimilar(referenceData, outputData, _fAbsMaxDelta=1e-5, _strComment="images are the same")
def testExecute(self): """ """ plugin = self.getPlugin() plugin.__class__.dictHPLC = {} self.run() ################################################################################ # Compare XSDataResults ################################################################################ strExpectedOutput = self.readAndParseFile (self.getReferenceDataOutputFile()) EDVerbose.DEBUG("Checking obtained result...") xsDataResultReference = XSDataResultBioSaxsHPLCv1_0.parseString(strExpectedOutput) xsDataResultObtained = plugin.getDataOutput() EDAssert.strAlmostEqual(xsDataResultReference.marshal(), xsDataResultObtained.marshal(), "XSDataResult output are the same", _strExcluded="bioSaxs") ################################################################################ # Compare Ascii files ################################################################################ asciiObt = os.linesep.join([i.strip() for i in open(xsDataResultObtained.integratedCurve.path.value) if "Raster" not in i]) asciiRef = os.linesep.join([i.strip() for i in open(os.path.join(self.getTestsDataImagesHome(), "bioSaxsProcessIntegrated1_2.dat")) if "Raster" not in i]) EDAssert.strAlmostEqual(asciiRef, asciiObt, _strComment="3 column ascii files are the same", _fRelError=0.1, _strExcluded=os.environ["USER"]) EDVerbose.screen("Execution time for %s: %.3fs" % (plugin.getClassName(), plugin.getRunTime()))
def testParse_xds_file(self): xdsInpPath = os.path.join(self.getPluginTestsDataHome(), "XDS_xdscfgparser.INP") parserDict = xdscfgparser.parse_xds_file(xdsInpPath) # import pprint # pprint.pprint(parserDict) EDAssert.equal([1, 4], parserDict["BACKGROUND_RANGE="], "BACKGROUND_RANGE") EDAssert.equal(['/data/id29/inhouse/opid291/x_geo_corr.cbf'], parserDict["X-GEO_CORR="], "X-GEO_CORR") EDAssert.strAlmostEqual(305.04, parserDict['DETECTOR_DISTANCE='], 'DETECTOR_DISTANCE')
def testExecute(self): self.run() # Compare results strXMLExpected = self.readAndParseFile(self.getReferenceDataOutputFile()) xsDataObtained = self.getPlugin().getDataOutput() xsDataExpected = XSDataMOSFLMOutputIndexing.parseString(strXMLExpected) EDAssert.strAlmostEqual(xsDataExpected.marshal(), xsDataObtained.marshal(), \ "(MOSFLM indexing result comparison - expected versus obtained)")
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")
def testExecute(self): self.run() # Compare results strXMLExpected = self.readAndParseFile( self.getReferenceDataOutputFile()) xsDataObtained = self.getPlugin().getDataOutput() xsDataExpected = XSDataMOSFLMOutputIndexing.parseString(strXMLExpected) EDAssert.strAlmostEqual(xsDataExpected.marshal(), xsDataObtained.marshal(), \ "(MOSFLM indexing result comparison - expected versus obtained)", _fAbsError=1000.0)
def testExecute(self): """ """ self.run() plugin = self.getPlugin() ################################################################################ # Compare XSDataResults ################################################################################ strExpectedOutput = self.readAndParseFile( self.getReferenceDataOutputFile()) # strObtainedOutput = self.readAndParseFile (self.m_edObtainedOutputDataFile) EDVerbose.DEBUG("Checking obtained result...") xsDataResultReference = XSDataResultBioSaxsMetadatav1_0.parseString( strExpectedOutput) xsDataResultObtained = plugin.getDataOutput() EDAssert.strAlmostEqual(xsDataResultReference.marshal(), xsDataResultObtained.marshal(), "XSDataResult output are the same", _strExcluded="bioSaxs") ################################################################################ # Compare dictionary: ################################################################################ edfRef = EdfFile.EdfFile( xsDataResultObtained.getOutputImage().getPath().value) edfObt = EdfFile.EdfFile( os.path.join(self.getTestsDataImagesHome(), "bioSaxsMetadata.edf")) ######################################################################## # DEPRECATED PLUGIN => DEPREFCATED TESTS ######################################################################## # headerRef = edfRef.GetHeader(0) # headerObt = edfObt.GetHeader(0) # keysRef = headerRef.keys() # keysObt = headerObt.keys() # keysRef.sort() # keysObt.sort() # for key in ["HeaderID", "Image", 'EDF_BinarySize', "EDF_DataBlockID", "EDF_HeaderSize", "filename", "RasterOrientation", "Center_1", "Center_2", "Code", "Comments", "Concentration", # "VersionNumber",'time_of_day', ]: # if key in keysObt: keysObt.remove(key) # if key in keysRef: keysRef.remove(key) # EDAssert.equal(keysRef, keysObt, _strComment="Same keys in the header dictionary") # for key in keysRef: # EDAssert.strAlmostEqual(headerRef[key], headerObt[key], _strComment="header value %s are the same" % key, _strExcluded="bioSaxs") ################################################################################ # Compare images ################################################################################ outputData = edfObt.GetData(0) referenceData = edfRef.GetData(0) EDAssert.arraySimilar(outputData, referenceData, _fAbsMaxDelta=0.1, _fScaledMaxDelta=0.05, _strComment="Images-data are the same")
def testExecute(self): self.run() # Compare results strXMLExpected = self.readAndParseFile(self.__strReferenceDataOutputFile) xsDataObtained = self.getPlugin().getDataOutput() xsDataExpected = XSDataMOSFLMOutputIntegration.parseString(strXMLExpected) # Remove the bestFileHKL part which creates problem... xsDataObtained.setBestfileHKL(None) xsDataExpected.setBestfileHKL(None) EDAssert.strAlmostEqual(xsDataExpected.marshal(), xsDataObtained.marshal(), "(MOSFLM integration result comparison - expected versus obtained)", 0.1, 5000)
def testExecute(self): self.run() # Checks the expected result strObtainedOutput = self.readAndParseFile(self.m_edObtainedOutputDataFile) from XSDataMOSFLMv10 import XSDataMOSFLMOutputGeneratePrediction xsDataMOSFLMOutputGeneratePrediction = XSDataMOSFLMOutputGeneratePrediction.parseString(strObtainedOutput) strImagePath = xsDataMOSFLMOutputGeneratePrediction.getPredictionImage().getPath().getValue() bImageExists = os.path.exists(strImagePath) EDAssert.strAlmostEqual(True, bImageExists, "(Test if the image with prediction exists)")
def testExecute(self): """ """ self.run() plugin = self.getPlugin() strExpectedOutput = self.readAndParseFile (self.getReferenceDataOutputFile()) EDVerbose.DEBUG("Checking obtained result...") xsDataResultReference = XSDataResultShiftImage.parseString(strExpectedOutput) xsDataResultObtained = plugin.getDataOutput() EDAssert.strAlmostEqual(xsDataResultReference.marshal(), xsDataResultObtained.marshal(), _fRelError=0.0, _fAbsError=0.3, _strComment="XML out are the same")
def testExecute(self): self.run() plugin = self.getPlugin() output = plugin.dataOutput reference = XSDataResCutoffResult.parseFile( self.getReferenceDataOutputFile()) EDAssert.strAlmostEqual(output.marshal(), reference.marshal(), "output looks good")
def testExecute(self): """ """ self.run() xsdOut = self.getPlugin().getDataOutput() EDAssert.strAlmostEqual(XSDataResultDataver.parseString(self.readAndParseFile(self.getReferenceDataOutputFile())).marshal(), xsdOut.marshal() , "XSData are almost the same", _fAbsError=0.1) refData = open(os.path.join(self.getTestsDataImagesHome(), "merged.dat")).read().replace("\n", " ") obtData = open(self.destFile).read().replace(os.linesep, " ") EDAssert.strAlmostEqual(refData, obtData, "Checking obtained file", _fRelError=0.1)
def testExecute(self): self.run() plugin = self.getPlugin() output = plugin.dataOutput reference = XSDataResCutoffResult.parseFile(self.getReferenceDataOutputFile()) EDAssert.strAlmostEqual(output.marshal(), reference.marshal(), "output looks good")
def testExecute(self): """ """ self.run() xsdout = self.getPlugin().getDataOutput().marshal() print self.getReferenceDataOutputFile() xsdRef = XSDataResultStitchOffsetedImage.parseString(self.readAndParseFile(self.getReferenceDataOutputFile())).marshal() EDAssert.strAlmostEqual(xsdRef, xsdout, "Xsd are the same") # fabio.edfimage.edfimage(data=fabio.open(self.outFile).data - fabio.open(self.refFile).data).write("/tmp/delta.edf") EDAssert.arraySimilar(fabio.open(self.outFile).data, fabio.open(self.refFile).data, "Arrays are the same", _fAbsMaxDelta=1)
def testExecute(self): """ """ self.run() xsdOut = self.getPlugin().getDataOutput() EDAssert.strAlmostEqual(XSDataResultDatop.parseString(self.readAndParseFile(self.getReferenceDataOutputFile())).marshal(), xsdOut.marshal() , "XSData are almost the same", _fAbsError=0.1) refData = open(os.path.join(self.getTestsDataImagesHome(), "noise1+2.dat")).read() obtData = os.linesep.join([i for i in open(self.destFile) if i[0].isspace()]) EDAssert.strAlmostEqual(refData, obtData, "Checking obtained file")
def unitTestArraytoXsdNoNumpy(self): """ test the execution of detectNumberOfCPUs """ EDVerbose.DEBUG("EDTestCaseEDUtilsArray.unitTestArraytoXsdNoNumpy") EDAssert.strAlmostEqual(XSDataArray.parseString(self.strXSDataArrayNoNumpy).marshal(), EDUtilsArray.arrayToXSData(self.arrayNumpy, _bForceNoNumpy=True).marshal(), _strComment="XSDataArray from (numpyArray) are the same (forced No Numpy)") EDAssert.strAlmostEqual(XSDataArray.parseString(self.strXSDataArrayNoNumpy).marshal(), EDUtilsArray.arrayToXSData(self.arrayNoNumpy, _bForceNoNumpy=True).marshal(), _strComment="XSDataArray from (list of lists) are the same (forced No Numpy)")
def testExecute(self): """ """ self.run() plugin = self.getPlugin() xsdRef = XSDataResultBioSaxsSmartMergev1_0.parseString(self.readAndParseFile(self.getReferenceDataOutputFile())) xsdObt = plugin.getDataOutput() xsdObt.status = None #Executive summary is too complicated to test EDAssert.strAlmostEqual(xsdRef.marshal(), xsdObt.marshal(), "XML output structures are the same", _fAbsError=0.1) ref = " ".join([" ".join(i.split()) for i in open(self.destFile)]) obt = " ".join([" ".join(i.split()) for i in open(xsdObt.mergedCurve.path.value)]) EDAssert.strAlmostEqual(ref, obt, "Files are the same", _fAbsError=0.1)
def testExecute(self): """ """ self.run() plugin = self.getPlugin() strExpectedOutput = self.readAndParseFile (self.getReferenceDataOutputFile()) EDVerbose.DEBUG("Checking obtained result...") xsDataResultReference = XSDataResultMeasureOffset.parseString(strExpectedOutput) xsDataResultObtained = plugin.getDataOutput() EDAssert.strAlmostEqual(xsDataResultReference.marshal(), xsDataResultObtained.marshal(), _fRelError=0.0, _fAbsError=5, _strComment="XML out are the same")
def testExecute(self): self.run() plugin = self.getPlugin() plugin.synchronize() xmlobtain = plugin.getDataOutput().marshal() xmlexpected = XSDataResultID11.parseString(self.readAndParseFile(self.getReferenceDataOutputFile())).marshal() EDAssert.strAlmostEqual(xmlexpected, xmlobtain, "XSData comparaison") #EDPluginSPDCakev1_5.killAllWorkers() outputData = open(plugin.getDataOutput().getOutputFile()[0].getPath().getValue(), "rb").read() referenceData = open(os.path.join(self.getTestsDataImagesHome(), "moke.spr"), "rb").read() EDAssert.strAlmostEqual(referenceData, outputData, " file are the same")
def testExecute(self): """ """ self.run() plugin = self.getPlugin() ################################################################################ # Compare XSDataResults ################################################################################ strExpectedOutput = self.readAndParseFile (self.getReferenceDataOutputFile()) EDVerbose.DEBUG("Checking obtained result...") xsDataResultReference = XSDataResultWriteMatrix.parseString(strExpectedOutput) xsDataResultObtained = plugin.getDataOutput() EDAssert.strAlmostEqual(xsDataResultReference.marshal(), xsDataResultObtained.marshal(), "XSDataResult output are the same")
def unitTestArraytoXsd(self): """ test the execution of xsDataToArray static method """ EDVerbose.DEBUG("EDTestCaseEDUtilsArray.unitTestArraytoXsd") if numpy is not None: EDAssert.strAlmostEqual(XSDataArray.parseString(self.strXSDataArrayNumpy).marshal(), EDUtilsArray.arrayToXSData(self.arrayNumpy).marshal(), _strComment="XSDataArray from (numpyArray) are the same") else: EDAssert.strAlmostEqual(XSDataArray.parseString(self.strXSDataArrayNoNumpy).marshal(), EDUtilsArray.arrayToXSData(self.arrayNumpy).marshal(), _strComment="XSDataArray from (Non numpy Array) are the same")
def testExecute(self): """ """ self.run() # Checks that there are no error messages plugin = self.getPlugin() edStringExpectedOutput = self.readAndParseFile (self.getReferenceDataOutputFile()) edStringObtainedOutput = self.readAndParseFile (self.m_edObtainedOutputDataFile) EDVerbose.DEBUG("Checking obtained result...") xsDataResultReference = XSDataResultExecVideo.parseString(edStringExpectedOutput) xsDataResultObtained = XSDataResultExecVideo.parseString(edStringObtainedOutput) EDAssert.strAlmostEqual(xsDataResultReference.marshal(), xsDataResultObtained.marshal(), "XSDataResult output are the same") ################################################################################ # Identification of the video by its size ################################################################################ edStringExpectedOutput = self.readAndParseFile (self.getReferenceDataOutputFile()) xsDataResultReference = XSDataResultExecVideo.parseString(edStringExpectedOutput) outputFileName = xsDataResultReference.getVideoPath().getPath().getValue() outputVideoSize = os.stat(outputFileName)[6] referenceFileName = os.path.join(self.getPluginTestsDataHome(), os.path.basename(outputFileName)) referenceVideoSize = os.stat(referenceFileName)[6] EDAssert.equal(outputVideoSize, referenceVideoSize, "Identification of the video file by its size") ################################################################################ # Identification of the video by mplayer ################################################################################ outputVideoLog = subprocess.Popen("mplayer -identify -vo null -ao null -frames 0 2>/dev/null " + outputFileName, stdout=subprocess.PIPE, shell=True).stdout.readlines() outputVideoSummary = "" for oneLine in outputVideoLog: if oneLine.strip() != "": if not oneLine.split()[0].split("=")[0] in self.EXCLUDED: outputVideoSummary += oneLine referenceVideoLog = subprocess.Popen("mplayer -identify -vo null -ao null -frames 0 2>/dev/null " + referenceFileName, stdout=subprocess.PIPE, shell=True).stdout.readlines() referenceVideoSummary = "" for oneLine in referenceVideoLog: if oneLine.strip() != "": if not oneLine.split()[0].split("=")[0] in self.EXCLUDED: referenceVideoSummary += oneLine EDAssert.strAlmostEqual(outputVideoSummary, referenceVideoSummary, "Identification of the video by mplayer", _lstExcluded="edna")
def testExecute(self): self.run() # Checks the expected result strObtainedOutput = self.readAndParseFile( self.m_edObtainedOutputDataFile) from XSDataMOSFLMv10 import XSDataMOSFLMOutputGeneratePrediction xsDataMOSFLMOutputGeneratePrediction = XSDataMOSFLMOutputGeneratePrediction.parseString( strObtainedOutput) strImagePath = xsDataMOSFLMOutputGeneratePrediction.getPredictionImage( ).getPath().getValue() bImageExists = os.path.exists(strImagePath) EDAssert.strAlmostEqual(True, bImageExists, "(Test if the image with prediction exists)")
def testExecute(self): """ """ self.run() plugin = self.getPlugin() # Checking obtained results xsDataResult = plugin.getDataOutput() EDAssert.strAlmostEqual(XSDataResult1DPowderEDF.parseString(self.readAndParseFile(self.getReferenceDataOutputFile())).marshal(), xsDataResult.marshal(), _strComment="XML structures are the same") outputData = open(xsDataResult.getOutputFile().getPath().getValue(), "rb").read() referenceData = open(os.path.join(self.getTestsDataImagesHome(), self.refOutput), "rb").read() EDAssert.strAlmostEqual(referenceData, outputData, "ChiPlot files are the same")
def testExecute(self): """ """ self.run() plugin = self.getPlugin() ################################################################################ # Compare XSDataResults ################################################################################ strExpectedOutput = self.readAndParseFile(self.getReferenceDataOutputFile()) EDVerbose.DEBUG("Checking obtained result...") xsDataResultReference = XSDataResult.parseString(strExpectedOutput) xsDataResultObtained = plugin.getDataOutput() EDAssert.strAlmostEqual(xsDataResultReference.marshal(), xsDataResultObtained.marshal(), "XSDataResult output are the same", _strExcluded="bioSaxs")
def testExecute(self): self.run() # Compare results strXMLExpected = self.readAndParseFile( self.__strReferenceDataOutputFile) xsDataObtained = self.getPlugin().getDataOutput() xsDataExpected = XSDataMOSFLMOutputIntegration.parseString( strXMLExpected) # Remove the bestFileHKL part which creates problem... xsDataObtained.setBestfileHKL(None) xsDataExpected.setBestfileHKL(None) EDAssert.strAlmostEqual( xsDataExpected.marshal(), xsDataObtained.marshal(), "(MOSFLM integration result comparison - expected versus obtained)", 0.1, 5000)
def testExecute(self): """ """ self.run() xsdout = self.getPlugin().getDataOutput().marshal() print self.getReferenceDataOutputFile() xsdRef = XSDataResultStitchOffsetedImage.parseString( self.readAndParseFile( self.getReferenceDataOutputFile())).marshal() EDAssert.strAlmostEqual(xsdRef, xsdout, "Xsd are the same") # fabio.edfimage.edfimage(data=fabio.open(self.outFile).data - fabio.open(self.refFile).data).write("/tmp/delta.edf") EDAssert.arraySimilar(fabio.open(self.outFile).data, fabio.open(self.refFile).data, "Arrays are the same", _fAbsMaxDelta=1)
def testExecute(self): """ """ self.run() plugin = self.getPlugin() strExpectedOutput = self.readAndParseFile (self.getReferenceDataOutputFile()) EDVerbose.DEBUG("Checking obtained result...") xsDataResultReference = XSDataResultSaxsAddMetadatav1_0.parseString(strExpectedOutput) xsDataResultObtained = plugin.getDataOutput() EDAssert.strAlmostEqual(xsDataResultReference.marshal(), xsDataResultObtained.marshal(), "XSDataResult output are the same") outputData = str(open(self.testOutput, "rb").read()[:8196]) referenceData = str(open(self.refOutput, "rb").read()[:8196]) EDAssert.strAlmostEqual(outputData, referenceData, "Same headers")
def testExecute(self): self.run() plugin = self.getPlugin() strExpectedOutput = self.readAndParseFile (self.getReferenceDataOutputFile()) # strObtainedOutput = self.readAndParseFile (self.m_edObtainedOutputDataFile) EDVerbose.DEBUG("Checking obtained result...") xsDataResultReference = XSDataResultSaxsAddv1_0.parseString(strExpectedOutput) xsDataResultObtained = plugin.getDataOutput() EDAssert.strAlmostEqual(xsDataResultReference.marshal(), xsDataResultObtained.marshal(), "XSDataResult output are the same") outputData = openimage(xsDataResultObtained.getOutputImage().getPath().getValue()).data referenceData = openimage(os.path.join(self.getTestsDataImagesHome(), "bsa_014_07.msk")).data EDAssert.arraySimilar(outputData, referenceData , _fAbsMaxDelta=0.8, _fScaledMaxDelta=0.05, _fRfactor=5, _fRelMaxDelta=1.5 , _strComment="Images are the same")
def testExecute(self): """ """ self.run() plugin = self.getPlugin() ################################################################################ # Compare XSDataResults ################################################################################ strExpectedOutput = self.readAndParseFile (self.getReferenceDataOutputFile()) EDVerbose.DEBUG("Checking obtained result...") xsDataResultReference = XSDataResultBioSaxsNormalizev1_0.parseString(strExpectedOutput) xsDataResultObtained = plugin.getDataOutput() EDAssert.strAlmostEqual(xsDataResultReference.marshal(), xsDataResultObtained.marshal(), "XSDataResult output are the same", _strExcluded="bioSaxs") ################################################################################ # Compare dictionary ################################################################################ edfRef = openimage(xsDataResultObtained.normalizedImage.getPath().value) edfObt = openimage(os.path.join(self.getTestsDataImagesHome(), "bioSaxsCorrected.edf")) headerRef = edfRef.header headerObt = edfObt.header keysRef = headerRef.keys() keysObt = headerObt.keys() keysRef.sort() keysObt.sort() # EDAssert.equal(keysRef, keysObt, _strComment="Same keys in the header dict") for key in keysRef: if not (key.startswith("History") or key in [ "Compression", "DDummy", "Dummy", "EDF_HeaderSize", "HeaderID", "Image", "filename", "RasterOrientation", "time_of_day"]): EDAssert.strAlmostEqual(headerRef[key], headerObt[key], _strComment="header value %s are the same" % key, _strExcluded="bioSaxs") ################################################################################ # Compare images ################################################################################ outputData = edfRef.data referenceData = edfObt.data EDAssert.arraySimilar(numpy.maximum(outputData, 0), numpy.maximum(referenceData, 0) , _fAbsMaxDelta=0.1, _fScaledMaxDelta=0.05, _strComment="Images-data are the same") outputData = edfRef.next().data referenceData = edfObt.next().data EDAssert.arraySimilar(numpy.maximum(outputData, 0), numpy.maximum(referenceData, 0) , _fAbsMaxDelta=0.1, _fScaledMaxDelta=0.05, _strComment="Images-ESD are the same")
def testExecute(self): """ """ self.run() plugin = self.getPlugin() strExpectedOutput = self.readAndParseFile( self.getReferenceDataOutputFile()) # strObtainedOutput = self.readAndParseFile (self.m_edObtainedOutputDataFile) EDVerbose.DEBUG("Checking obtained result...") xsDataResultReference = XSDataResultPyFAI.parseString( strExpectedOutput) xsDataResultObtained = plugin.getDataOutput() EDAssert.strAlmostEqual(xsDataResultReference.marshal(), xsDataResultObtained.marshal(), "XSDataResult output are the same")
def testExecute(self): """ """ self.run() plugin = self.getPlugin() ################################################################################ # Compare XSDataResults ################################################################################ strExpectedOutput = self.readAndParseFile (self.getReferenceDataOutputFile()) EDVerbose.DEBUG("Checking obtained result...") xsDataResultReference = XSDataResult.parseString(strExpectedOutput) xsDataResultObtained = plugin.getDataOutput() EDAssert.strAlmostEqual(xsDataResultReference.marshal(), xsDataResultObtained.marshal(), "XSDataResult output are the same", _strExcluded="bioSaxs") EDAssert.isFile(xsDataResultObtained.gnom.gnomFile.path.value, "Gnom file exists")
def testExecute(self): """ """ self.run() plugin = self.getPlugin() ################################################################################ # Compare XSDataResults ################################################################################ strExpectedOutput = self.readAndParseFile (self.getReferenceDataOutputFile()) # strObtainedOutput = self.readAndParseFile (self.m_edObtainedOutputDataFile) EDVerbose.DEBUG("Checking obtained result...") xsDataResultReference = XSDataResultBioSaxsMetadatav1_0.parseString(strExpectedOutput) xsDataResultObtained = plugin.getDataOutput() EDAssert.strAlmostEqual(xsDataResultReference.marshal(), xsDataResultObtained.marshal(), "XSDataResult output are the same", _strExcluded="bioSaxs") ################################################################################ # Compare dictionary: ################################################################################ edfRef = EdfFile.EdfFile(xsDataResultObtained.getOutputImage().getPath().value) edfObt = EdfFile.EdfFile(os.path.join(self.getTestsDataImagesHome(), "bioSaxsMetadata.edf")) ######################################################################## # DEPRECATED PLUGIN => DEPREFCATED TESTS ######################################################################## # headerRef = edfRef.GetHeader(0) # headerObt = edfObt.GetHeader(0) # keysRef = headerRef.keys() # keysObt = headerObt.keys() # keysRef.sort() # keysObt.sort() # for key in ["HeaderID", "Image", 'EDF_BinarySize', "EDF_DataBlockID", "EDF_HeaderSize", "filename", "RasterOrientation", "Center_1", "Center_2", "Code", "Comments", "Concentration", # "VersionNumber",'time_of_day', ]: # if key in keysObt: keysObt.remove(key) # if key in keysRef: keysRef.remove(key) # EDAssert.equal(keysRef, keysObt, _strComment="Same keys in the header dictionary") # for key in keysRef: # EDAssert.strAlmostEqual(headerRef[key], headerObt[key], _strComment="header value %s are the same" % key, _strExcluded="bioSaxs") ################################################################################ # Compare images ################################################################################ outputData = edfObt.GetData(0) referenceData = edfRef.GetData(0) EDAssert.arraySimilar(outputData, referenceData , _fAbsMaxDelta=0.1, _fScaledMaxDelta=0.05, _strComment="Images-data are the same")
def testExecute(self): """ """ self.run() plugin = self.getPlugin() # # Checking obtained results xsDataResultsSPDCake = plugin.getDataOutput() pathToOutput = xsDataResultsSPDCake.getCakedFile().getPath().getValue() # edStringDataObtained = EDUtilsFile.readFile(pathToOutput) # edStringDataReference = EDUtilsFile.readFile(os.path.join(self.getPluginTestsDataHome(), \ # "EDPluginSPDCakev1_1.chi")) # EDAssert.strAlmostEqual(edStringDataReference, edStringDataObtained, "Comparing ChiPlot files") EDVerbose.DEBUG("Checking obtained result...") strExpectedOutput = self.readAndParseFile( self.getReferenceDataOutputFile()) xsDataResultReference = XSDataResultSPDCake.parseString( strExpectedOutput) xsDataResultObtained = plugin.getDataOutput() EDAssert.strAlmostEqual(xsDataResultReference.marshal(), xsDataResultObtained.marshal(), "XSDataResult output are the same") # Checking obtained results xsDataResultsSPDCake = plugin.getDataOutput() strPathToChiOutput = xsDataResultsSPDCake.getCakedFile().getPath( ).getValue() strPathToChiReference = os.path.join(self.getTestsDataImagesHome(), "EDPluginSPDCakev1_1.chi") Xref, Yref = readChiPlot(strPathToChiReference) Xobt, Yobt = readChiPlot(strPathToChiOutput) EDVerbose.DEBUG("Output File: %s, Reference file: %s" % (strPathToChiOutput, strPathToChiReference)) bigX = Xref + Xobt bigX.sort() bigYobt = numpy.interp(bigX, Xobt, Yobt) bigYref = numpy.interp(bigX, Xref, Yref) EDVerbose.DEBUG("ref.shape= %s, obt.shape=%s" % (bigYobt.shape, bigYref.shape)) EDVerbose.DEBUG("Type of object ref= %s, obt=%s" % (bigYobt.__class__, bigYref.__class__)) EDAssert.arraySimilar(bigYobt, bigYref, _fAbsMaxDelta=0.1, _fScaledMaxDelta=0.1, _strComment="Comparing ChiPlot files")
def testExecute(self): """ """ plugin = self.getPlugin() plugin.__class__.lastBuffer = XSDataFile(XSDataString(os.path.join(EDUtilsPath.EDNA_TESTIMAGES, "buffer_before.dat"))) plugin.__class__.lastSample = XSDataFile(XSDataString(os.path.join(EDUtilsPath.EDNA_TESTIMAGES, "bioSaxsAveraged.dat"))) self.run() plugin = self.getPlugin() xsdRef = XSDataResultBioSaxsSmartMergev1_0.parseString(self.readAndParseFile(self.getReferenceDataOutputFile())) xsdRef.autoRg = None xsdObt = plugin.getDataOutput() xsdObt.status = None #Executive summary is too complicated to test EDAssert.strAlmostEqual(xsdRef.marshal(), xsdObt.marshal(), "XML output structures are the same", _fAbsError=0.1) # ref = " ".join([" ".join(i.split()) for i in open(self.destFile)]) # obt = " ".join([" ".join(i.split()) for i in open(xsdObt.mergedCurve.path.value)]) # EDAssert.strAlmostEqual(ref, obt, "Files are the same", _fAbsError=0.1) print plugin.__class__.lastBuffer.path.value print plugin.__class__.lastSample.path.value
def testExecute(self): """ """ self.run() xsdOut = self.getPlugin().getDataOutput() EDAssert.strAlmostEqual(XSDataResultDatop.parseString( self.readAndParseFile( self.getReferenceDataOutputFile())).marshal(), xsdOut.marshal(), "XSData are almost the same", _fAbsError=0.1) refData = open( os.path.join(self.getTestsDataImagesHome(), "noise1+2.dat")).read() obtData = os.linesep.join( [i for i in open(self.destFile) if i[0].isspace()]) EDAssert.strAlmostEqual(refData, obtData, "Checking obtained file")
def testExecute(self): """ """ self.run() plugin = self.getPlugin() ################################################################################ # Compare XSDataResults ################################################################################ strExpectedOutput = self.readAndParseFile( self.getReferenceDataOutputFile()) # strObtainedOutput = self.readAndParseFile (self.m_edObtainedOutputDataFile) EDVerbose.DEBUG("Checking obtained result...") xsDataResultReference = XSDataResultBioSaxsAzimutIntv1_0.parseString( strExpectedOutput) xsDataResultObtained = plugin.getDataOutput() EDAssert.strAlmostEqual(xsDataResultReference.marshal(), xsDataResultObtained.marshal(), "XSDataResult output are the same", _strExcluded="bioSaxs") ################################################################################ # Compare spectrum ascii Files ################################################################################ outputData = open( xsDataResultObtained.getIntegratedCurve().getPath().value, "rb").read().split(os.linesep) referenceData = EDUtilsFile.readFileAndParseVariables( os.path.join(self.getTestsDataImagesHome(), "bioSaxsIntegratedv1_3.dat"), EDUtilsPath.getDictOfPaths()).split(os.linesep) outputData = os.linesep.join( [i for i in outputData if not i.startswith("# History")]) referenceData = os.linesep.join( [i for i in referenceData if not i.startswith("# History")]) EDAssert.strAlmostEqual( referenceData, outputData, _strComment="3column ascii spectra files are the same", _fRelError=0.1, _fAbsError=0.1, _strExcluded="bioSaxs")
def testExecute(self): """ """ self.run() plugin = self.getPlugin() ################################################################################ # Compare XSDataResults ################################################################################ strExpectedOutput = self.readAndParseFile( self.getReferenceDataOutputFile()) EDVerbose.DEBUG("Checking obtained result...") xsDataResultReference = XSDataResultMatrixInvertv2.parseString( strExpectedOutput) xsDataResultObtained = plugin.getDataOutput() EDAssert.strAlmostEqual(xsDataResultReference.marshal(), xsDataResultObtained.marshal(), _fStrSimilar=0.99, _strComment="XSDataResult output are the same")
def testExecute(self): """ """ self.run() plugin = self.getPlugin() strExpectedOutput = self.readAndParseFile( self.getReferenceDataOutputFile()) EDVerbose.DEBUG("Checking obtained result...") xsDataResultReference = XSDataResultSaxsAddMetadatav1_0.parseString( strExpectedOutput) xsDataResultObtained = plugin.getDataOutput() EDAssert.strAlmostEqual(xsDataResultReference.marshal(), xsDataResultObtained.marshal(), "XSDataResult output are the same") outputData = str(open(self.testOutput, "rb").read()[:8196]) referenceData = str(open(self.refOutput, "rb").read()[:8196]) EDAssert.strAlmostEqual(outputData, referenceData, "Same headers")
def testExecute(self): self.run() plugin = self.getPlugin() plugin.synchronize() xmlobtain = plugin.getDataOutput().marshal() xmlexpected = XSDataResultID11.parseString( self.readAndParseFile( self.getReferenceDataOutputFile())).marshal() EDAssert.strAlmostEqual(xmlexpected, xmlobtain, "XSData comparaison") #EDPluginSPDCakev1_5.killAllWorkers() outputData = open( plugin.getDataOutput().getOutputFile()[0].getPath().getValue(), "rb").read() referenceData = open( os.path.join(self.getTestsDataImagesHome(), "moke.spr"), "rb").read() EDAssert.strAlmostEqual(referenceData, outputData, " file are the same")
def testExecute(self): """ """ self.run() plugin = self.getPlugin() strExpectedOutput = self.readAndParseFile (self.getReferenceDataOutputFile()) # strObtainedOutput = self.readAndParseFile (self.m_edObtainedOutputDataFile) EDVerbose.DEBUG("Checking obtained result...") xsDataResultReference = XSDataResultSaxsAnglev1_0.parseString(strExpectedOutput) xsDataResultObtained = plugin.getDataOutput() EDAssert.strAlmostEqual(xsDataResultReference.marshal(), xsDataResultObtained.marshal(), "XSDataResult output are the same") outputData = openimage(xsDataResultObtained.getRegroupedDataFile().getPath().getValue()).data referenceData = openimage(os.path.join(self.getTestsDataImagesHome(), "Moke-2th10-tilt0-rot0.azim")).data EDAssert.arraySimilar(outputData, referenceData , _fAbsMaxDelta=0.4, _fScaledMaxDelta=0.5, _strComment="Images are the same")
def testExecute(self): """ """ self.run() plugin = self.getPlugin() ################################################################################ # Compare XSDataResults ################################################################################ strExpectedOutput = self.readAndParseFile (self.getReferenceDataOutputFile()) # strObtainedOutput = self.readAndParseFile (self.m_edObtainedOutputDataFile) EDVerbose.DEBUG("Checking obtained result...") xsDataResultReference = XSDataResultBioSaxsMetadatav1_0.parseString(strExpectedOutput) xsDataResultObtained = plugin.getDataOutput() EDAssert.strAlmostEqual(xsDataResultReference.marshal(), xsDataResultObtained.marshal(), "XSDataResult output are the same", _strExcluded="bioSaxs") ################################################################################ # Compare dictionary ################################################################################ edfRef = fabio.open(xsDataResultObtained.getOutputImage().getPath().value) edfObt = fabio.open(os.path.join(self.getTestsDataImagesHome(), "bioSaxsMetadata.edf")) keysRef = edfRef.header_keys keysObt = edfObt.header_keys keysRef.sort() keysObt.sort() for key in ["HeaderID", "Image", 'EDF_BinarySize', "EDF_DataBlockID", "EDF_HeaderSize", "filename", "RasterOrientation" ]: if key in keysObt: keysObt.remove(key) if key in keysRef: keysRef.remove(key) # print edfObt.header EDAssert.equal(keysRef, keysObt, _strComment="Same keys in the header dictionary") for key in keysRef: EDAssert.strAlmostEqual(edfRef.header[key], edfObt.header[key], _strComment="header value %s are the same" % key, _strExcluded="bioSaxs") ################################################################################ # Compare images ################################################################################ outputData = edfObt.data referenceData = edfRef.data EDAssert.arraySimilar(outputData, referenceData , _fAbsMaxDelta=0.1, _fScaledMaxDelta=0.05, _strComment="Images-data are the same")