Changeset 3a473ef in sasview


Ignore:
Timestamp:
Aug 31, 2018 7:13:23 AM (3 months ago)
Author:
Piotr Rozyczko <rozyczko@…>
Branches:
ESS_GUI, ESS_GUI_Pr_fixes, ESS_GUI_iss879, ESS_GUI_project_save
Children:
c1cfa80
Parents:
aa1db44
Message:

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

Location:
test
Files:
17 edited

Legend:

Unmodified
Added
Removed
  • test/corfunc/test/utest_corfunc.py

    r86ba9d6 r3a473ef  
    44from __future__ import division, print_function 
    55 
     6import os.path 
    67import unittest 
    78import time 
     
    1112from sas.sascalc.corfunc.corfunc_calculator import CorfuncCalculator 
    1213from sas.sascalc.dataloader.data_info import Data1D 
     14 
     15 
     16def find(filename): 
     17    return os.path.join(os.path.dirname(__file__), filename) 
    1318 
    1419 
     
    3136        self.extrapolation = None 
    3237        self.transformation = None 
    33         self.results = [np.loadtxt(filename+"_out.txt").T[2] 
     38        self.results = [np.loadtxt(find(filename+"_out.txt")).T[2] 
    3439                        for filename in ("gamma1", "gamma3", "idf")] 
    3540 
     
    6974        while True: 
    7075            time.sleep(0.001) 
    71             if not self.calculator.transform_isrunning(): 
     76            if (not self.calculator.transform_isrunning() and 
     77                self.transformation is not None): 
    7278                break 
    7379 
    74     def transform_callback(self, transforms): 
    75         transform1, transform3, idf = transforms 
     80        transform1, transform3, idf = self.transformation 
    7681        self.assertIsNotNone(transform1) 
    7782        self.assertAlmostEqual(transform1.y[0], 1) 
    7883        self.assertAlmostEqual(transform1.y[-1], 0, 5) 
     84 
     85    def transform_callback(self, transforms): 
    7986        self.transformation = transforms 
    8087 
     
    110117 
    111118def load_data(filename="98929.txt"): 
    112     data = np.loadtxt(filename, dtype=np.float64) 
     119    data = np.loadtxt(find(filename), dtype=np.float64) 
    113120    q = data[:,0] 
    114121    iq = data[:,1] 
  • test/fileconverter/test/utest_nxcansas_writer.py

    r5a8cdbb r3a473ef  
    33 
    44import os 
    5 import pylint 
     5import os.path 
    66import unittest 
    77import warnings 
    88 
    99warnings.simplefilter("ignore") 
     10 
     11 
     12def find(filename): 
     13    return os.path.join(os.path.dirname(__file__), filename) 
     14 
    1015 
    1116class nxcansas_writer(unittest.TestCase): 
     
    1419        self.loader = Loader() 
    1520        self.writer = NXcanSASWriter() 
    16         self.read_file_1d = "cansas1d.xml" 
    17         self.write_file_1d = "export1d.h5" 
    18         self.read_file_2d = "exp18_14_igor_2dqxqy.dat" 
    19         self.write_file_2d = "export2d.h5" 
     21        self.read_file_1d = find("cansas1d.xml") 
     22        self.write_file_1d = find("export1d.h5") 
     23        self.read_file_2d = find("exp18_14_igor_2dqxqy.dat") 
     24        self.write_file_2d = find("export2d.h5") 
    2025 
    2126        self.data_1d = self.loader.load(self.read_file_1d)[0] 
  • test/pr_inversion/test/utest_explorer.py

    r959eb01 r3a473ef  
    33""" 
    44 
     5import os.path 
    56import unittest, math, numpy 
    67from utest_invertor import load 
    78from sas.sascalc.pr.invertor import Invertor 
    89from sas.sascalc.pr.distance_explorer import DistExplorer 
    9          
     10 
     11 
     12def find(filename): 
     13    return os.path.join(os.path.dirname(__file__), filename) 
     14 
     15 
    1016class TestExplorer(unittest.TestCase): 
    1117             
    1218    def setUp(self): 
    1319        self.invertor = Invertor() 
    14         x, y, err = load('sphere_80.txt') 
     20        x, y, err = load(find('sphere_80.txt')) 
    1521         
    1622        # Choose the right d_max... 
  • test/pr_inversion/test/utest_invertor.py

    rcb62bd5 r3a473ef  
    1010 
    1111import os 
     12import os.path 
    1213import unittest 
    1314import math 
    1415import numpy 
    1516from sas.sascalc.pr.invertor import Invertor 
     17 
     18 
     19def find(filename): 
     20    return os.path.join(os.path.dirname(__file__), filename) 
    1621 
    1722 
     
    2833            self.x_in[i] = 1.0*(i+1) 
    2934        
    30         x, y, err = load("sphere_80.txt") 
     35        x, y, err = load(find("sphere_80.txt")) 
    3136 
    3237        # Choose the right d_max... 
     
    192197            Test an inversion for which we know the answer 
    193198        """ 
    194         x, y, err = load("sphere_80.txt") 
     199        x, y, err = load(find("sphere_80.txt")) 
    195200 
    196201        # Choose the right d_max... 
     
    247252            Test an inversion for which we know the answer 
    248253        """ 
    249         x, y, err = load("sphere_80.txt") 
     254        x, y, err = load(find("sphere_80.txt")) 
    250255 
    251256        # Choose the right d_max... 
     
    312317            Test error condition where a point has q=0 
    313318        """ 
    314         x, y, err = load("sphere_80.txt") 
     319        x, y, err = load(find("sphere_80.txt")) 
    315320        x[0] = 0.0 
    316321         
     
    329334            Test error condition where a point has q<0 
    330335        """ 
    331         x, y, err = load("sphere_80.txt") 
     336        x, y, err = load(find("sphere_80.txt")) 
    332337        x[0] = -0.2 
    333338         
     
    353358            Test error condition where a point has q<0 
    354359        """ 
    355         x, y, err = load("sphere_80.txt") 
     360        x, y, err = load(find("sphere_80.txt")) 
    356361        y[0] = 0.0 
    357362         
     
    374379         
    375380    def no_test_time(self): 
    376         x, y, err = load("sphere_80.txt") 
     381        x, y, err = load(find("sphere_80.txt")) 
    377382 
    378383        # Choose the right d_max... 
     
    406411         
    407412    def test_save(self): 
    408         x, y, err = load("sphere_80.txt") 
     413        x, y, err = load(find("sphere_80.txt")) 
    409414 
    410415        # Choose the right d_max... 
     
    464469            Test an inversion for which we know the answer 
    465470        """ 
    466         x, y, err = load("data_error_1.txt") 
     471        x, y, err = load(find("data_error_1.txt")) 
    467472 
    468473        # Choose the right d_max... 
     
    482487            Have zero as an error should raise an exception 
    483488        """ 
    484         x, y, err = load("data_error_2.txt") 
     489        x, y, err = load(find("data_error_2.txt")) 
    485490 
    486491        # Set data 
     
    495500            Test an inversion for which we know the answer 
    496501        """ 
    497         x, y, err = load("data_error_1.txt") 
     502        x, y, err = load(find("data_error_1.txt")) 
    498503 
    499504        # Set data 
     
    511516            An exception should be raised. 
    512517        """ 
    513         x, y, err = load("data_error_3.txt") 
     518        x, y, err = load(find("data_error_3.txt")) 
    514519 
    515520        # Set data 
     
    521526            Should not complain or crash. 
    522527        """ 
    523         x, y, err = load("data_error_4.txt") 
     528        x, y, err = load(find("data_error_4.txt")) 
    524529 
    525530        # Set data 
     
    535540            Makes not sense, but should not complain or crash. 
    536541        """ 
    537         x, y, err = load("data_error_5.txt") 
     542        x, y, err = load(find("data_error_5.txt")) 
    538543 
    539544        # Set data 
     
    549554            Makes not sense, but should not complain or crash. 
    550555        """ 
    551         x, y, err = load("data_error_6.txt") 
     556        x, y, err = load(find("data_error_6.txt")) 
    552557 
    553558        # Set data 
  • test/sascalculator/test/utest_sas_gen.py

    r1d014cb r3a473ef  
    22Unit tests for the sas_gen 
    33""" 
     4 
     5import os.path 
    46import warnings 
    57warnings.simplefilter("ignore") 
    68 
    79import unittest 
     10import numpy as np 
     11 
    812from sas.sascalc.calculator import sas_gen 
     13 
     14 
     15def find(filename): 
     16    return os.path.join(os.path.dirname(__file__), filename) 
    917 
    1018 
     
    2028        Test .sld file loaded 
    2129        """ 
    22         f = self.sldloader.read("sld_file.sld") 
     30        f = self.sldloader.read(find("sld_file.sld")) 
    2331        self.assertEqual(f.pos_x[0], -40.5) 
    2432        self.assertEqual(f.pos_y[0], -13.5) 
     
    2937        Test .pdb file loaded 
    3038        """ 
    31         f = self.pdbloader.read("c60.pdb") 
     39        f = self.pdbloader.read(find("c60.pdb")) 
    3240        self.assertEqual(f.pos_x[0], -0.733) 
    3341        self.assertEqual(f.pos_y[0], -1.008) 
     
    3846        Test .omf file loaded 
    3947        """ 
    40         f = self.omfloader.read("A_Raw_Example-1.omf") 
     48        f = self.omfloader.read(find("A_Raw_Example-1.omf")) 
    4149        output = sas_gen.OMF2SLD() 
    4250        output.set_data(f) 
     
    4856        self.assertEqual(output.pos_z[0], 0.0) 
    4957 
     58    def test_calculator(self): 
     59        """ 
     60        Test that the calculator calculates. 
     61        """ 
     62        f = self.omfloader.read(find("A_Raw_Example-1.omf")) 
     63        omf2sld = sas_gen.OMF2SLD() 
     64        omf2sld.set_data(f) 
     65        model = sas_gen.GenSAS() 
     66        model.set_sld_data(omf2sld.output) 
     67        x = np.linspace(0, 0.1, 11)[1:] 
     68        model.runXY([x, x]) 
     69 
    5070 
    5171if __name__ == '__main__': 
  • test/sascalculator/test/utest_slit_length_calculator.py

    rb09095a r3a473ef  
    33""" 
    44 
     5import os.path 
    56import unittest 
    67from sas.sascalc.dataloader.readers.ascii_reader import Reader 
    78from sas.sascalc.calculator.slit_length_calculator import SlitlengthCalculator \ 
    89    as calculator 
     10 
     11 
     12def find(filename): 
     13    return os.path.join(os.path.dirname(__file__), filename) 
    914 
    1015 
     
    1924            Test slit_length_calculator" 
    2025        """ 
    21         list = self.reader.read("beam profile.DAT") 
     26        list = self.reader.read(find("beam profile.DAT")) 
    2227        self.assertTrue(len(list) == 1) 
    2328        f = list[0] 
  • 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__": 
  • test/sasguiframe/test/utest_manipulations.py

    rc0ca2e3d r3a473ef  
    1515 
    1616 
     17def find(filename): 
     18    return os.path.join(os.path.dirname(__file__), filename) 
     19 
     20 
    1721class DataInfoTests(unittest.TestCase): 
    1822 
    1923    def setUp(self): 
    20         data = Loader().load("cansas1d.xml") 
     24        data = Loader().load(find("cansas1d.xml")) 
    2125        self.data = data[0] 
    2226 
     
    3539 
    3640    def setUp(self): 
    37         data = Loader().load("cansas1d.xml") 
     41        data = Loader().load(find("cansas1d.xml")) 
    3842        self.data = data[0] 
    3943 
  • test/sasinvariant/test/utest_data_handling.py

    r9a5097c r3a473ef  
    88copyright 2010, University of Tennessee 
    99""" 
     10 
     11import os.path 
    1012import unittest 
    1113import math 
     
    1517 
    1618from sas.sascalc.invariant import invariant 
    17      
     19 
     20 
     21def find(filename): 
     22    return os.path.join(os.path.dirname(__file__), filename) 
     23 
     24 
    1825class TestLinearFit(unittest.TestCase): 
    1926    """ 
     
    94101    """ 
    95102    def setUp(self): 
    96         data = Loader().load("latex_smeared_slit.xml") 
     103        data = Loader().load(find("latex_smeared_slit.xml")) 
    97104        self.data = data[0] 
    98105        self.data.dxl = None 
     
    676683            value  = math.fabs(test_y[i]- temp[i])/temp[i] 
    677684            self.assert_(value < 0.001)                 
    678                        
  • test/sasinvariant/test/utest_use_cases.py

    rb09095a r3a473ef  
    44""" 
    55#TODO: there's no test for smeared extrapolation 
     6 
     7import os.path 
    68import unittest 
    79from sas.sascalc.dataloader.loader import  Loader 
     
    911 
    1012 
     13def find(filename): 
     14    return os.path.join(os.path.dirname(__file__), filename) 
     15 
     16 
    1117class Data1D: 
    1218    pass 
     
    1824    """ 
    1925    def setUp(self): 
    20         self.data_list = Loader().load("linefittest.txt") 
     26        self.data_list = Loader().load(find("linefittest.txt")) 
    2127        self.data = self.data_list[0] 
    2228 
     
    5763    """ 
    5864    def setUp(self): 
    59         self.data_list = Loader().load("linefittest_no_weight.txt") 
     65        self.data_list = Loader().load(find("linefittest_no_weight.txt")) 
    6066        self.data = self.data_list[0] 
    6167 
     
    96102    """ 
    97103    def setUp(self): 
    98         self.data_list = Loader().load("PolySpheres.txt") 
     104        self.data_list = Loader().load(find("PolySpheres.txt")) 
    99105        self.data = self.data_list[0] 
    100106 
     
    278284    def setUp(self): 
    279285        # data with smear info 
    280         list = Loader().load("latex_smeared.xml") 
     286        list = Loader().load(find("latex_smeared.xml")) 
    281287        self.data_q_smear = list[0] 
    282288 
Note: See TracChangeset for help on using the changeset viewer.