Changeset f53d684 in sasview


Ignore:
Timestamp:
Dec 5, 2017 12:31:07 PM (10 months ago)
Author:
Paul Kienzle <pkienzle@…>
Branches:
master, bad_file_loader_fix, ticket-1094-headless, ticket-1111, ticket-818, ticket885, win64bit_conda_vm
Children:
5bb05a4
Parents:
3053a4a
git-author:
Stuart Prescott <llimeht@…> (12/05/17 12:31:07)
git-committer:
Paul Kienzle <pkienzle@…> (12/05/17 12:31:07)
Message:

Make tests work from any directory and functional without special runner script (#124)

Files:
2 added
17 edited

Legend:

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

    r86ba9d6 rf53d684  
    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 
     
    110115 
    111116def load_data(filename="98929.txt"): 
    112     data = np.loadtxt(filename, dtype=np.float64) 
     117    data = np.loadtxt(find(filename), dtype=np.float64) 
    113118    q = data[:,0] 
    114119    iq = data[:,1] 
  • test/fileconverter/test/utest_nxcansas_writer.py

    rc16ffe7 rf53d684  
    33 
    44import os 
     5import os.path 
    56import unittest 
    67import warnings 
    78 
    89warnings.simplefilter("ignore") 
     10 
     11 
     12def find(filename): 
     13    return os.path.join(os.path.dirname(__file__), filename) 
     14 
    915 
    1016class nxcansas_writer(unittest.TestCase): 
     
    1319        self.loader = Loader() 
    1420        self.writer = NXcanSASWriter() 
    15         self.read_file_1d = "cansas1d.xml" 
    16         self.write_file_1d = "export1d.h5" 
    17         self.read_file_2d = "exp18_14_igor_2dqxqy.dat" 
    18         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") 
    1925 
    2026        self.data_1d = self.loader.load(self.read_file_1d)[0] 
  • test/pr_inversion/test/utest_explorer.py

    r959eb01 rf53d684  
    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 rf53d684  
    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 rf53d684  
    22Unit tests for the sas_gen 
    33""" 
     4 
     5import os.path 
    46import warnings 
    57warnings.simplefilter("ignore") 
     
    79import unittest 
    810from sas.sascalc.calculator import sas_gen 
     11 
     12 
     13def find(filename): 
     14    return os.path.join(os.path.dirname(__file__), filename) 
    915 
    1016 
     
    2026        Test .sld file loaded 
    2127        """ 
    22         f = self.sldloader.read("sld_file.sld") 
     28        f = self.sldloader.read(find("sld_file.sld")) 
    2329        self.assertEqual(f.pos_x[0], -40.5) 
    2430        self.assertEqual(f.pos_y[0], -13.5) 
     
    2935        Test .pdb file loaded 
    3036        """ 
    31         f = self.pdbloader.read("c60.pdb") 
     37        f = self.pdbloader.read(find("c60.pdb")) 
    3238        self.assertEqual(f.pos_x[0], -0.733) 
    3339        self.assertEqual(f.pos_y[0], -1.008) 
     
    3844        Test .omf file loaded 
    3945        """ 
    40         f = self.omfloader.read("A_Raw_Example-1.omf") 
     46        f = self.omfloader.read(find("A_Raw_Example-1.omf")) 
    4147        output = sas_gen.OMF2SLD() 
    4248        output.set_data(f) 
  • test/sascalculator/test/utest_slit_length_calculator.py

    rb09095a rf53d684  
    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

    rfe15198 rf53d684  
    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         self.data_list = reader.read("jan08002.ABS") 
     26        self.data_list = reader.read(find("jan08002.ABS")) 
    2327        self.data = self.data_list[0] 
    2428 
     
    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 
     
    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") 
    7377 
     
    7680    def setUp(self): 
    7781        reader = DANSEReader() 
    78         self.data_list = reader.read("MP_New.sans") 
     82        self.data_list = reader.read(find("MP_New.sans")) 
    7983        self.data = self.data_list[0] 
    8084 
     
    8892        """ 
    8993        self.assertEqual(len(self.data_list), 1) 
    90         self.assertEqual(self.data.filename, "MP_New.sans") 
     94        self.assertEqual(os.path.basename(self.data.filename), "MP_New.sans") 
    9195        self.assertEqual(self.data.meta_data['loader'], "DANSE") 
    9296 
     
    114118    def test_generic_loader(self): 
    115119        # the generic loader should work as well 
    116         data = Loader().load("MP_New.sans") 
     120        data = Loader().load(find("MP_New.sans")) 
    117121        self.assertEqual(len(data), 1) 
    118122        self.assertEqual(data[0].meta_data['loader'], "DANSE") 
     
    123127    def setUp(self): 
    124128        reader = CANSASReader() 
    125         self.data_list = reader.read("cansas1d.xml") 
     129        self.data_list = reader.read(find("cansas1d.xml")) 
    126130        self.data = self.data_list[0] 
    127131 
    128132    def test_generic_loader(self): 
    129133        # the generic loader should work as well 
    130         data = Loader().load("cansas1d.xml") 
     134        data = Loader().load(find("cansas1d.xml")) 
    131135        self.assertEqual(len(data), 1) 
    132136        self.assertEqual(data[0].meta_data['loader'], "CanSAS XML 1D") 
    133137 
    134138    def test_cansas_checkdata(self): 
    135         self.assertEqual(self.data.filename, "cansas1d.xml") 
     139        self.assertEqual(os.path.basename(self.data.filename), "cansas1d.xml") 
    136140        self._checkdata() 
    137141 
     
    282286 
    283287        filename = "write_test.xml" 
    284         r.write(filename, self.data) 
    285         data = Loader().load(filename) 
     288        r.write(find(filename), self.data) 
     289        data = Loader().load(find(filename)) 
    286290        self.data = data[0] 
    287291        self.assertEqual(len(data), 1) 
     
    297301        """ 
    298302        filename = "cansas1d_units.xml" 
    299         data = CANSASReader().read(filename) 
     303        data = CANSASReader().read(find(filename)) 
    300304        self.data = data[0] 
    301305        self.assertEqual(len(data), 1) 
     
    309313        """ 
    310314        filename = "cansas1d_badunits.xml" 
    311         data = CANSASReader().read(filename) 
     315        data = CANSASReader().read(find(filename)) 
    312316        self.data = data[0] 
    313317        self.assertEqual(len(data), 1) 
     
    326330        """ 
    327331        filename = "cansas1d_slit.xml" 
    328         data = CANSASReader().read(filename) 
     332        data = CANSASReader().read(find(filename)) 
    329333        self.data = data[0] 
    330334        self.assertEqual(len(data), 1) 
  • test/sasdataloader/test/utest_ascii.py

    rfe15198 rf53d684  
    22    Unit tests for the ascii (n-column) reader 
    33""" 
     4 
     5import os.path 
    46import warnings 
    57warnings.simplefilter("ignore") 
     
    911 
    1012 
     13def find(filename): 
     14    return os.path.join(os.path.dirname(__file__), filename) 
     15 
     16 
    1117class ABSReaderTests(unittest.TestCase): 
    1218     
    1319    def setUp(self): 
    1420        self.loader = Loader() 
    15         self.f1_list = self.loader.load("ascii_test_1.txt") 
     21        self.f1_list = self.loader.load(find("ascii_test_1.txt")) 
    1622        self.f1 = self.f1_list[0] 
    17         self.f2_list = self.loader.load("ascii_test_2.txt") 
     23        self.f2_list = self.loader.load(find("ascii_test_2.txt")) 
    1824        self.f2 = self.f2_list[0] 
    19         self.f3_list = self.loader.load("ascii_test_3.txt") 
     25        self.f3_list = self.loader.load(find("ascii_test_3.txt")) 
    2026        self.f3 = self.f3_list[0] 
    21         self.f4_list = self.loader.load("ascii_test_4.abs") 
     27        self.f4_list = self.loader.load(find("ascii_test_4.abs")) 
    2228        self.f4 = self.f4_list[0] 
    23         self.f5_list = self.loader.load("ascii_test_5.txt") 
     29        self.f5_list = self.loader.load(find("ascii_test_5.txt")) 
    2430        self.f5 = self.f5_list[0] 
    2531 
     
    99105        f = None 
    100106        try: 
    101             f = self.loader.load("ascii_test_6.txt") 
     107            f = self.loader.load(find("ascii_test_6.txt")) 
    102108        # The length of the data is 5 
    103109        except: 
  • test/sasdataloader/test/utest_averaging.py

    rfe15198 rf53d684  
    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') 
     108        filepath = find('MAR07232_rest.h5') 
    106109        self.data_list = Loader().load(filepath) 
    107110        self.data = self.data_list[0] 
     
    118121 
    119122        o = r(self.data) 
    120         filepath = os.path.join(os.path.dirname( 
    121             os.path.realpath(__file__)), 'ring_testdata.txt') 
     123        filepath = find('ring_testdata.txt') 
    122124        answer_list = Loader().load(filepath) 
    123125        answer = answer_list[0] 
     
    140142        o = r(self.data) 
    141143 
    142         filepath = os.path.join(os.path.dirname( 
    143             os.path.realpath(__file__)), 'avg_testdata.txt') 
     144        filepath = find('avg_testdata.txt') 
    144145        answer = Loader().load(filepath)[0] 
    145146        for i in range(r.nbins_phi): 
     
    176177        o = r(self.data) 
    177178 
    178         filepath = os.path.join(os.path.dirname( 
    179             os.path.realpath(__file__)), 'slabx_testdata.txt') 
     179        filepath = find('slabx_testdata.txt') 
    180180        answer = Loader().load(filepath)[0] 
    181181        for i in range(len(o.x)): 
     
    195195        o = r(self.data) 
    196196 
    197         filepath = os.path.join(os.path.dirname( 
    198             os.path.realpath(__file__)), 'slaby_testdata.txt') 
     197        filepath = find('slaby_testdata.txt') 
    199198        answer = Loader().load(filepath)[0] 
    200199        for i in range(len(o.x)): 
     
    222221        o = r(self.data) 
    223222 
    224         filepath = os.path.join(os.path.dirname( 
    225             os.path.realpath(__file__)), 'ring_testdata.txt') 
     223        filepath = find('ring_testdata.txt') 
    226224        answer = Loader().load(filepath)[0] 
    227225        for i in range(len(o.x)): 
     
    240238        o = r(self.data) 
    241239 
    242         filepath = os.path.join(os.path.dirname( 
    243             os.path.realpath(__file__)), 'sectorphi_testdata.txt') 
     240        filepath = find('sectorphi_testdata.txt') 
    244241        answer = Loader().load(filepath)[0] 
    245242        for i in range(len(o.x)): 
     
    258255        o = r(self.data) 
    259256 
    260         filepath = os.path.join(os.path.dirname( 
    261             os.path.realpath(__file__)), 'sectorq_testdata.txt') 
     257        filepath = find('sectorq_testdata.txt') 
    262258        answer = Loader().load(filepath)[0] 
    263259        for i in range(len(o.x)): 
  • test/sasdataloader/test/utest_cansas.py

    rf00072f rf53d684  
    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 rf53d684  
    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

    r3648cbf rf53d684  
    1414 
    1515 
     16def find(filename): 
     17    return os.path.join(os.path.dirname(__file__), filename) 
     18 
     19 
    1620class GenericFileReaderTests(unittest.TestCase): 
    1721 
    1822    def setUp(self): 
    1923        self.reader = TestFileReader() 
    20         self.bad_file = "ACB123.txt" 
    21         self.good_file = "123ABC.txt" 
     24        self.bad_file = find("ACB123.txt") 
     25        self.good_file = find("123ABC.txt") 
    2226 
    2327    def test_bad_file_path(self): 
  • test/sasdataloader/test/utest_red2d_reader.py

    rfe15198 rf53d684  
    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() 
    16         self.data_list = self.loader.load("exp18_14_igor_2dqxqy.dat") 
     21        self.data_list = self.loader.load(find("exp18_14_igor_2dqxqy.dat")) 
    1722 
    1823    def test_checkdata(self): 
  • test/sasdataloader/test/utest_sesans.py

    rfe15198 rf53d684  
    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) 
     
    3844            Test .SES loading on a TOF dataset 
    3945        """ 
    40         file = self.loader("sesans_examples/sphere_isis.ses") 
     46        file = self.loader(find("sesans_examples/sphere_isis.ses")) 
    4147        f = file[0] 
    4248        self.assertEqual(len(file), 1) 
     
    5662            FileContentsException, 
    5763            self.loader, 
    58             "sesans_examples/sesans_no_data.ses") 
     64            find("sesans_examples/sesans_no_data.ses")) 
    5965 
    6066    def test_sesans_no_spin_echo_unit(self): 
     
    6571            FileContentsException, 
    6672            self.loader, 
    67             "sesans_examples/no_spin_echo_unit.ses") 
     73            find("sesans_examples/no_spin_echo_unit.ses")) 
    6874 
    6975    def test_sesans_future_version(self): 
     
    7480            FileContentsException, 
    7581            self.loader, 
    76             "sesans_examples/next_gen.ses") 
     82            find("sesans_examples/next_gen.ses")) 
    7783 
    7884    def test_sesans_mandatory_headers(self): 
     
    8389            FileContentsException, 
    8490            self.loader, 
    85             "sesans_examples/no_wavelength.ses") 
     91            find("sesans_examples/no_wavelength.ses")) 
    8692 
    8793    def test_sesans_columns_match_headers(self): 
     
    9298            FileContentsException, 
    9399            self.loader, 
    94             "sesans_examples/too_many_headers.ses") 
     100            find("sesans_examples/too_many_headers.ses")) 
    95101 
    96102if __name__ == "__main__": 
  • test/sasguiframe/test/utest_manipulations.py

    rc0ca2e3d rf53d684  
    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 rf53d684  
    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 rf53d684  
    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.