Changeset add6365 in sasview for test


Ignore:
Timestamp:
Oct 19, 2018 2:17:38 PM (6 years ago)
Author:
krzywon
Branches:
unittest-saveload
Children:
08f921e
Parents:
497e06d (diff), 9fb4572 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge branch 'ticket-1111' into unittest-saveload

Location:
test
Files:
20 added
3 deleted
17 edited
7 moved

Legend:

Unmodified
Added
Removed

  • test/corfunc/test/utest_corfunc.py

    r86ba9d6 r6ef75fa6  
    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 rf53d684  
    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 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 r39a018b  
    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 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/test_data/avg_testdata.txt

    r8c9ffde r7fd5e2a  
    110.00019987186878 -0.01196215 0.148605728355 
    2 0.000453772721237 0.02091606 0.0680283029334 
    3 0.000750492390439 -0.01337855 0.0444902910757 
    4 0.00103996394336 0.03062 0.0580312894528 
    5 0.0013420198959 0.0811008333333 0.0540469289108 
    6 0.001652061869 0.167022288372 0.0651891320031 
    7 0.00196086470492 27.5554711176 0.735053300957 
     20.000453772721237 0.02091606 0.23372601 
     30.000750492390439 -0.01337855 0.17169562 
     40.00103996394336 0.03062 0.13136407 
     50.0013420198959 0.0811008333333 0.10681163 
     60.001652061869 0.167022288372 0.10098903 
     70.00196086470492 27.5554711176 0.7350533 
    880.00226262401224 105.031578947 1.35744586624 
    990.00256734439716 82.1791776119 1.10749938588 

  • test/sasdataloader/test/test_data/ring_testdata.txt

    r400155b r7fd5e2a  
    440.628318530718 0.964040908176 0.0790933208542 
    550.942477796077 0.922142905769 0.0781616076625 
    6 1.25663706144 1.02710537736 0.080875897538 
     61.25663706144 1.02710537736 0.08136351514804 
    771.57079632679 1.01448978075 0.0808313893873 
    881.88495559215 1.04677136013 0.0828850195035 

  • test/sasdataloader/test/test_data/sectorphi_testdata.txt

    r8c9ffde r7fd5e2a  
    13130.981747704247 0.893411561538 0.151685984204 
    14141.06028752059 0.86231787 0.152618707077 
    15 1.13882733693 1.0607364925 0.164276150316 
     151.13882733693 1.0607364925 0.166167546658 
    16161.21736715327 1.0684421475 0.163649496829 
    17 1.29590696961 1.09330437436 0.167871645263 
     171.29590696961 1.09330437436 0.16981858402 
    18181.37444678595 0.88759347 0.150974201439 
    19191.45298660229 1.1352002 0.172191803977 

  • test/sasdataloader/test/test_data/sectorq_testdata.txt

    r8c9ffde r7fd5e2a  
    17170.00913119845523 0.405669568421 0.0705339106673 
    18180.00938052380065 0.331241946 0.061307573431 
    19 0.00962825731078 0.237315993939 0.0578654769893 
     190.00962825731078 0.237315993939 0.059602636160850493 
    20200.00987552050718 0.296916590385 0.0592796733987 

  • test/sasdataloader/test/test_data/slabx_testdata.txt

    r8c9ffde r7fd5e2a  
    2121-0.00184475260646 2.40154 1.09579651396 
    2222-0.00143541414791 0.065281 0.198049867458 
    23 -0.00102607559383 -0.04767235 0.154389685536 
    24 -0.000616736954402 -0.0090503 0.0960105462957 
     23-0.00102607559383 -0.04767235 0.52329358394690839 
     24-0.000616736954402 -0.0090503 0.36635778277525377 
    2525-0.000207398273925 0.03109325 0.246629023029 
    26 0.000201940423805 -0.027508775 0.082928847514 
     260.000201940423805 -0.027508775 0.36314899662535211 
    27270.000611279108096 0.03251315 0.246951260373 
    28 0.00102061774154 -0.00987975 0.144233534589 
    29 0.00142995630705 0.075937 0.19485507435 
     280.00102061774154 -0.00987975 0.38184199939241886 
     290.00142995630705 0.075937 0.53662696540520582 
    30300.00183929475361 10.60918375 1.62858709853 
    31310.00224863307777 106.2485 7.2886384188 

  • test/sasdataloader/test/test_data/slaby_testdata.txt

    r8c9ffde r7fd5e2a  
    1 -0.00981587154747 0.197046827778 0.0872226309261 
     1-0.00981587154747 0.197046827778 0.09153902 
    22-0.00940654133769 0.2466434 0.124972263589 
    33-0.0089972103454 0.218745969444 0.0838510368061 
    44-0.00858787875434 0.126093522222 0.107482002513 
    5 -0.00817854644886 0.310427366667 0.100945289852 
     5-0.00817854644886 0.310427366667 0.10469745 
    66-0.0077692135991 0.0843802722222 0.103942898914 
    77-0.00735988010303 0.246036369444 0.0916479235889 

  • test/sasdataloader/test/utest_abs_reader.py

    r574adc7 rf4e2f22  
    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.assertEqual(data_abs.x[i], data_cor.x[i]) 
     83            self.assertEqual(data_abs.y[i], data_cor.y[i]) 
     84            self.assertEqual(data_abs.dxl[i], data_cor.dxl[i]) 
     85            self.assertEqual(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 
    … …  
    102118        self.assertEqual(self.data.detector[0].beam_center.y, center_y) 
    103119 
    104         self.assertEqual(self.data.I_unit, '1/cm') 
     120        self.assertEqual(self.data.I_unit, 'cm^{-1}') 
    105121        self.assertEqual(self.data.data[0], 1.57831) 
    106122        self.assertEqual(self.data.data[1], 2.70983) 
    … …  
    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 r9fb4572  
    22    Unit tests for the ascii (n-column) reader 
    33""" 
     4 
     5import os.path 
    46import warnings 
     7import math 
    58warnings.simplefilter("ignore") 
    69 
    710import unittest 
    811from sas.sascalc.dataloader.loader import Loader 
     12from sas.sascalc.dataloader.data_info import Data2D 
     13 
     14 
     15def find(filename): 
     16    return os.path.join(os.path.dirname(__file__), filename) 
    917 
    1018 
    … …  
    1321    def setUp(self): 
    1422        self.loader = Loader() 
    15         self.f1_list = self.loader.load("ascii_test_1.txt") 
     23        self.f1_list = self.loader.load(find("ascii_test_1.txt")) 
    1624        self.f1 = self.f1_list[0] 
    17         self.f2_list = self.loader.load("ascii_test_2.txt") 
     25        self.f2_list = self.loader.load(find("ascii_test_2.txt")) 
    1826        self.f2 = self.f2_list[0] 
    19         self.f3_list = self.loader.load("ascii_test_3.txt") 
     27        self.f3_list = self.loader.load(find("ascii_test_3.txt")) 
    2028        self.f3 = self.f3_list[0] 
    21         self.f4_list = self.loader.load("ascii_test_4.abs") 
     29        self.f4_list = self.loader.load(find("ascii_test_4.abs")) 
    2230        self.f4 = self.f4_list[0] 
    23         self.f5_list = self.loader.load("ascii_test_5.txt") 
     31        self.f5_list = self.loader.load(find("ascii_test_5.txt")) 
    2432        self.f5 = self.f5_list[0] 
    2533 
    … …  
    2937        """ 
    3038        # The length of the data is 10 
     39        self.assertEqual(len(self.f1_list), 1) 
     40        self.assertEqual(len(self.f2_list), 1) 
     41        self.assertEqual(len(self.f3_list), 1) 
     42        self.assertEqual(len(self.f4_list), 1) 
     43        self.assertEqual(len(self.f5_list), 1) 
    3144        self.assertEqual(len(self.f1.x), 10) 
    3245        self.assertEqual(self.f1.x[0],0.002618) 
    … …  
    94107        f = None 
    95108        try: 
    96             f = self.loader.load("ascii_test_6.txt") 
     109            f = self.loader.load(find("ascii_test_6.txt")) 
    97110        # The length of the data is 5 
    98111        except: 
    99112            self.assertEqual(f, None) 
    100113 
     114    def test_nan_values(self): 
     115        """ 
     116        Test loading an ascii data file with nan values saved in x, y, or dy. 
     117        """ 
     118        f_1d = self.loader.load(find("nans_in_1d_data.dat"))[0] 
     119        f_2d = self.loader.load(find("nans_in_2d_data.DAT"))[0] 
     120        for i in range(0, len(f_1d.x) - 1): 
     121            self.assertFalse(math.isnan(f_1d.x[i])) 
     122            self.assertFalse(math.isnan(f_1d.y[i])) 
     123            self.assertFalse(math.isnan(f_1d.dy[i])) 
     124        self.assertTrue(isinstance(f_2d, Data2D)) 
     125        f_2d.data = f_2d.data.flatten() 
     126        f_2d.qx_data = f_2d.qx_data.flatten() 
     127        f_2d.qy_data = f_2d.qy_data.flatten() 
     128        for i in range(0, len(f_2d.data) - 1): 
     129            self.assertFalse(math.isnan(f_2d.data[i])) 
     130            self.assertFalse(math.isnan(f_2d.qx_data[i])) 
     131            self.assertFalse(math.isnan(f_2d.qy_data[i])) 
     132 
     133 
    101134if __name__ == '__main__': 
    102135    unittest.main() 

  • test/sasdataloader/test/utest_averaging.py

    r2a52b0e rf4e2f22  
    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('test_data' + os.sep + '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('test_data' + os.sep + '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('test_data' + os.sep + 'avg_testdata.txt') 
    141145        answer = Loader().load(filepath)[0] 
    142146        for i in range(r.nbins_phi): 
    … …  
    154158        s, ds, npoints = r(self.data) 
    155159        self.assertAlmostEqual(s, 34.278990899999997, 4) 
    156         self.assertAlmostEqual(ds, 7.8007981835194293, 4) 
     160        self.assertAlmostEqual(ds, 8.237259999538685, 4) 
    157161        self.assertAlmostEqual(npoints, 324.0000, 4) 
    158162 
    … …  
    160164        s, ds = r(self.data) 
    161165        self.assertAlmostEqual(s, 0.10579935462962962, 4) 
    162         self.assertAlmostEqual(ds, 0.024076537603455028, 4) 
     166        self.assertAlmostEqual(ds, 0.02542364197388483, 4) 
    163167 
    164168    def test_slabX(self): 
    … …  
    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('test_data' + os.sep + '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('test_data' + os.sep + '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('test_data' + os.sep + '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('test_data' + os.sep + '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('test_data' + os.sep + 'sectorq_testdata.txt') 
    259258        answer = Loader().load(filepath)[0] 
    260259        for i in range(len(o.x)): 

  • test/sasdataloader/test/utest_cansas.py

    rf00072f rf4e2f22  
    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): 
    … …  
    8691        reader = XMLreader(self.xml_valid, self.schema_1_0) 
    8792        valid = reader.validate_xml() 
    88         if valid: 
    89             self.assertTrue(valid) 
    90         else: 
    91             self.assertFalse(valid) 
     93        self.assertTrue(valid) 
    9294 
    9395    def _check_data(self, data): 
    … …  
    188190    def test_save_cansas_v1_0(self): 
    189191        xmlreader = XMLreader(self.isis_1_0, self.schema_1_0) 
    190         valid = xmlreader.validate_xml() 
    191         self.assertTrue(valid) 
     192        self.assertTrue(xmlreader.validate_xml()) 
    192193        reader_generic = Loader() 
    193194        dataloader = reader_generic.load(self.isis_1_0) 
    … …  
    202203            return_data = reader2.read(self.write_1_0_filename) 
    203204            written_data = return_data[0] 
    204             XMLreader(self.write_1_0_filename, self.schema_1_0) 
    205             valid = xmlreader.validate_xml() 
    206             self.assertTrue(valid) 
     205            xmlreader = XMLreader(self.write_1_0_filename, self.schema_1_0) 
     206            self.assertTrue(xmlreader.validate_xml()) 
    207207            self._check_data(written_data) 
    208208        if os.path.isfile(self.write_1_0_filename): 
    … …  
    254254    def setUp(self): 
    255255        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" 
     256        self.datafile_basic = find("simpleexamplefile.h5") 
     257        self.datafile_multiplesasentry = find( 
     258            "test_data" + os.sep + "nxcansas_1Dand2D_multisasentry.h5") 
     259        self.datafile_multiplesasdata = find( 
     260            "test_data" + os.sep + "nxcansas_1Dand2D_multisasdata.h5") 
     261        self.datafile_multiplesasdata_multiplesasentry = find( 
     262            "test_data" + os.sep + "nxcansas_1Dand2D_multisasentry_multisasdata.h5") 
    260263 
    261264    def test_real_data(self): 
    … …  
    268271        self._check_multiple_data(self.data[0]) 
    269272        self._check_multiple_data(self.data[1]) 
    270         self._check_1d_data(self.data[0]) 
     273        if isinstance(self.data[0], Data1D): 
     274            self._check_1d_data(self.data[0]) 
     275            self._check_2d_data(self.data[1]) 
     276        else: 
     277            self._check_1d_data(self.data[1]) 
     278            self._check_2d_data(self.data[0]) 
     279 
     280    def test_multiple_sasdatas(self): 
     281        self.data = self.loader.load(self.datafile_multiplesasdata) 
     282        self.assertTrue(len(self.data) == 2) 
     283        self._check_multiple_data(self.data[0]) 
     284        self._check_multiple_data(self.data[1]) 
     285        if isinstance(self.data[0], Data1D): 
     286            self._check_1d_data(self.data[0]) 
     287            self._check_2d_data(self.data[1]) 
     288        else: 
     289            self._check_1d_data(self.data[1]) 
     290            self._check_2d_data(self.data[0]) 
     291 
     292    def test_multiple_sasentries_multiplesasdatas(self): 
     293        self.data = self.loader.load( 
     294            self.datafile_multiplesasdata_multiplesasentry) 
     295        self.assertTrue(len(self.data) == 4) 
     296        self._check_multiple_data(self.data[0]) 
     297        self._check_multiple_data(self.data[1]) 
     298        self._check_multiple_data(self.data[2]) 
     299        self._check_multiple_data(self.data[3]) 
     300        for data in self.data: 
     301            if isinstance(data, Data1D): 
     302                self._check_1d_data(data) 
     303            else: 
     304                self._check_2d_data(data) 
    271305 
    272306    def _check_multiple_data(self, data): 
    273         self.assertTrue(data.title == "MH4_5deg_16T_SLOW") 
    274         self.assertTrue(data.run[0] == '33837') 
    275         self.assertTrue(len(data.run) == 1) 
    276         self.assertTrue(data.instrument == "SANS2D") 
    277         self.assertTrue(data.source.radiation == "Spallation Neutron Source") 
    278         self.assertTrue(len(data.detector) == 1) 
    279         self.assertTrue(data.detector[0].name == "rear-detector") 
    280         self.assertTrue(data.detector[0].distance == 4.385281) 
    281         self.assertTrue(data.detector[0].distance_unit == 'm') 
    282         self.assertTrue(len(data.trans_spectrum) == 1) 
     307        self.assertEqual(data.title, "MH4_5deg_16T_SLOW") 
     308        self.assertEqual(data.run[0], '33837') 
     309        self.assertEqual(len(data.run), 1) 
     310        self.assertEqual(data.instrument, "SANS2D") 
     311        self.assertEqual(data.source.radiation, "Spallation Neutron Source") 
     312        self.assertEqual(len(data.detector), 2) 
     313        self.assertTrue(data.detector[0].name == "rear-detector" 
     314                        or data.detector[1].name == "rear-detector") 
     315        self.assertTrue(data.detector[0].name == "front-detector" 
     316                        or data.detector[1].name == "front-detector") 
     317        self.assertAlmostEqual(data.detector[0].distance + 
     318                               data.detector[1].distance, 7230.54, 2) 
     319        self.assertEqual(data.detector[0].distance_unit, 'mm') 
     320        self.assertEqual(len(data.trans_spectrum), 1) 
    283321 
    284322    def _check_1d_data(self, data): 
    285         self.assertTrue(isinstance(data, Data1D)) 
    286         self.assertTrue(len(data.x) == 66) 
    287         self.assertTrue(len(data.x) == len(data.y)) 
    288         self.assertTrue(data.dy[10] == 0.20721350111248701) 
    289         self.assertTrue(data.y[10] == 24.193889608153476) 
    290         self.assertTrue(data.x[10] == 0.008981127988654792) 
     323        self.assertEqual(len(data.x), 66) 
     324        self.assertEqual(len(data.x), len(data.y)) 
     325        self.assertAlmostEqual(data.dy[10], 0.207214) 
     326        self.assertAlmostEqual(data.y[10], 24.1939) 
     327        self.assertAlmostEqual(data.x[10], 0.00898113) 
    291328 
    292329    def _check_2d_data(self, data): 
    293330        self.assertTrue(isinstance(data, Data2D)) 
    294         self.assertTrue(len(data.x) == 66) 
    295         self.assertTrue(len(data.x) == len(data.y)) 
    296         self.assertTrue(data.dy[10] == 0.20721350111248701) 
    297         self.assertTrue(data.y[10] == 24.193889608153476) 
    298         self.assertTrue(data.x[10] == 0.008981127988654792) 
     331        self.assertEqual(len(data.q_data), 150*150) 
     332        self.assertEqual(len(data.q_data), len(data.data)) 
     333        self.assertAlmostEqual(data.err_data[10], 0.186723989418) 
     334        self.assertAlmostEqual(data.data[10], 0.465181) 
     335        self.assertAlmostEqual(data.qx_data[10], -0.129) 
     336        self.assertAlmostEqual(data.qy_data[10], -0.149) 
    299337 
    300338    def _check_example_data(self, data): 
    301         self.assertTrue(data.title == "") 
    302         self.assertTrue(data.x.size == 100) 
    303         self.assertTrue(data._xunit == "A^{-1}") 
    304         self.assertTrue(data._yunit == "cm^{-1}") 
    305         self.assertTrue(data.y.size == 100) 
     339        self.assertEqual(data.title, "") 
     340        self.assertEqual(data.x.size, 100) 
     341        self.assertEqual(data._xunit, "A^{-1}") 
     342        self.assertEqual(data._yunit, "cm^{-1}") 
     343        self.assertEqual(data.y.size, 100) 
    306344        self.assertAlmostEqual(data.y[40], 0.952749011516985) 
    307345        self.assertAlmostEqual(data.x[40], 0.3834415188257777) 

  • 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

    rbeba407 rf4e2f22  
    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.assertEqual(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" + os.sep + "TestExtensions") 
     54        not_xml = find("test_data" + os.sep + "TestExtensions.notxml") 
     55        # Deprecated extensions 
     56        asc_dep = find("test_data" + os.sep + "TestExtensions.asc") 
     57        nxs_dep = find("test_data" + os.sep + "TestExtensions.nxs") 
     58        # Native extension as a baseline 
     59        xml_native = find("test_data" + os.sep + "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.assertEqual(len(asc_load[0].errors), 1) 
     73        self.assertEqual(len(nxs_load[0].errors), 1) 
     74 
     75    def check_unknown_extension(self, data): 
     76        self.assertTrue(isinstance(data, Data1D)) 
     77        self.assertEqual(len(data.x), 138) 
     78        self.assertEqual(data.sample.ID, "TK49 c10_SANS") 
     79        self.assertEqual(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 rfc51d06  
    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) 
    2532        self.assertEqual(f.qx_data[36863],0.2908819) 
    26         self.assertEqual(f.Q_unit, '1/A') 
    27         self.assertEqual(f.I_unit, '1/cm') 
     33        self.assertEqual(f.Q_unit, 'A^{-1}') 
     34        self.assertEqual(f.I_unit, 'cm^{-1}') 
    2835 
    2936        self.assertEqual(f.meta_data['loader'],"IGOR/DAT 2D Q_map") 

  • test/sasdataloader/test/utest_sesans.py

    ra78a02f rf4e2f22  
    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" + os.sep + 
     28                                  "sphere2micron.ses")) 
    2229        f = file[0] 
    2330        # self.assertEqual(f, 5) 
     31        self.assertEqual(len(file), 1) 
    2432        self.assertEqual(len(f.x), 40) 
    2533        self.assertEqual(f.x[0], 391.56) 
    … …  
    3745            Test .SES loading on a TOF dataset 
    3846        """ 
    39         file = self.loader("sesans_examples/sphere_isis.ses") 
     47        file = self.loader(find("sesans_examples" + os.sep + "sphere_isis.ses")) 
    4048        f = file[0] 
     49        self.assertEqual(len(file), 1) 
    4150        self.assertEqual(len(f.x), 57) 
    4251        self.assertEqual(f.x[-1], 19303.4) 
    … …  
    5463            FileContentsException, 
    5564            self.loader, 
    56             "sesans_examples/sesans_no_data.ses") 
     65            find("sesans_examples" + os.sep + "sesans_no_data.ses")) 
    5766 
    5867    def test_sesans_no_spin_echo_unit(self): 
    … …  
    6372            FileContentsException, 
    6473            self.loader, 
    65             "sesans_examples/no_spin_echo_unit.ses") 
     74            find("sesans_examples" + os.sep + "no_spin_echo_unit.ses")) 
    6675 
    6776    def test_sesans_future_version(self): 
    … …  
    7281            FileContentsException, 
    7382            self.loader, 
    74             "sesans_examples/next_gen.ses") 
     83            find("sesans_examples" + os.sep + "next_gen.ses")) 
    7584 
    7685    def test_sesans_mandatory_headers(self): 
    … …  
    8190            FileContentsException, 
    8291            self.loader, 
    83             "sesans_examples/no_wavelength.ses") 
     92            find("sesans_examples" + os.sep + "no_wavelength.ses")) 
    8493 
    8594    def test_sesans_columns_match_headers(self): 
    … …  
    9099            FileContentsException, 
    91100            self.loader, 
    92             "sesans_examples/too_many_headers.ses") 
     101            find("sesans_examples" + os.sep + "too_many_headers.ses")) 
    93102 
    94103if __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.