Changeset 3a473ef in sasview for test/sasdataloader


Ignore:
Timestamp:
Aug 31, 2018 7:13:23 AM (6 years ago)
Author:
Piotr Rozyczko <rozyczko@…>
Branches:
ESS_GUI, ESS_GUI_batch_fitting, ESS_GUI_bumps_abstraction, ESS_GUI_iss1116, ESS_GUI_iss879, ESS_GUI_opencl, ESS_GUI_ordering, ESS_GUI_sync_sascalc
Children:
c1cfa80
Parents:
aa1db44
Message:

Manual update of test/ directory with changes on master - SASVIEW-996

Location:
test/sasdataloader/test
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • test/sasdataloader/test/utest_abs_reader.py

    r574adc7 r3a473ef  
    1616 
    1717 
     18def find(filename): 
     19    return os.path.join(os.path.dirname(__file__), filename) 
     20 
     21 
    1822class abs_reader(unittest.TestCase): 
    1923 
    2024    def setUp(self): 
    2125        reader = AbsReader() 
    22         data = reader.read("jan08002.ABS") 
    23         self.data= data[0] 
     26        self.data_list = reader.read(find("jan08002.ABS")) 
     27        self.data = self.data_list[0] 
    2428 
    2529    def test_abs_checkdata(self): 
    … …  
    3135            tests won't pass 
    3236        """ 
    33         self.assertEqual(self.data.filename, "jan08002.ABS") 
     37        self.assertEqual(os.path.basename(self.data.filename), "jan08002.ABS") 
    3438        self.assertEqual(self.data.meta_data['loader'], "IGOR 1D") 
    3539 
    … …  
    4953 
    5054        self.assertEqual(self.data.y_unit, 'cm^{-1}') 
    51         self.assertEqual(self.data.x[0], 0.002618) 
    52         self.assertEqual(self.data.x[1], 0.007854) 
    53         self.assertEqual(self.data.x[2], 0.01309) 
     55        self.assertEqual(self.data.x[0], 0.008082) 
     56        self.assertEqual(self.data.x[1], 0.0275) 
     57        self.assertEqual(self.data.x[2], 0.02762) 
    5458        self.assertEqual(self.data.x[126], 0.5828) 
    5559 
    … …  
    6973    def test_generic_loader(self): 
    7074        # the generic loader should work as well 
    71         data = Loader().load("jan08002.ABS") 
     75        data = Loader().load(find("jan08002.ABS")) 
    7276        self.assertEqual(data[0].meta_data['loader'], "IGOR 1D") 
     77 
     78    def test_usans_negative_dxl(self): 
     79        data_abs = Loader().load(find("sam14_cor.ABS")) 
     80        data_cor = Loader().load(find("sam14_cor.cor")) 
     81        for i in range(0, len(data_abs) - 1): 
     82            self.assertEquals(data_abs.x[i], data_cor.x[i]) 
     83            self.assertEquals(data_abs.y[i], data_cor.y[i]) 
     84            self.assertEquals(data_abs.dxl[i], data_cor.dxl[i]) 
     85            self.assertEquals(data_abs.dxw[i], data_cor.dxw[i]) 
     86            self.assertTrue(data_abs.dxl > 0) 
     87 
    7388 
    7489class DanseReaderTests(unittest.TestCase): 
    … …  
    7691    def setUp(self): 
    7792        reader = DANSEReader() 
    78         data = reader.read("MP_New.sans") 
    79         self.data = data[0] 
     93        self.data_list = reader.read(find("MP_New.sans")) 
     94        self.data = self.data_list[0] 
    8095 
    8196    def test_checkdata(self): 
    … …  
    87102            tests won't pass 
    88103        """ 
    89         self.assertEqual(self.data.filename, "MP_New.sans") 
     104        self.assertEqual(len(self.data_list), 1) 
     105        self.assertEqual(os.path.basename(self.data.filename), "MP_New.sans") 
    90106        self.assertEqual(self.data.meta_data['loader'], "DANSE") 
    91107 
    … …  
    113129    def test_generic_loader(self): 
    114130        # the generic loader should work as well 
    115         data = Loader().load("MP_New.sans") 
     131        data = Loader().load(find("MP_New.sans")) 
     132        self.assertEqual(len(data), 1) 
    116133        self.assertEqual(data[0].meta_data['loader'], "DANSE") 
    117134 
    … …  
    121138    def setUp(self): 
    122139        reader = CANSASReader() 
    123         data = reader.read("cansas1d.xml") 
    124         self.data = data[0] 
     140        self.data_list = reader.read(find("cansas1d.xml")) 
     141        self.data = self.data_list[0] 
    125142 
    126143    def test_generic_loader(self): 
    127144        # the generic loader should work as well 
    128         data = Loader().load("cansas1d.xml") 
     145        data = Loader().load(find("cansas1d.xml")) 
     146        self.assertEqual(len(data), 1) 
    129147        self.assertEqual(data[0].meta_data['loader'], "CanSAS XML 1D") 
    130148 
    131149    def test_cansas_checkdata(self): 
    132         self.assertEqual(self.data.filename, "cansas1d.xml") 
     150        self.assertEqual(os.path.basename(self.data.filename), "cansas1d.xml") 
    133151        self._checkdata() 
    134152 
    … …  
    141159            tests won't pass 
    142160        """ 
     161        self.assertEqual(len(self.data_list), 1) 
    143162        self.assertEqual(self.data.run[0], "1234") 
    144163        self.assertEqual(self.data.meta_data['loader'], "CanSAS XML 1D") 
    … …  
    278297 
    279298        filename = "write_test.xml" 
    280         r.write(filename, self.data) 
    281         data = Loader().load(filename) 
     299        r.write(find(filename), self.data) 
     300        data = Loader().load(find(filename)) 
    282301        self.data = data[0] 
     302        self.assertEqual(len(data), 1) 
    283303        self.assertEqual(self.data.filename, filename) 
    284304        self._checkdata() 
    … …  
    292312        """ 
    293313        filename = "cansas1d_units.xml" 
    294         data = CANSASReader().read(filename) 
     314        data = CANSASReader().read(find(filename)) 
    295315        self.data = data[0] 
     316        self.assertEqual(len(data), 1) 
    296317        self.assertEqual(self.data.filename, filename) 
    297318        self._checkdata() 
    … …  
    303324        """ 
    304325        filename = "cansas1d_badunits.xml" 
    305         data = CANSASReader().read(filename) 
     326        data = CANSASReader().read(find(filename)) 
    306327        self.data = data[0] 
     328        self.assertEqual(len(data), 1) 
    307329        self.assertEqual(self.data.filename, filename) 
    308330        # The followed should not have been loaded 
    … …  
    319341        """ 
    320342        filename = "cansas1d_slit.xml" 
    321         data = CANSASReader().read(filename) 
     343        data = CANSASReader().read(find(filename)) 
    322344        self.data = data[0] 
     345        self.assertEqual(len(data), 1) 
     346        self.assertEqual(len(self.data_list), 1) 
    323347        self.assertEqual(self.data.filename, filename) 
    324348        self.assertEqual(self.data.run[0], "1234") 

  • test/sasdataloader/test/utest_ascii.py

    ra78a02f r3a473ef  
    22    Unit tests for the ascii (n-column) reader 
    33""" 
     4 
     5import os.path 
    46import warnings 
     7import math 
    58warnings.simplefilter("ignore") 
    69 
    … …  
    912 
    1013 
     14def find(filename): 
     15    return os.path.join(os.path.dirname(__file__), filename) 
     16 
     17 
    1118class ABSReaderTests(unittest.TestCase): 
    1219     
    1320    def setUp(self): 
    1421        self.loader = Loader() 
    15         self.f1_list = self.loader.load("ascii_test_1.txt") 
     22        self.f1_list = self.loader.load(find("ascii_test_1.txt")) 
    1623        self.f1 = self.f1_list[0] 
    17         self.f2_list = self.loader.load("ascii_test_2.txt") 
     24        self.f2_list = self.loader.load(find("ascii_test_2.txt")) 
    1825        self.f2 = self.f2_list[0] 
    19         self.f3_list = self.loader.load("ascii_test_3.txt") 
     26        self.f3_list = self.loader.load(find("ascii_test_3.txt")) 
    2027        self.f3 = self.f3_list[0] 
    21         self.f4_list = self.loader.load("ascii_test_4.abs") 
     28        self.f4_list = self.loader.load(find("ascii_test_4.abs")) 
    2229        self.f4 = self.f4_list[0] 
    23         self.f5_list = self.loader.load("ascii_test_5.txt") 
     30        self.f5_list = self.loader.load(find("ascii_test_5.txt")) 
    2431        self.f5 = self.f5_list[0] 
    2532 
    … …  
    2936        """ 
    3037        # The length of the data is 10 
     38        self.assertEqual(len(self.f1_list), 1) 
     39        self.assertEqual(len(self.f2_list), 1) 
     40        self.assertEqual(len(self.f3_list), 1) 
     41        self.assertEqual(len(self.f4_list), 1) 
     42        self.assertEqual(len(self.f5_list), 1) 
    3143        self.assertEqual(len(self.f1.x), 10) 
    3244        self.assertEqual(self.f1.x[0],0.002618) 
    … …  
    94106        f = None 
    95107        try: 
    96             f = self.loader.load("ascii_test_6.txt") 
     108            f = self.loader.load(find("ascii_test_6.txt")) 
    97109        # The length of the data is 5 
    98110        except: 
    99111            self.assertEqual(f, None) 
    100112 
     113    def test_nan_values(self): 
     114        """ 
     115        Test loading an ascii data file with nan values saved in x, y, or dy. 
     116        """ 
     117        f_1d = self.loader.load(find("nans_in_1d_data.dat"))[0] 
     118        f_2d = self.loader.load(find("nans_in_2d_data.DAT"))[0] 
     119        for i in range(0, len(f_1d.x) - 1): 
     120            self.assertFalse(math.isnan(f_1d.x[i])) 
     121            self.assertFalse(math.isnan(f_1d.y[i])) 
     122            self.assertFalse(math.isnan(f_1d.dy[i])) 
     123        f_2d.data = f_2d.data.flatten() 
     124        f_2d.qx_data = f_2d.qx_data.flatten() 
     125        f_2d.qy_data = f_2d.qy_data.flatten() 
     126        for i in range(0, len(f_2d.data) - 1): 
     127            self.assertFalse(math.isnan(f_2d.data[i])) 
     128            self.assertFalse(math.isnan(f_2d.qx_data[i])) 
     129            self.assertFalse(math.isnan(f_2d.qy_data[i])) 
     130 
     131 
    101132if __name__ == '__main__': 
    102133    unittest.main() 

  • test/sasdataloader/test/utest_averaging.py

    r2a52b0e r3a473ef  
    1313                                                  SlabY, get_q, 
    1414                                                  reader2D_converter) 
     15 
     16 
     17def find(filename): 
     18    return os.path.join(os.path.dirname(__file__), filename) 
    1519 
    1620 
    … …  
    102106 
    103107    def setUp(self): 
    104         filepath = os.path.join(os.path.dirname( 
    105             os.path.realpath(__file__)), 'MAR07232_rest.h5') 
    106         self.data = Loader().load(filepath)[0] 
     108        filepath = find('MAR07232_rest.h5') 
     109        self.data_list = Loader().load(filepath) 
     110        self.data = self.data_list[0] 
    107111 
    108112    def test_ring(self): 
    … …  
    117121 
    118122        o = r(self.data) 
    119         filepath = os.path.join(os.path.dirname( 
    120             os.path.realpath(__file__)), 'ring_testdata.txt') 
    121         answer = Loader().load(filepath)[0] 
    122  
     123        filepath = find('ring_testdata.txt') 
     124        answer_list = Loader().load(filepath) 
     125        answer = answer_list[0] 
     126 
     127        self.assertEqual(len(answer_list), 1) 
    123128        for i in range(r.nbins_phi - 1): 
    124129            self.assertAlmostEqual(o.x[i + 1], answer.x[i], 4) 
    … …  
    137142        o = r(self.data) 
    138143 
    139         filepath = os.path.join(os.path.dirname( 
    140             os.path.realpath(__file__)), 'avg_testdata.txt') 
     144        filepath = find('avg_testdata.txt') 
    141145        answer = Loader().load(filepath)[0] 
    142146        for i in range(r.nbins_phi): 
    … …  
    173177        o = r(self.data) 
    174178 
    175         filepath = os.path.join(os.path.dirname( 
    176             os.path.realpath(__file__)), 'slabx_testdata.txt') 
     179        filepath = find('slabx_testdata.txt') 
    177180        answer = Loader().load(filepath)[0] 
    178181        for i in range(len(o.x)): 
    … …  
    192195        o = r(self.data) 
    193196 
    194         filepath = os.path.join(os.path.dirname( 
    195             os.path.realpath(__file__)), 'slaby_testdata.txt') 
     197        filepath = find('slaby_testdata.txt') 
    196198        answer = Loader().load(filepath)[0] 
    197199        for i in range(len(o.x)): 
    … …  
    219221        o = r(self.data) 
    220222 
    221         filepath = os.path.join(os.path.dirname( 
    222             os.path.realpath(__file__)), 'ring_testdata.txt') 
     223        filepath = find('ring_testdata.txt') 
    223224        answer = Loader().load(filepath)[0] 
    224225        for i in range(len(o.x)): 
    … …  
    237238        o = r(self.data) 
    238239 
    239         filepath = os.path.join(os.path.dirname( 
    240             os.path.realpath(__file__)), 'sectorphi_testdata.txt') 
     240        filepath = find('sectorphi_testdata.txt') 
    241241        answer = Loader().load(filepath)[0] 
    242242        for i in range(len(o.x)): 
    … …  
    255255        o = r(self.data) 
    256256 
    257         filepath = os.path.join(os.path.dirname( 
    258             os.path.realpath(__file__)), 'sectorq_testdata.txt') 
     257        filepath = find('sectorq_testdata.txt') 
    259258        answer = Loader().load(filepath)[0] 
    260259        for i in range(len(o.x)): 

  • test/sasdataloader/test/utest_cansas.py

    rf00072f r3a473ef  
    3131CANSAS_NS = CansasConstants.CANSAS_NS 
    3232 
     33 
     34def find(filename): 
     35    return os.path.join(os.path.dirname(__file__), filename) 
     36 
     37 
    3338class cansas_reader_xml(unittest.TestCase): 
    3439 
    3540    def setUp(self): 
    3641        self.loader = Loader() 
    37         self.xml_valid = "cansas_test_modified.xml" 
    38         self.xml_invalid = "cansas_test.xml" 
    39         self.cansas1d_badunits = "cansas1d_badunits.xml" 
    40         self.cansas1d = "cansas1d.xml" 
    41         self.cansas1d_slit = "cansas1d_slit.xml" 
    42         self.cansas1d_units = "cansas1d_units.xml" 
    43         self.cansas1d_notitle = "cansas1d_notitle.xml" 
    44         self.isis_1_0 = "ISIS_1_0.xml" 
    45         self.isis_1_1 = "ISIS_1_1.xml" 
    46         self.isis_1_1_notrans = "ISIS_1_1_notrans.xml" 
    47         self.isis_1_1_doubletrans = "ISIS_1_1_doubletrans.xml" 
    48         self.schema_1_0 = "cansas1d_v1_0.xsd" 
    49         self.schema_1_1 = "cansas1d_v1_1.xsd" 
    50         self.write_1_0_filename = "isis_1_0_write_test.xml" 
    51         self.write_1_1_filename = "isis_1_1_write_test.xml" 
     42        self.xml_valid = find("cansas_test_modified.xml") 
     43        self.xml_invalid = find("cansas_test.xml") 
     44        self.cansas1d_badunits = find("cansas1d_badunits.xml") 
     45        self.cansas1d = find("cansas1d.xml") 
     46        self.cansas1d_slit = find("cansas1d_slit.xml") 
     47        self.cansas1d_units = find("cansas1d_units.xml") 
     48        self.cansas1d_notitle = find("cansas1d_notitle.xml") 
     49        self.isis_1_0 = find("ISIS_1_0.xml") 
     50        self.isis_1_1 = find("ISIS_1_1.xml") 
     51        self.isis_1_1_notrans = find("ISIS_1_1_notrans.xml") 
     52        self.isis_1_1_doubletrans = find("ISIS_1_1_doubletrans.xml") 
     53        self.schema_1_0 = find("cansas1d_v1_0.xsd") 
     54        self.schema_1_1 = find("cansas1d_v1_1.xsd") 
     55        self.write_1_0_filename = find("isis_1_0_write_test.xml") 
     56        self.write_1_1_filename = find("isis_1_1_write_test.xml") 
    5257 
    5358    def get_number_of_entries(self, dictionary, name, i): 
    … …  
    254259    def setUp(self): 
    255260        self.loader = Loader() 
    256         self.datafile_basic = "simpleexamplefile.h5" 
    257         self.datafile_multiplesasentry = "cansas_1Dand2D_samedatafile.h5" 
    258         self.datafile_multiplesasdata = "cansas_1Dand2D_samesasentry.h5" 
    259         self.datafile_multiplesasdata_multiplesasentry = "cansas_1Dand2D_multiplesasentry_multiplesasdata.h5" 
     261        self.datafile_basic = find("simpleexamplefile.h5") 
     262        self.datafile_multiplesasentry = find("cansas_1Dand2D_samedatafile.h5") 
     263        self.datafile_multiplesasdata = find("cansas_1Dand2D_samesasentry.h5") 
     264        self.datafile_multiplesasdata_multiplesasentry = find("cansas_1Dand2D_multiplesasentry_multiplesasdata.h5") 
    260265 
    261266    def test_real_data(self): 

  • test/sasdataloader/test/utest_extension_registry.py

    rdcb91cf r3a473ef  
    1313logger = logging.getLogger(__name__) 
    1414 
     15 
     16def find(filename): 
     17    return os.path.join(os.path.dirname(__file__), filename) 
     18 
     19 
    1520class ExtensionRegistryTests(unittest.TestCase): 
    1621 
    1722    def setUp(self): 
    18         self.valid_file = "valid_cansas_xml.xml" 
    19         self.valid_file_wrong_known_ext = "valid_cansas_xml.txt" 
    20         self.valid_file_wrong_unknown_ext = "valid_cansas_xml.xyz" 
     23        self.valid_file = find("valid_cansas_xml.xml") 
     24        self.valid_file_wrong_known_ext = find("valid_cansas_xml.txt") 
     25        self.valid_file_wrong_unknown_ext = find("valid_cansas_xml.xyz") 
    2126        shutil.copyfile(self.valid_file, self.valid_file_wrong_known_ext) 
    2227        shutil.copyfile(self.valid_file, self.valid_file_wrong_unknown_ext) 
    23         self.invalid_file = "cansas1d_notitle.xml" 
     28        self.invalid_file = find("cansas1d_notitle.xml") 
    2429 
    2530        self.loader = Loader() 

  • test/sasdataloader/test/utest_generic_file_reader_class.py

    rbeba407 r3a473ef  
    88import numpy as np 
    99 
    10 from sas.sascalc.dataloader.data_info import DataInfo, plottable_1D 
     10from sas.sascalc.dataloader.data_info import DataInfo, plottable_1D, Data1D 
     11from sas.sascalc.dataloader.loader import Loader 
     12from sas.sascalc.dataloader.loader_exceptions import NoKnownLoaderException 
    1113from sas.sascalc.dataloader.file_reader_base_class import FileReader 
    1214 
    … …  
    1416 
    1517 
     18def find(filename): 
     19    return os.path.join(os.path.dirname(__file__), filename) 
     20 
     21 
    1622class GenericFileReaderTests(unittest.TestCase): 
    1723 
    1824    def setUp(self): 
    19         self.reader = FileReader() 
    20         self.bad_file = "ACB123.txt" 
    21         self.good_file = "123ABC.txt" 
    22         self.msg = "Unable to find file at: {}\n".format(self.bad_file) 
    23         self.msg += "Please check your file path and try again." 
    24         x = np.zeros(0) 
    25         y = np.zeros(0) 
    26         self.reader.current_dataset = plottable_1D(x, y) 
    27         self.reader.current_datainfo = DataInfo() 
    28         self.reader.send_to_output() 
     25        self.reader = TestFileReader() 
     26        self.bad_file = find("ACB123.txt") 
     27        self.good_file = find("123ABC.txt") 
     28        self.generic_reader = Loader() 
     29        self.deprecated_file_type = find("FEB18012.ASC") 
    2930 
    3031    def test_bad_file_path(self): 
    31         output = self.reader.read(self.bad_file) 
    32         self.assertEqual(len(output[0].errors), 1) 
    33         self.assertEqual(output[0].errors[0], self.msg) 
     32        self.assertRaises(NoKnownLoaderException, self.reader.read, 
     33                          self.bad_file) 
    3434 
    3535    def test_good_file_path(self): 
    36         f_open = open(self.good_file, 'w') 
    37         f_open.close() 
     36        f = open(self.good_file, 'w') 
     37        f.write('123ABC exists!') 
     38        f.close() 
    3839        output = self.reader.read(self.good_file) 
    39         self.assertEqual(len(output[0].errors), 1) 
    40         self.assertEqual(output[0].errors[0], self.msg) 
     40        self.assertEqual(len(output), 1) 
     41        self.assertEqual(output[0].meta_data["blah"], '123ABC exists!') 
     42 
     43    def test_old_file_types(self): 
     44        f = self.generic_reader.load(self.deprecated_file_type) 
     45        last_f = f[0] 
     46        if hasattr(last_f, "errors"): 
     47            self.assertEquals(len(last_f.errors), 1) 
     48        else: 
     49            self.fail("Errors did not propogate to the file properly.") 
     50 
     51    def test_same_file_unknown_extensions(self): 
     52        # Five files, all with the same content, but different file extensions 
     53        no_ext = find("test_data//TestExtensions") 
     54        not_xml = find("test_data//TestExtensions.notxml") 
     55        # Deprecated extensions 
     56        asc_dep = find("test_data//TestExtensions.asc") 
     57        nxs_dep = find("test_data//TestExtensions.nxs") 
     58        # Native extension as a baseline 
     59        xml_native = find("test_data//TestExtensions.xml") 
     60        # Load the files and check contents 
     61        no_ext_load = self.generic_reader.load(no_ext) 
     62        asc_load = self.generic_reader.load(asc_dep) 
     63        nxs_load = self.generic_reader.load(nxs_dep) 
     64        not_xml_load = self.generic_reader.load(not_xml) 
     65        xml_load = self.generic_reader.load(xml_native) 
     66        self.check_unknown_extension(no_ext_load[0]) 
     67        self.check_unknown_extension(asc_load[0]) 
     68        self.check_unknown_extension(nxs_load[0]) 
     69        self.check_unknown_extension(not_xml_load[0]) 
     70        self.check_unknown_extension(xml_load[0]) 
     71        # Be sure the deprecation warning is passed with the file 
     72        self.assertEquals(len(asc_load[0].errors), 1) 
     73        self.assertEquals(len(nxs_load[0].errors), 1) 
     74 
     75    def check_unknown_extension(self, data): 
     76        self.assertTrue(isinstance(data, Data1D)) 
     77        self.assertEquals(len(data.x), 138) 
     78        self.assertEquals(data.sample.ID, "TK49 c10_SANS") 
     79        self.assertEquals(data.meta_data["loader"], "CanSAS XML 1D") 
    4180 
    4281    def tearDown(self): 
    … …  
    4584        if os.path.isfile(self.good_file): 
    4685            os.remove(self.good_file) 
     86 
     87class TestFileReader(FileReader): 
     88    def get_file_contents(self): 
     89        """ 
     90        Reader specific class to access the contents of the file 
     91        All reader classes that inherit from FileReader must implement 
     92        """ 
     93        x = np.zeros(0) 
     94        y = np.zeros(0) 
     95        self.current_dataset = plottable_1D(x,y) 
     96        self.current_datainfo = DataInfo() 
     97        self.current_datainfo.meta_data["blah"] = self.nextline() 
     98        self.send_to_output() 

  • test/sasdataloader/test/utest_red2d_reader.py

    r248ff73 r3a473ef  
    1010import os.path 
    1111 
     12 
     13def find(filename): 
     14    return os.path.join(os.path.dirname(__file__), filename) 
     15 
     16 
    1217class abs_reader(unittest.TestCase): 
    1318 
    1419    def setUp(self): 
    1520        self.loader = Loader() 
     21        self.data_list = self.loader.load(find("exp18_14_igor_2dqxqy.dat")) 
    1622 
    1723    def test_checkdata(self): 
    … …  
    1925            Test .DAT file loaded as IGOR/DAT 2D Q_map 
    2026        """ 
    21         f = self.loader.load("exp18_14_igor_2dqxqy.dat")[0] 
     27        f = self.data_list[0] 
    2228        # The length of the data is 10 
     29        self.assertEqual(len(self.data_list), 1) 
    2330        self.assertEqual(len(f.qx_data),  36864) 
    2431        self.assertEqual(f.qx_data[0],-0.03573497) 

  • test/sasdataloader/test/utest_sesans.py

    ra78a02f r3a473ef  
    33""" 
    44 
     5import os.path 
    56import unittest 
    67from sas.sascalc.dataloader.loader_exceptions import FileContentsException,\ 
    … …  
    89from sas.sascalc.dataloader.readers.sesans_reader import Reader 
    910from sas.sascalc.dataloader.loader import  Loader 
     11 
     12 
     13def find(filename): 
     14    return os.path.join(os.path.dirname(__file__), filename) 
     15 
    1016 
    1117class sesans_reader(unittest.TestCase): 
    … …  
    1925            Test .SES in the full loader to make sure that the file type is correctly accepted 
    2026        """ 
    21         file = Loader().load("sesans_examples/sphere2micron.ses") 
     27        file = Loader().load(find("sesans_examples/sphere2micron.ses")) 
    2228        f = file[0] 
    2329        # self.assertEqual(f, 5) 
     30        self.assertEqual(len(file), 1) 
    2431        self.assertEqual(len(f.x), 40) 
    2532        self.assertEqual(f.x[0], 391.56) 
    … …  
    3744            Test .SES loading on a TOF dataset 
    3845        """ 
    39         file = self.loader("sesans_examples/sphere_isis.ses") 
     46        file = self.loader(find("sesans_examples/sphere_isis.ses")) 
    4047        f = file[0] 
     48        self.assertEqual(len(file), 1) 
    4149        self.assertEqual(len(f.x), 57) 
    4250        self.assertEqual(f.x[-1], 19303.4) 
    … …  
    5462            FileContentsException, 
    5563            self.loader, 
    56             "sesans_examples/sesans_no_data.ses") 
     64            find("sesans_examples/sesans_no_data.ses")) 
    5765 
    5866    def test_sesans_no_spin_echo_unit(self): 
    … …  
    6371            FileContentsException, 
    6472            self.loader, 
    65             "sesans_examples/no_spin_echo_unit.ses") 
     73            find("sesans_examples/no_spin_echo_unit.ses")) 
    6674 
    6775    def test_sesans_future_version(self): 
    … …  
    7280            FileContentsException, 
    7381            self.loader, 
    74             "sesans_examples/next_gen.ses") 
     82            find("sesans_examples/next_gen.ses")) 
    7583 
    7684    def test_sesans_mandatory_headers(self): 
    … …  
    8189            FileContentsException, 
    8290            self.loader, 
    83             "sesans_examples/no_wavelength.ses") 
     91            find("sesans_examples/no_wavelength.ses")) 
    8492 
    8593    def test_sesans_columns_match_headers(self): 
    … …  
    9098            FileContentsException, 
    9199            self.loader, 
    92             "sesans_examples/too_many_headers.ses") 
     100            find("sesans_examples/too_many_headers.ses")) 
    93101 
    94102if __name__ == "__main__": 
Note: See TracChangeset for help on using the changeset viewer.