Changeset 2f17d40 in sasview for test/sasdataloader


Ignore:
Timestamp:
May 16, 2017 8:16:20 AM (8 years ago)
Author:
GitHub <noreply@…>
Branches:
master, ESS_GUI, ESS_GUI_Docs, ESS_GUI_batch_fitting, ESS_GUI_bumps_abstraction, ESS_GUI_iss1116, ESS_GUI_iss879, ESS_GUI_iss959, ESS_GUI_opencl, ESS_GUI_ordering, ESS_GUI_sync_sascalc, costrafo411, magnetic_scatt, release-4.2.2, ticket-1009, ticket-1094-headless, ticket-1242-2d-resolution, ticket-1243, ticket-1249, ticket885, unittest-saveload
Children:
81b1f4d
Parents:
658dd57 (diff), 8e9536f (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
git-author:
Adam Washington <rprospero@…> (05/16/17 08:16:20)
git-committer:
GitHub <noreply@…> (05/16/17 08:16:20)
Message:

Merge pull request #76 from rprospero/master

Update SESANS reader to file format 1.0

Location:
test/sasdataloader
Files:
8 added
3 deleted
5 edited

Legend:

Unmodified
Added
Removed

  • test/sasdataloader/plugins/test_reader.py

    r959eb01 raaf5e49  
    88copyright 2008, University of Tennessee 
    99""" 
     10from __future__ import print_function 
     11 
    1012import os 
    1113import numpy as np 
    … …  
    5961    reader = Reader() 
    6062    output = reader.read("../test/test_data.test") 
    61     print output.x 
     63    print(output.x) 
    6264     
    6365     

  • test/sasdataloader/test/sequence_tests.py

    r959eb01 raaf5e49  
     1from __future__ import print_function 
     2 
    13from DataLoader.loader import Loader 
    24from DataLoader.readers.IgorReader import Reader as igor_reader 
    … …  
    810    out2 = Loader().load("MAR07232_rest.ASC") 
    911    if len(out2.detector)>1: 
    10         print "Consecutive reads using Loader failed" 
     12        print("Consecutive reads using Loader failed") 
    1113 
    1214def consecutive_reader(): 
    … …  
    1416    out2 = igor_reader().read("MAR07232_rest.ASC") 
    1517    if len(out2.detector)>1: 
    16         print "Consecutive reads using Readers failed" 
    17         print out1 
    18         print out2 
     18        print("Consecutive reads using Readers failed") 
     19        print(out1) 
     20        print(out2) 
    1921 
    2022def single_abs(): 
    … …  
    2931    single_igor() 
    3032    single_abs() 
    31     print "Test passed" 
     33    print("Test passed") 

  • test/sasdataloader/test/testplugings.py

    r959eb01 r17c9436  
    33""" 
    44 
     5import os 
    56import unittest 
    67from sas.sascalc.dataloader.loader import  Loader, Registry 
    … …  
    4142        # Create module 
    4243        import zipfile 
    43         z = zipfile.PyZipFile("plugins.zip", 'w') 
     44        f_name = "plugins.zip" 
     45        z = zipfile.PyZipFile(f_name, 'w') 
    4446        z.writepy("../plugins", "") 
    4547        z.close() 
     48        if os.path.isfile(f_name): 
     49            os.remove(f_name) 
    4650         
    4751    def testplugin_checksetup(self): 

  • test/sasdataloader/test/utest_abs_reader.py

    rdd11014 rc551bb3  
    22    Unit tests for data manipulations 
    33""" 
     4from __future__ import print_function 
    45 
    56import unittest 
    … …  
    89from sas.sascalc.dataloader.loader import Loader 
    910from sas.sascalc.dataloader.readers.IgorReader import Reader as IgorReader 
     11from sas.sascalc.dataloader.readers.abs_reader import Reader as AbsReader 
     12from sas.sascalc.dataloader.readers.hfir1d_reader import Reader as HFIRReader 
     13from sas.sascalc.dataloader.readers.danse_reader import Reader as DANSEReader 
     14from sas.sascalc.dataloader.readers.cansas_reader import Reader as CANSASReader 
     15 
    1016from sas.sascalc.dataloader.data_info import Data1D 
    1117  
    1218import os.path 
    1319 
     20 
    1421class abs_reader(unittest.TestCase): 
    1522     
    1623    def setUp(self): 
    17         from sas.sascalc.dataloader.readers.abs_reader import Reader 
    18         self.data = Reader().read("jan08002.ABS") 
    19          
     24        reader = AbsReader() 
     25        self.data = reader.read("jan08002.ABS") 
     26 
    2027    def test_abs_checkdata(self): 
    2128        """ 
    … …  
    6168    def test_checkdata2(self): 
    6269        self.assertEqual(self.data.dy[126], 1) 
    63          
     70 
     71    def test_generic_loader(self): 
     72        # the generic loader should work as well 
     73        data = Loader().load("jan08002.ABS") 
     74        self.assertEqual(data.meta_data['loader'], "IGOR 1D") 
     75 
     76 
    6477class hfir_reader(unittest.TestCase): 
    65      
     78 
    6679    def setUp(self): 
    67         self.data = Loader().load("S2-30dq.d1d") 
    68          
     80        reader = HFIRReader() 
     81        self.data = reader.read("S2-30dq.d1d") 
     82 
    6983    def test_hfir_checkdata(self): 
    7084        """ 
    … …  
    8397        self.assertEqual(self.data.dy[1], 0.000315) 
    8498        self.assertEqual(self.data.dx[1], 0.008249) 
    85          
     99 
     100    def test_generic_loader(self): 
     101        # the generic loader should work as well 
     102        data = Loader().load("S2-30dq.d1d") 
     103        self.assertEqual(data.meta_data['loader'], "HFIR 1D") 
     104 
    86105 
    87106class igor_reader(unittest.TestCase): 
    … …  
    137156     
    138157    def setUp(self): 
    139         self.data = Loader().load("MP_New.sans") 
     158        reader = DANSEReader() 
     159        self.data = reader.read("MP_New.sans") 
    140160 
    141161    def test_checkdata(self): 
    … …  
    171191        self.assertEqual(self.data.err_data[2], 2.06313) 
    172192 
     193    def test_generic_loader(self): 
     194        # the generic loader should work as well 
     195        data = Loader().load("MP_New.sans") 
     196        self.assertEqual(data.meta_data['loader'], "DANSE") 
     197 
    173198  
    174199class cansas_reader(unittest.TestCase): 
    175200     
    176201    def setUp(self): 
     202        reader = CANSASReader() 
     203        data = reader.read("cansas1d.xml") 
     204        self.data = data[0] 
     205 
     206    def test_generic_loader(self): 
     207        # the generic loader should work as well 
    177208        data = Loader().load("cansas1d.xml") 
    178         self.data = data[0] 
    179   
     209        self.assertEqual(data[0].meta_data['loader'], "CanSAS XML 1D") 
     210 
    180211    def test_cansas_checkdata(self): 
    181212        self.assertEqual(self.data.filename, "cansas1d.xml") 
    … …  
    190221            tests won't pass 
    191222        """ 
    192          
    193223        self.assertEqual(self.data.run[0], "1234") 
    194224        self.assertEqual(self.data.meta_data['loader'], "CanSAS XML 1D") 
    … …  
    264294            self.assertEqual(item.distance_unit,'mm') 
    265295 
    266             if item.size.x==50 \ 
    267                 and item.distance==11000.0 \ 
    268                 and item.name=='source' \ 
    269                 and item.type=='radius': 
     296            if item.size.x == 50 \ 
     297                and item.distance == 11000.0 \ 
     298                and item.name == 'source' \ 
     299                and item.type == 'radius': 
    270300                _found1 = True 
    271             elif item.size.x==1.0 \ 
    272                 and item.name=='sample' \ 
    273                 and item.type=='radius': 
     301            elif item.size.x == 1.0 \ 
     302                and item.name == 'sample' \ 
     303                and item.type == 'radius': 
    274304                _found2 = True 
    275305                 
    276         if _found1==False or _found2==False: 
     306        if _found1 == False or _found2 == False: 
    277307            raise RuntimeError, "Could not find all data %s %s" % (_found1, _found2)  
    278308             
    … …  
    309339            self.assertTrue(item.date in ['04-Sep-2007 18:35:02', 
    310340                                          '03-SEP-2006 11:42:47']) 
    311             print item.term 
     341            print(item.term) 
    312342            for t in item.term: 
    313                 if t['name']=="ABS:DSTAND" \ 
    314                     and t['unit']=='mm' \ 
    315                     and float(t['value'])==1.0: 
     343                if (t['name'] == "ABS:DSTAND" 
     344                    and t['unit'] == 'mm' 
     345                    and float(t['value']) == 1.0): 
    316346                    _found_term2 = True 
    317                 elif t['name']=="radialstep" \ 
    318                     and t['unit']=='mm' \ 
    319                     and float(t['value'])==10.0: 
     347                elif (t['name'] == "radialstep" 
     348                      and t['unit'] == 'mm' 
     349                      and float(t['value']) == 10.0): 
    320350                    _found_term1 = True 
    321351                     
    322         if _found_term1==False or _found_term2==False: 
    323             raise RuntimeError, "Could not find all process terms %s %s" % (_found_term1, _found_term2)  
    324              
    325          
    326          
     352        if _found_term1 == False or _found_term2 == False: 
     353            raise RuntimeError, "Could not find all process terms %s %s" % (_found_term1, _found_term2) 
    327354         
    328355    def test_writer(self): 
    329         from sas.sascalc.dataloader.readers.cansas_reader import Reader 
    330         r = Reader() 
    331         x = np.ones(5) 
    332         y = np.ones(5) 
    333         dy = np.ones(5) 
    334          
     356        r = CANSASReader() 
     357 
    335358        filename = "write_test.xml" 
    336359        r.write(filename, self.data) 
    … …  
    339362        self.assertEqual(self.data.filename, filename) 
    340363        self._checkdata() 
     364        if os.path.isfile(filename): 
     365            os.remove(filename) 
    341366         
    342367    def test_units(self): 
    … …  
    346371        """ 
    347372        filename = "cansas1d_units.xml" 
    348         data = Loader().load(filename) 
     373        data = CANSASReader().read(filename) 
    349374        self.data = data[0] 
    350375        self.assertEqual(self.data.filename, filename) 
    … …  
    357382        """ 
    358383        filename = "cansas1d_badunits.xml" 
    359         data = Loader().load(filename) 
     384        data = CANSASReader().read(filename) 
    360385        self.data = data[0] 
    361386        self.assertEqual(self.data.filename, filename) 
    … …  
    366391         
    367392        self.assertEqual(self.data.meta_data['loader'], "CanSAS XML 1D") 
    368         print self.data.errors 
     393        print(self.data.errors) 
    369394        self.assertEqual(len(self.data.errors), 1) 
    370          
    371          
     395 
    372396    def test_slits(self): 
    373397        """ 
    … …  
    375399        """ 
    376400        filename = "cansas1d_slit.xml" 
    377         data = Loader().load(filename) 
     401        data = CANSASReader().read(filename) 
    378402        self.data = data[0] 
    379403        self.assertEqual(self.data.filename, filename) 
    … …  
    397421        self.assertEqual(self.data.run_name['1234'], 'run name') 
    398422        self.assertEqual(self.data.title, "Test title") 
    399          
    400              
     423 
    401424 
    402425if __name__ == '__main__': 

  • test/sasdataloader/test/utest_cansas.py

    r7432acb r1fc50fb2  
    4646        self.schema_1_0 = "cansas1d_v1_0.xsd" 
    4747        self.schema_1_1 = "cansas1d_v1_1.xsd" 
    48  
     48        self.write_1_0_filename = "isis_1_0_write_test.xml" 
     49        self.write_1_1_filename = "isis_1_1_write_test.xml" 
    4950 
    5051    def get_number_of_entries(self, dictionary, name, i): 
    … …  
    5657        return name 
    5758 
    58  
    5959    def test_invalid_xml(self): 
    6060        """ 
    … …  
    6262        """ 
    6363        invalid = StringIO.StringIO('<a><c></b></a>') 
    64         reader = XMLreader(invalid) 
    65  
     64        XMLreader(invalid) 
    6665 
    6766    def test_xml_validate(self): 
    … …  
    8281        self.assertFalse(xmlschema.validate(invalid)) 
    8382 
    84  
    8583    def test_real_xml(self): 
    8684        reader = XMLreader(self.xml_valid, self.schema_1_0) 
    … …  
    9088        else: 
    9189            self.assertFalse(valid) 
    92  
    9390 
    9491    def _check_data(self, data): 
    … …  
    105102        self.assertTrue(data.meta_data["xmlpreprocess"] is not None) 
    106103 
    107  
    108104    def _check_data_1_1(self, data): 
    109105        spectrum = data.trans_spectrum[0] 
    110106        self.assertTrue(len(spectrum.wavelength) == 138) 
    111107 
    112  
    113108    def test_cansas_xml(self): 
    114         filename = "isis_1_1_write_test.xml" 
    115109        xmlreader = XMLreader(self.isis_1_1, self.schema_1_1) 
    116110        valid = xmlreader.validate_xml() 
    117111        xmlreader.set_processing_instructions() 
    118112        self.assertTrue(valid) 
    119         fo = open(self.isis_1_1) 
    120         str = fo.read() 
    121113        reader_generic = Loader() 
    122114        dataloader = reader_generic.load(self.isis_1_1) 
    … …  
    128120            self._check_data(cansasreader[i]) 
    129121            self._check_data_1_1(cansasreader[i]) 
    130             reader_generic.save(filename, dataloader[i], None) 
    131             fo = open(filename) 
    132             str = fo.read() 
     122            reader_generic.save(self.write_1_1_filename, dataloader[i], None) 
    133123            reader2 = Loader() 
    134             return_data = reader2.load(filename) 
     124            self.assertTrue(os.path.isfile(self.write_1_1_filename)) 
     125            return_data = reader2.load(self.write_1_1_filename) 
    135126            written_data = return_data[0] 
    136127            self._check_data(written_data) 
    137  
     128        if os.path.isfile(self.write_1_1_filename): 
     129            os.remove(self.write_1_1_filename) 
    138130 
    139131    def test_double_trans_spectra(self): 
    … …  
    144136        for item in data: 
    145137            self._check_data(item) 
    146  
    147138 
    148139    def test_entry_name_recurse(self): 
    … …  
    155146        self.assertTrue(len(d) == 6) 
    156147 
    157  
    158148    def test_load_cansas_file(self): 
    159         valid = [] 
    160149        reader1 = XMLreader(self.xml_valid, self.schema_1_0) 
    161150        self.assertTrue(reader1.validate_xml()) 
    … …  
    173162        self.assertFalse(reader7.validate_xml()) 
    174163 
    175  
    176164    def test_invalid_cansas(self): 
    177165        list = self.loader.load(self.cansas1d_notitle) 
    … …  
    184172        self.assertTrue(data.detector[0].distance == 4150) 
    185173 
    186  
    187174    def test_old_cansas_files(self): 
    188175        reader1 = XMLreader(self.cansas1d, self.schema_1_0) 
    189176        self.assertTrue(reader1.validate_xml()) 
    190177        file_loader = Loader() 
    191         file1 = file_loader.load(self.cansas1d) 
     178        file_loader.load(self.cansas1d) 
    192179        reader2 = XMLreader(self.cansas1d_units, self.schema_1_0) 
    193180        self.assertTrue(reader2.validate_xml()) 
    … …  
    197184        self.assertTrue(reader4.validate_xml()) 
    198185 
    199  
    200186    def test_save_cansas_v1_0(self): 
    201         filename = "isis_1_0_write_test.xml" 
    202187        xmlreader = XMLreader(self.isis_1_0, self.schema_1_0) 
    203188        valid = xmlreader.validate_xml() 
    … …  
    210195            self._check_data(dataloader[i]) 
    211196            self._check_data(cansasreader[i]) 
    212             reader_generic.save(filename, dataloader[i], None) 
     197            reader_generic.save(self.write_1_0_filename, dataloader[i], None) 
    213198            reader2 = Reader() 
    214             return_data = reader2.read(filename) 
     199            self.assertTrue(os.path.isfile(self.write_1_0_filename)) 
     200            return_data = reader2.read(self.write_1_0_filename) 
    215201            written_data = return_data[0] 
    216             xmlwrite = XMLreader(filename, self.schema_1_0) 
     202            XMLreader(self.write_1_0_filename, self.schema_1_0) 
    217203            valid = xmlreader.validate_xml() 
    218204            self.assertTrue(valid) 
    219205            self._check_data(written_data) 
    220  
     206        if os.path.isfile(self.write_1_0_filename): 
     207            os.remove(self.write_1_0_filename) 
    221208 
    222209    def test_processing_instructions(self): 
    … …  
    224211        valid = reader.validate_xml() 
    225212        if valid: 
    226             ## find the processing instructions and make into a dictionary 
     213            # find the processing instructions and make into a dictionary 
    227214            dic = self.get_processing_instructions(reader) 
    228215            self.assertTrue(dic == {'xml-stylesheet': \ 
    … …  
    232219            xmldoc = minidom.parseString(xml) 
    233220 
    234             ## take the processing instructions and put them back in 
     221            # take the processing instructions and put them back in 
    235222            xmldoc = self.set_processing_instructions(xmldoc, dic) 
    236             xml_output = xmldoc.toprettyxml() 
    237  
     223            xmldoc.toprettyxml() 
    238224 
    239225    def set_processing_instructions(self, minidom_object, dic): 
    … …  
    243229            minidom_object.insertBefore(pi, xmlroot) 
    244230        return minidom_object 
    245  
    246231 
    247232    def get_processing_instructions(self, xml_reader_object): 
Note: See TracChangeset for help on using the changeset viewer.