Changeset 8c9e65c in sasview for test


Ignore:
Timestamp:
Mar 5, 2019 1:52:24 PM (6 years ago)
Author:
GitHub <noreply@…>
Branches:
master, magnetic_scatt, release-4.2.2, ticket-1009, ticket-1094-headless, ticket-1242-2d-resolution, ticket-1249
Children:
f205d3a, 1342f6a
Parents:
0a924c6 (diff), 4cbb2f5 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
git-author:
Paul Kienzle <pkienzle@…> (03/05/19 13:52:24)
git-committer:
GitHub <noreply@…> (03/05/19 13:52:24)
Message:

py37 support for sascalc. Refs #888 an #1233.

Location:
test
Files:
3 added
3 deleted
14 edited
8 moved

Legend:

Unmodified
Added
Removed

  • test/calculatorview/test/utest_gui_sld.py

    r959eb01 r88d2e70  
    3333        self.sld_frame.panel.ProcessEvent(clickEvent) 
    3434        bkg = self.sld_frame.panel.compound_ctl.GetBackgroundColour() 
    35         self.assert_(bkg.GetAsString() == 'pink') 
     35        self.assertTrue(bkg.GetAsString() == 'pink') 
    3636        #compute invariant without entering a value for compound 
    3737        self.sld_frame.panel.compound_ctl.SetValue("") 
    … …  
    3939        self.sld_frame.panel.ProcessEvent(clickEvent) 
    4040        bkg = self.sld_frame.panel.compound_ctl.GetBackgroundColour() 
    41         self.assert_(bkg.GetAsString() == 'pink') 
     41        self.assertTrue(bkg.GetAsString() == 'pink') 
    4242        #compute invariant without entering a value for compound 
    4343        self.sld_frame.panel.compound_ctl.SetValue("H2O") 
    … …  
    4545        self.sld_frame.panel.ProcessEvent(clickEvent) 
    4646        bkg = self.sld_frame.panel.compound_ctl.GetBackgroundColour() 
    47         self.assert_(bkg.GetAsString() == 'white') 
     47        self.assertTrue(bkg.GetAsString() == 'white') 
    4848        
    4949    def testDensityTextCtrl(self): 
    … …  
    5959        self.sld_frame.panel.ProcessEvent(clickEvent) 
    6060        bkg = self.sld_frame.panel.density_ctl.GetBackgroundColour() 
    61         self.assert_(bkg.GetAsString() == 'pink') 
     61        self.assertTrue(bkg.GetAsString() == 'pink') 
    6262        #compute invariant without entering a value for density 
    6363        self.sld_frame.panel.compound_ctl.SetValue("H2O") 
    … …  
    6565        self.sld_frame.panel.ProcessEvent(clickEvent) 
    6666        bkg = self.sld_frame.panel.density_ctl.GetBackgroundColour() 
    67         self.assert_(bkg.GetAsString() == 'pink') 
     67        self.assertTrue(bkg.GetAsString() == 'pink') 
    6868        #compute invariant without entering a value for density 
    6969        self.sld_frame.panel.compound_ctl.SetValue("H2O") 
    … …  
    7171        self.sld_frame.panel.ProcessEvent(clickEvent) 
    7272        bkg = self.sld_frame.panel.density_ctl.GetBackgroundColour() 
    73         self.assert_(bkg.GetAsString() == 'white') 
     73        self.assertTrue(bkg.GetAsString() == 'white') 
    7474         
    7575    def testWavelengthTextCtrl(self): 
    … …  
    8686        self.sld_frame.panel.ProcessEvent(clickEvent) 
    8787        bkg = self.sld_frame.panel.wavelength_ctl.GetBackgroundColour() 
    88         self.assert_(bkg.GetAsString() == 'pink') 
     88        self.assertTrue(bkg.GetAsString() == 'pink') 
    8989        #compute invariant without entering a value for wavelegnth 
    9090        self.sld_frame.panel.compound_ctl.SetValue("H2O") 
    … …  
    9393        self.sld_frame.panel.ProcessEvent(clickEvent) 
    9494        cp_bkg = self.sld_frame.panel.compound_ctl.GetBackgroundColour() 
    95         self.assert_(cp_bkg.GetAsString() == 'white') 
     95        self.assertTrue(cp_bkg.GetAsString() == 'white') 
    9696        ds_bkg = self.sld_frame.panel.density_ctl.GetBackgroundColour() 
    97         self.assert_(ds_bkg.GetAsString() == 'white') 
     97        self.assertTrue(ds_bkg.GetAsString() == 'white') 
    9898        wv_bkg = self.sld_frame.panel.wavelength_ctl.GetBackgroundColour() 
    9999        value = self.sld_frame.panel.wavelength_ctl.GetValue() 
    100         self.assert_(wv_bkg.GetAsString() == 'white') 
    101         self.assert_(float(value) == WAVELENGTH) 
     100        self.assertTrue(wv_bkg.GetAsString() == 'white') 
     101        self.assertTrue(float(value) == WAVELENGTH) 
    102102        sld_real = self.sld_frame.panel.neutron_sld_real_ctl.GetValue() 
    103103        sld_im = self.sld_frame.panel.neutron_sld_im_ctl.GetValue() 
    … …  
    110110        length = self.sld_frame.panel.neutron_length_ctl.GetValue() 
    111111         
    112         self.assertAlmostEquals(float(sld_real), 1.04e-6, 1) 
    113         self.assertAlmostEquals(float(sld_im), -1.5e-7, 1) 
     112        self.assertAlmostEqual(float(sld_real), 1.04e-6, 1) 
     113        self.assertAlmostEqual(float(sld_im), -1.5e-7, 1) 
    114114        #test absorption value 
    115         self.assertAlmostEquals(float(abs) , 0.0741, 2) 
    116         self.assertAlmostEquals(float(incoh), 5.62, 2) 
     115        self.assertAlmostEqual(float(abs) , 0.0741, 2) 
     116        self.assertAlmostEqual(float(incoh), 5.62, 2) 
    117117        #Test length 
    118         self.assertAlmostEquals(float(length), 0.1755, 2) 
     118        self.assertAlmostEqual(float(length), 0.1755, 2) 
    119119        #test Cu sld 
    120         self.assertAlmostEquals(float(cu_real), 9.46e-6, 1) 
    121         self.assertAlmostEquals(float(cu_im), 3.01e-8) 
     120        self.assertAlmostEqual(float(cu_real), 9.46e-6, 1) 
     121        self.assertAlmostEqual(float(cu_im), 3.01e-8) 
    122122        # test Mo sld 
    123         self.assertAlmostEquals(float(mo_real), 9.43e-6) 
    124         self.assertAlmostEquals(float(mo_im), 5.65e-7, 1) 
     123        self.assertAlmostEqual(float(mo_real), 9.43e-6) 
     124        self.assertAlmostEqual(float(mo_im), 5.65e-7, 1) 
    125125        #compute invariant with all correct inputs value 
    126126        self.sld_frame.panel.compound_ctl.SetValue("H2O") 
    … …  
    130130        bkg = self.sld_frame.panel.wavelength_ctl.GetBackgroundColour() 
    131131        value = self.sld_frame.panel.wavelength_ctl.GetValue() 
    132         self.assert_(bkg.GetAsString() == 'white') 
    133         self.assert_(float(value) == WAVELENGTH/2) 
     132        self.assertTrue(bkg.GetAsString() == 'white') 
     133        self.assertTrue(float(value) == WAVELENGTH/2) 
    134134         
    135135    def testSomeCombination(self): 
    … …  
    145145        self.sld_frame.panel.ProcessEvent(clickEvent) 
    146146        cp_bkg = self.sld_frame.panel.compound_ctl.GetBackgroundColour() 
    147         self.assert_(cp_bkg.GetAsString() == 'white') 
     147        self.assertTrue(cp_bkg.GetAsString() == 'white') 
    148148        ds_bkg = self.sld_frame.panel.density_ctl.GetBackgroundColour() 
    149         self.assert_(ds_bkg.GetAsString() == 'white') 
     149        self.assertTrue(ds_bkg.GetAsString() == 'white') 
    150150        wv_bkg = self.sld_frame.panel.wavelength_ctl.GetBackgroundColour() 
    151         self.assert_(wv_bkg.GetAsString() == 'pink') 
     151        self.assertTrue(wv_bkg.GetAsString() == 'pink') 
    152152        #density, wavelength is invalid 
    153153        self.sld_frame.panel.compound_ctl.SetValue("H2O") 
    … …  
    158158        self.sld_frame.panel.ProcessEvent(clickEvent) 
    159159        cp_bkg = self.sld_frame.panel.compound_ctl.GetBackgroundColour() 
    160         self.assert_(cp_bkg.GetAsString() == 'white') 
     160        self.assertTrue(cp_bkg.GetAsString() == 'white') 
    161161        ds_bkg = self.sld_frame.panel.density_ctl.GetBackgroundColour() 
    162         self.assert_(ds_bkg.GetAsString() == 'pink') 
     162        self.assertTrue(ds_bkg.GetAsString() == 'pink') 
    163163        wv_bkg = self.sld_frame.panel.wavelength_ctl.GetBackgroundColour() 
    164         self.assert_(wv_bkg.GetAsString() == 'pink') 
     164        self.assertTrue(wv_bkg.GetAsString() == 'pink') 
    165165        #density, wavelength is invalid 
    166166        self.sld_frame.panel.compound_ctl.SetValue("invalid compound") 
    … …  
    171171        self.sld_frame.panel.ProcessEvent(clickEvent) 
    172172        cp_bkg = self.sld_frame.panel.compound_ctl.GetBackgroundColour() 
    173         self.assert_(cp_bkg.GetAsString() == 'pink') 
     173        self.assertTrue(cp_bkg.GetAsString() == 'pink') 
    174174        ds_bkg = self.sld_frame.panel.density_ctl.GetBackgroundColour() 
    175         self.assert_(ds_bkg.GetAsString() == 'pink') 
     175        self.assertTrue(ds_bkg.GetAsString() == 'pink') 
    176176        wv_bkg = self.sld_frame.panel.wavelength_ctl.GetBackgroundColour() 
    177         self.assert_(wv_bkg.GetAsString() == 'white') 
     177        self.assertTrue(wv_bkg.GetAsString() == 'white') 
    178178        value = self.sld_frame.panel.wavelength_ctl.GetValue() 
    179         self.assert_(float(value) == WAVELENGTH) 
     179        self.assertTrue(float(value) == WAVELENGTH) 
    180180 
    181181         

  • test/pr_inversion/test/utest_explorer.py

    rf53d684 r1852b17  
    33""" 
    44 
     5import sys 
    56import os.path 
    67import unittest, math, numpy 
    7 from utest_invertor import load 
    88from sas.sascalc.pr.invertor import Invertor 
    99from sas.sascalc.pr.distance_explorer import DistExplorer 
    1010 
     11try: 
     12    from utest_invertor import load 
     13except ImportError: 
     14    from .utest_invertor import load 
    1115 
    1216def find(filename): 
    … …  
    3640        self.assertEqual(len(results.errors), 0) 
    3741        self.assertEqual(len(results.chi2), 25) 
    38          
     42 
    3943if __name__ == '__main__': 
    4044    unittest.main() 

  • test/sascalculator/test/utest_sld.py

    ra50da82 r88d2e70  
    5151                                  molecule_formula=self.sld_formula) 
    5252        #test sld 
    53         self.assertAlmostEquals(sld_real * _SCALE, -5.6e-7, 1) 
    54         self.assertAlmostEquals(sld_im * _SCALE, 0) 
     53        self.assertAlmostEqual(sld_real * _SCALE, -5.6e-7, 1) 
     54        self.assertAlmostEqual(sld_im * _SCALE, 0) 
    5555        #test absorption value 
    56         self.assertAlmostEquals(abs, 0.0741, 2) 
    57         self.assertAlmostEquals(incoh, 5.62, 2) 
     56        self.assertAlmostEqual(abs, 0.0741, 2) 
     57        self.assertAlmostEqual(incoh, 5.62, 2) 
    5858        #Test length 
    59         self.assertAlmostEquals(length, 0.1755, 3) 
     59        self.assertAlmostEqual(length, 0.1755, 3) 
    6060        #test Cu sld 
    61         self.assertAlmostEquals(cu_real * _SCALE, 9.46e-6, 1) 
    62         self.assertAlmostEquals(cu_im * _SCALE, 3.01e-8) 
     61        self.assertAlmostEqual(cu_real * _SCALE, 9.46e-6, 1) 
     62        self.assertAlmostEqual(cu_im * _SCALE, 3.01e-8) 
    6363        # test Mo sld 
    64         self.assertAlmostEquals(mo_real * _SCALE, 9.43e-6) 
    65         self.assertAlmostEquals(mo_im * _SCALE, 5.65e-7,1) 
     64        self.assertAlmostEqual(mo_real * _SCALE, 9.43e-6) 
     65        self.assertAlmostEqual(mo_im * _SCALE, 5.65e-7,1) 
    6666 
    6767 
    … …  
    9191                                  molecule_formula=self.sld_formula) 
    9292        #test sld 
    93         self.assertAlmostEquals(sld_real * _SCALE, 6.33e-6, 1) 
    94         self.assertAlmostEquals(sld_im * _SCALE, 0) 
     93        self.assertAlmostEqual(sld_real * _SCALE, 6.33e-6, 1) 
     94        self.assertAlmostEqual(sld_im * _SCALE, 0) 
    9595        #test absorption value 
    96         self.assertAlmostEquals(abs, 1.35e-4, 2) 
    97         self.assertAlmostEquals(incoh, 0.138, 2) 
     96        self.assertAlmostEqual(abs, 1.35e-4, 2) 
     97        self.assertAlmostEqual(incoh, 0.138, 2) 
    9898        #Test length 
    99         self.assertAlmostEquals(length, 1.549, 3) 
     99        self.assertAlmostEqual(length, 1.549, 3) 
    100100        #test Cu sld 
    101         self.assertAlmostEquals(cu_real * _SCALE, 9.36e-6, 1) 
    102         self.assertAlmostEquals(cu_im * _SCALE, 2.98e-8) 
     101        self.assertAlmostEqual(cu_real * _SCALE, 9.36e-6, 1) 
     102        self.assertAlmostEqual(cu_im * _SCALE, 2.98e-8) 
    103103        # test Mo sld 
    104         self.assertAlmostEquals(mo_real * _SCALE, 9.33e-6) 
    105         self.assertAlmostEquals(mo_im * _SCALE, 5.59e-9,1) 
     104        self.assertAlmostEqual(mo_real * _SCALE, 9.33e-6) 
     105        self.assertAlmostEqual(mo_im * _SCALE, 5.59e-9,1) 
    106106 
    107107 
    … …  
    131131                                  molecule_formula=self.sld_formula) 
    132132        #test sld 
    133         self.assertAlmostEquals(sld_real * _SCALE, 1.04e-6, 1) 
    134         self.assertAlmostEquals(sld_im * _SCALE, -1.5e-7, 1) 
     133        self.assertAlmostEqual(sld_real * _SCALE, 1.04e-6, 1) 
     134        self.assertAlmostEqual(sld_im * _SCALE, -1.5e-7, 1) 
    135135        #test absorption value 
    136         self.assertAlmostEquals(abs, 180.0,0) 
    137         self.assertAlmostEquals(incoh, 0.0754, 2) 
     136        self.assertAlmostEqual(abs, 180.0,0) 
     137        self.assertAlmostEqual(incoh, 0.0754, 2) 
    138138        #Test length 
    139         self.assertAlmostEquals(length, 0.005551, 4) 
     139        self.assertAlmostEqual(length, 0.005551, 4) 
    140140        #test Cu sld 
    141         self.assertAlmostEquals(cu_real * _SCALE, 2.89e-5, 1) 
    142         self.assertAlmostEquals(cu_im * _SCALE, 2.81e-6) 
     141        self.assertAlmostEqual(cu_real * _SCALE, 2.89e-5, 1) 
     142        self.assertAlmostEqual(cu_im * _SCALE, 2.81e-6) 
    143143        # test Mo sld 
    144         self.assertAlmostEquals(mo_real * _SCALE, 2.84e-5, 1) 
    145         self.assertAlmostEquals(mo_im * _SCALE, 7.26e-7,1) 
     144        self.assertAlmostEqual(mo_real * _SCALE, 2.84e-5, 1) 
     145        self.assertAlmostEqual(mo_im * _SCALE, 7.26e-7,1) 
    146146 
    147147if __name__ == '__main__': 

  • test/sasdataloader/plugins/test_reader.py

    raaf5e49 r88d2e70  
    4040                    input_f =  open(path,'r') 
    4141                except : 
    42                     raise  RuntimeError, "ascii_reader: cannot open %s" % path 
     42                    raise  RuntimeError("ascii_reader: cannot open %s" % path) 
    4343                buff = input_f.read() 
    4444                lines = buff.split('\n') 
    … …  
    5555                return output 
    5656        else: 
    57             raise RuntimeError, "%s is not a file" % path 
     57            raise RuntimeError("%s is not a file" % path) 
    5858        return None 
    5959     

  • test/sasdataloader/test/utest_abs_reader.py

    rd96744de r4cbb2f5  
    357357        self.assertEqual(self.data.dy[0], 3) 
    358358        self.assertEqual(self.data.x[1], 0.03) 
    359         self.assertAlmostEquals(self.data.y[1], 1001.0) 
     359        self.assertAlmostEqual(self.data.y[1], 1001.0) 
    360360        self.assertEqual(self.data.dxl[1], 0.005) 
    361361        self.assertEqual(self.data.dxw[1], 0.001) 

  • test/sasinvariant/test/utest_data_handling.py

    rf53d684 r88d2e70  
    4545 
    4646        # Test results 
    47         self.assertAlmostEquals(p[0], 1.0, 5) 
    48         self.assertAlmostEquals(p[1], 0.0, 5) 
     47        self.assertAlmostEqual(p[0], 1.0, 5) 
     48        self.assertAlmostEqual(p[1], 0.0, 5) 
    4949 
    5050    def test_fit_linear_data_with_noise(self): 
    … …  
    7474 
    7575        # Test results 
    76         self.assertAlmostEquals(p[0], 1.0, 5) 
    77         self.assertAlmostEquals(p[1], 0.0, 5) 
     76        self.assertAlmostEqual(p[0], 1.0, 5) 
     77        self.assertAlmostEqual(p[1], 0.0, 5) 
    7878 
    7979    def test_fit_linear_data_with_noise_and_fixed_par(self): 
    … …  
    506506        for i in range(len(self.data.x)): 
    507507            value  = math.fabs(test_y[i]-self.data.y[i])/self.data.y[i] 
    508             self.assert_(value < 0.001) 
     508            self.assertTrue(value < 0.001) 
    509509             
    510510class TestDataExtraLowSlitGuinier(unittest.TestCase): 
    … …  
    553553 
    554554        test_y = inv._low_extrapolation_function.evaluate_model(x=self.data.x[:inv._low_extrapolation_npts]) 
    555         self.assert_(len(test_y) == len(self.data.y[:inv._low_extrapolation_npts])) 
     555        self.assertTrue(len(test_y) == len(self.data.y[:inv._low_extrapolation_npts])) 
    556556         
    557557        for i in range(inv._low_extrapolation_npts): 
    558558            value  = math.fabs(test_y[i]-self.data.y[i])/self.data.y[i] 
    559             self.assert_(value < 0.001) 
     559            self.assertTrue(value < 0.001) 
    560560             
    561561    def test_low_data(self): 
    … …  
    589589                                               npts = inv._low_extrapolation_npts)  
    590590        test_y = data_in_range.y 
    591         self.assert_(len(test_y) == len(self.data.y[:inv._low_extrapolation_npts])) 
     591        self.assertTrue(len(test_y) == len(self.data.y[:inv._low_extrapolation_npts])) 
    592592        for i in range(inv._low_extrapolation_npts): 
    593593            value  = math.fabs(test_y[i]-self.data.y[i])/self.data.y[i] 
    594             self.assert_(value < 0.001)     
     594            self.assertTrue(value < 0.001) 
    595595        
    596596             
    … …  
    642642         
    643643        test_y = inv._high_extrapolation_function.evaluate_model(x=self.data.x[start: ]) 
    644         self.assert_(len(test_y) == len(self.data.y[start:])) 
     644        self.assertTrue(len(test_y) == len(self.data.y[start:])) 
    645645         
    646646        for i in range(len(self.data.x[start:])): 
    647647            value  = math.fabs(test_y[i]-self.data.y[start+i])/self.data.y[start+i] 
    648             self.assert_(value < 0.001) 
     648            self.assertTrue(value < 0.001) 
    649649             
    650650    def test_high_data(self): 
    … …  
    677677                                               npts = inv._high_extrapolation_npts)  
    678678        test_y = data_in_range.y 
    679         self.assert_(len(test_y) == len(self.data.y[start:])) 
     679        self.assertTrue(len(test_y) == len(self.data.y[start:])) 
    680680        temp = self.data.y[start:] 
    681681         
    682682        for i in range(len(self.data.x[start:])): 
    683683            value  = math.fabs(test_y[i]- temp[i])/temp[i] 
    684             self.assert_(value < 0.001)                 
     684            self.assertTrue(value < 0.001) 

  • test/sasinvariant/test/utest_use_cases.py

    rf53d684 r88d2e70  
    3939 
    4040        # Test results 
    41         self.assertAlmostEquals(p[0], 2.3983,3) 
    42         self.assertAlmostEquals(p[1], 0.87833,3) 
     41        self.assertAlmostEqual(p[0], 2.3983,3) 
     42        self.assertAlmostEqual(p[1], 0.87833,3) 
    4343 
    4444    def test_fit_line_data_fixed(self): 
    … …  
    5454 
    5555        # Test results 
    56         self.assertAlmostEquals(p[0], 4) 
    57         self.assertAlmostEquals(p[1], -4.0676,3) 
     56        self.assertAlmostEqual(p[0], 4) 
     57        self.assertAlmostEqual(p[1], -4.0676,3) 
    5858 
    5959 
    … …  
    7878 
    7979        # Test results 
    80         self.assertAlmostEquals(p[0], 2.4727,3) 
    81         self.assertAlmostEquals(p[1], 0.6,3) 
     80        self.assertAlmostEqual(p[0], 2.4727,3) 
     81        self.assertAlmostEqual(p[1], 0.6,3) 
    8282 
    8383    def test_fit_line_data_fixed_no_weight(self): 
    … …  
    9393 
    9494        # Test results 
    95         self.assertAlmostEquals(p[0], 4) 
    96         self.assertAlmostEquals(p[1], -7.8,3) 
     95        self.assertAlmostEqual(p[0], 4) 
     96        self.assertAlmostEqual(p[1], -7.8,3) 
    9797 
    9898 
    … …  
    132132 
    133133        # Test results 
    134         self.assertAlmostEquals(qstar, 7.48959e-5,2) 
    135         self.assertAlmostEquals(v, 0.005644689, 4) 
    136         self.assertAlmostEquals(s , 941.7452, 3) 
     134        self.assertAlmostEqual(qstar, 7.48959e-5,2) 
     135        self.assertAlmostEqual(v, 0.005644689, 4) 
     136        self.assertAlmostEqual(s , 941.7452, 3) 
    137137 
    138138    def test_use_case_2(self): 
    … …  
    153153        s, ds = inv.get_surface_with_error(contrast=2.6e-6, porod_const=2) 
    154154        # Test results 
    155         self.assertAlmostEquals(qstar, 7.48959e-5,2) 
    156         self.assertAlmostEquals(v, 0.005644689, 1) 
    157         self.assertAlmostEquals(s , 941.7452, 3) 
     155        self.assertAlmostEqual(qstar, 7.48959e-5,2) 
     156        self.assertAlmostEqual(v, 0.005644689, 1) 
     157        self.assertAlmostEqual(s , 941.7452, 3) 
    158158 
    159159    def test_use_case_3(self): 
    … …  
    190190 
    191191        # Test results 
    192         self.assertAlmostEquals(qstar, 7.49e-5, 1) 
    193         self.assertAlmostEquals(v, 0.005648401, 4) 
    194         self.assertAlmostEquals(s , 941.7452, 3) 
     192        self.assertAlmostEqual(qstar, 7.49e-5, 1) 
     193        self.assertAlmostEqual(v, 0.005648401, 4) 
     194        self.assertAlmostEqual(s , 941.7452, 3) 
    195195 
    196196    def test_use_case_4(self): 
    … …  
    218218 
    219219        # Test results 
    220         self.assertAlmostEquals(qstar, 7.49e-5,2) 
    221         self.assertAlmostEquals(v, 0.005952674, 3) 
    222         self.assertAlmostEquals(s , 941.7452, 3) 
     220        self.assertAlmostEqual(qstar, 7.49e-5,2) 
     221        self.assertAlmostEqual(v, 0.005952674, 3) 
     222        self.assertAlmostEqual(s , 941.7452, 3) 
    223223 
    224224    def test_use_case_5(self): 
    … …  
    247247 
    248248        # Test results 
    249         self.assertAlmostEquals(qstar, 7.88981e-5,2) 
    250         self.assertAlmostEquals(v, 0.005952674, 3) 
    251         self.assertAlmostEquals(s , 941.7452, 3) 
     249        self.assertAlmostEqual(qstar, 7.88981e-5,2) 
     250        self.assertAlmostEqual(v, 0.005952674, 3) 
     251        self.assertAlmostEqual(s , 941.7452, 3) 
    252252 
    253253    def test_use_case_6(self): 
    … …  
    273273 
    274274        # Test results 
    275         self.assertAlmostEquals(qstar, 7.49e-5,2) 
    276         self.assertAlmostEquals(v, 0.005952674, 3) 
    277         self.assertAlmostEquals(s , 941.7452, 3) 
     275        self.assertAlmostEqual(qstar, 7.49e-5,2) 
     276        self.assertAlmostEqual(v, 0.005952674, 3) 
     277        self.assertAlmostEqual(s , 941.7452, 3) 
    278278 
    279279 
    … …  
    297297        s = inv.get_surface(contrast=2.6e-6, porod_const=2) 
    298298        # Test results 
    299         self.assertAlmostEquals(qstar, 1.361677e-3, 4) 
    300         self.assertAlmostEquals(v, 0.115352622, 2) 
    301         self.assertAlmostEquals(s , 941.7452, 3 ) 
     299        self.assertAlmostEqual(qstar, 1.361677e-3, 4) 
     300        self.assertAlmostEqual(v, 0.115352622, 2) 
     301        self.assertAlmostEqual(s , 941.7452, 3 ) 
    302302 
    303303    def test_use_case_2(self): 
    … …  
    315315        s, ds = inv.get_surface_with_error(contrast=2.6e-6, porod_const=2) 
    316316        # Test results 
    317         self.assertAlmostEquals(qstar, 1.361677e-3, 4) 
    318         self.assertAlmostEquals(v, 0.115352622, 2) 
    319         self.assertAlmostEquals(s , 941.7452, 3 ) 
     317        self.assertAlmostEqual(qstar, 1.361677e-3, 4) 
     318        self.assertAlmostEqual(v, 0.115352622, 2) 
     319        self.assertAlmostEqual(s , 941.7452, 3 ) 
    320320 
    321321    def test_use_case_3(self): 
    … …  
    336336 
    337337        # Test results 
    338         self.assertAlmostEquals(qstar, 0.00138756,2) 
    339         self.assertAlmostEquals(v, 0.117226896,2) 
    340         self.assertAlmostEquals(s ,941.7452, 3) 
     338        self.assertAlmostEqual(qstar, 0.00138756,2) 
     339        self.assertAlmostEqual(v, 0.117226896,2) 
     340        self.assertAlmostEqual(s ,941.7452, 3) 
    341341 
    342342    def test_use_case_4(self): 
    … …  
    354354 
    355355        # Test results 
    356         self.assertAlmostEquals(qstar, 0.0045773,2) 
     356        self.assertAlmostEqual(qstar, 0.0045773,2) 
    357357 
    358358    def test_use_case_5(self): 
    … …  
    374374 
    375375        # Test results 
    376         self.assertAlmostEquals(qstar, 0.00460319,3) 
     376        self.assertAlmostEqual(qstar, 0.00460319,3) 
    377377       
    378378   

  • test/sasrealspace/test/utest_oriented.py

    r1cdbcd8 r88d2e70  
    5959        ana_val = self.ana.runXY([0.1, 0.1]) 
    6060        sim_val = self.model.getIq2D(0.1, 0.1) 
    61         self.assert_( math.fabs(sim_val/ana_val-1.0)<0.1 ) 
     61        self.assertTrue( math.fabs(sim_val/ana_val-1.0)<0.1 ) 
    6262 
    6363class TestCylinderAddObject(unittest.TestCase): 
    … …  
    101101        #print ana_val, sim_val, sim_val/ana_val 
    102102 
    103         self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
     103        self.assertTrue( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
    104104 
    105105 
    … …  
    143143        #print ana_val, sim_val, sim_val/ana_val 
    144144 
    145         self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
     145        self.assertTrue( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
    146146 
    147147    def testalongZ(self): 
    … …  
    156156        #print ana_val, sim_val, sim_val/ana_val 
    157157 
    158         self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
     158        self.assertTrue( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
    159159 
    160160    def testalongX(self): 
    … …  
    169169        #print ana_val, sim_val, sim_val/ana_val 
    170170 
    171         self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
     171        self.assertTrue( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
    172172 
    173173class TestEllipsoid(unittest.TestCase): 
    … …  
    213213        #print ana_val, sim_val, sim_val/ana_val 
    214214 
    215         self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
     215        self.assertTrue( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
    216216 
    217217    def testalongZ(self): 
    … …  
    226226        #print ana_val, sim_val, sim_val/ana_val 
    227227 
    228         self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
     228        self.assertTrue( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
    229229 
    230230    def testalongY(self): 
    … …  
    240240 
    241241        try: 
    242             self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
     242            self.assertTrue( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
    243243        except Exception: 
    244244            print("Error", ana_val, sim_val, sim_val/ana_val) 
    … …  
    295295        sim_val, err = self.canvas.getIq2DError(0.1, 0.2) 
    296296 
    297         self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
     297        self.assertTrue( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
    298298 
    299299class TestCoreShellError(unittest.TestCase): 
    … …  
    347347        sim_val, err = self.canvas.getIq2DError(0.1, 0.2) 
    348348 
    349         self.assert_( math.fabs(sim_val-ana_val) < 3.0 * err ) 
     349        self.assertTrue( math.fabs(sim_val-ana_val) < 3.0 * err ) 
    350350 
    351351class TestRunMethods(unittest.TestCase): 
    … …  
    392392 
    393393        try: 
    394             self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
     394            self.assertTrue( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
    395395        except Exception: 
    396396            print("Error", ana_val, sim_val, sim_val/ana_val) 
    … …  
    404404 
    405405        try: 
    406             self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
     406            self.assertTrue( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
    407407        except Exception: 
    408408            print("Error", ana_val, sim_val, sim_val/ana_val) 
    … …  
    416416 
    417417        try: 
    418             self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
     418            self.assertTrue( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
    419419        except Exception: 
    420420            print("Error", ana_val, sim_val, sim_val/ana_val) 
    … …  
    428428 
    429429        try: 
    430             self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
     430            self.assertTrue( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
    431431        except Exception: 
    432432            print("Error", ana_val, sim_val, sim_val/ana_val) 
    … …  
    471471        sim_val = self.model.getIq2D(0.1, 0.2) 
    472472 
    473         self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
     473        self.assertTrue( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
    474474 
    475475        # Change the radius a re-evaluate 
    … …  
    479479        ana_val = self.ana.runXY([0.1, 0.2]) 
    480480        sim_val = self.model.getIq2D(0.1, 0.2) 
    481         self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
     481        self.assertTrue( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
    482482 
    483483 

  • test/sasrealspace/test/utest_realspace.py

    r1cdbcd8 r88d2e70  
    3838        self.model.add('ellipsoid','elli2') 
    3939        self.model.delete('elli2') 
    40         self.assert_('elli2' not in self.model.getShapeList()) 
     40        self.assertTrue('elli2' not in self.model.getShapeList()) 
    4141 
    4242    def testsetParam(self): 
    … …  
    8181        value_2 = self.canvas.getIq(0.001) 
    8282 
    83         self.assert_( (value_1-value_2)/value_1 < 0.1) 
     83        self.assertTrue( (value_1-value_2)/value_1 < 0.1) 
    8484 
    8585    def testSetDensityTiming(self): 
    … …  
    9999        t_2 = time.time()-t_0 
    100100 
    101         self.assert_( t_2 < t_1 and (t_1-t_2)/t_2 > 2) 
     101        self.assertTrue( t_2 < t_1 and (t_1-t_2)/t_2 > 2) 
    102102 
    103103    def testGetParamList(self): 
    104104        """ Test GetParamList on empty canvas""" 
    105         self.assert_('lores_density' in self.canvas.getParamList()) 
     105        self.assertTrue('lores_density' in self.canvas.getParamList()) 
    106106        handle = self.canvas.add('sphere') 
    107107 
    … …  
    109109        """ Test GetParamList on filled canvas""" 
    110110        self.canvas.add('sphere') 
    111         self.assert_('lores_density' in self.canvas.getParamList()) 
     111        self.assertTrue('lores_density' in self.canvas.getParamList()) 
    112112 
    113113    def testAdd(self): 
    … …  
    151151        # THIS WILL DEPEND ON THE NUMBER OF SPACE POINTS: 
    152152        # that why we need some error analysis. 
    153         self.assert_( (sim_2*ana_1/sim_1 - ana_2)/ana_2 < 0.1) 
     153        self.assertTrue( (sim_2*ana_1/sim_1 - ana_2)/ana_2 < 0.1) 
    154154 
    155155        # test the absolute amplitude 
    156         self.assert_( math.fabs(sim_2-ana_2)/ana_2 < 0.1) 
     156        self.assertTrue( math.fabs(sim_2-ana_2)/ana_2 < 0.1) 
    157157 
    158158    def testGetIq2(self): 
    … …  
    196196        sim_2 = self.canvas.getIq(0.01) 
    197197 
    198         self.assert_((sim_2-sim_1)/sim_1<0.05) 
     198        self.assertTrue((sim_2-sim_1)/sim_1<0.05) 
    199199 
    200200    def testGetIq_time(self): 
    … …  
    216216        delta_2 = time.time()-t_0 
    217217 
    218         self.assert_((delta_2-delta_1)/delta_1<0.05) 
     218        self.assertTrue((delta_2-delta_1)/delta_1<0.05) 
    219219 
    220220 
    … …  
    342342        ana = self.sphere.run(0.05) 
    343343        val, err = self.canvas.getIqError(0.05) 
    344         self.assert_(math.fabs(ana-val)<2.0*err) 
     344        self.assertTrue(math.fabs(ana-val)<2.0*err) 
    345345 
    346346    def testRightOrder(self): 
    … …  
    350350        val, err = self.canvas.getIqError(0.05) 
    351351        #print 'right', ana, val, err 
    352         self.assert_(math.fabs(ana-val)/ana < 1.1) 
     352        self.assertTrue(math.fabs(ana-val)/ana < 1.1) 
    353353 
    354354    def testWrongOrder(self): 
    … …  
    365365        val, err = self.canvas.getIqError(0.05) 
    366366        #print 'wrong', ana, val, err 
    367         self.assert_(math.fabs(ana-val)/ana < 1.1) 
     367        self.assertTrue(math.fabs(ana-val)/ana < 1.1) 
    368368 
    369369 

  • 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_ascii.py

    rdb5196d r9fb4572  
    1010import unittest 
    1111from sas.sascalc.dataloader.loader import Loader 
     12from sas.sascalc.dataloader.data_info import Data2D 
    1213 
    1314 
    … …  
    121122            self.assertFalse(math.isnan(f_1d.y[i])) 
    122123            self.assertFalse(math.isnan(f_1d.dy[i])) 
     124        self.assertTrue(isinstance(f_2d, Data2D)) 
    123125        f_2d.data = f_2d.data.flatten() 
    124126        f_2d.qx_data = f_2d.qx_data.flatten() 

  • test/sasdataloader/test/utest_averaging.py

    rf53d684 rf4e2f22  
    106106 
    107107    def setUp(self): 
    108         filepath = find('MAR07232_rest.h5') 
     108        filepath = find('test_data' + os.sep + 'MAR07232_rest.h5') 
    109109        self.data_list = Loader().load(filepath) 
    110110        self.data = self.data_list[0] 
    … …  
    121121 
    122122        o = r(self.data) 
    123         filepath = find('ring_testdata.txt') 
     123        filepath = find('test_data' + os.sep + 'ring_testdata.txt') 
    124124        answer_list = Loader().load(filepath) 
    125125        answer = answer_list[0] 
    … …  
    142142        o = r(self.data) 
    143143 
    144         filepath = find('avg_testdata.txt') 
     144        filepath = find('test_data' + os.sep + 'avg_testdata.txt') 
    145145        answer = Loader().load(filepath)[0] 
    146146        for i in range(r.nbins_phi): 
    … …  
    158158        s, ds, npoints = r(self.data) 
    159159        self.assertAlmostEqual(s, 34.278990899999997, 4) 
    160         self.assertAlmostEqual(ds, 7.8007981835194293, 4) 
     160        self.assertAlmostEqual(ds, 8.237259999538685, 4) 
    161161        self.assertAlmostEqual(npoints, 324.0000, 4) 
    162162 
    … …  
    164164        s, ds = r(self.data) 
    165165        self.assertAlmostEqual(s, 0.10579935462962962, 4) 
    166         self.assertAlmostEqual(ds, 0.024076537603455028, 4) 
     166        self.assertAlmostEqual(ds, 0.02542364197388483, 4) 
    167167 
    168168    def test_slabX(self): 
    … …  
    177177        o = r(self.data) 
    178178 
    179         filepath = find('slabx_testdata.txt') 
     179        filepath = find('test_data' + os.sep + '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 = find('slaby_testdata.txt') 
     197        filepath = find('test_data' + os.sep + 'slaby_testdata.txt') 
    198198        answer = Loader().load(filepath)[0] 
    199199        for i in range(len(o.x)): 
    … …  
    221221        o = r(self.data) 
    222222 
    223         filepath = find('ring_testdata.txt') 
     223        filepath = find('test_data' + os.sep + 'ring_testdata.txt') 
    224224        answer = Loader().load(filepath)[0] 
    225225        for i in range(len(o.x)): 
    … …  
    238238        o = r(self.data) 
    239239 
    240         filepath = find('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 = find('sectorq_testdata.txt') 
     257        filepath = find('test_data' + os.sep + 'sectorq_testdata.txt') 
    258258        answer = Loader().load(filepath)[0] 
    259259        for i in range(len(o.x)): 

  • test/sasdataloader/test/utest_cansas.py

    rf53d684 rf4e2f22  
    9191        reader = XMLreader(self.xml_valid, self.schema_1_0) 
    9292        valid = reader.validate_xml() 
    93         if valid: 
    94             self.assertTrue(valid) 
    95         else: 
    96             self.assertFalse(valid) 
     93        self.assertTrue(valid) 
    9794 
    9895    def _check_data(self, data): 
    … …  
    193190    def test_save_cansas_v1_0(self): 
    194191        xmlreader = XMLreader(self.isis_1_0, self.schema_1_0) 
    195         valid = xmlreader.validate_xml() 
    196         self.assertTrue(valid) 
     192        self.assertTrue(xmlreader.validate_xml()) 
    197193        reader_generic = Loader() 
    198194        dataloader = reader_generic.load(self.isis_1_0) 
    … …  
    207203            return_data = reader2.read(self.write_1_0_filename) 
    208204            written_data = return_data[0] 
    209             XMLreader(self.write_1_0_filename, self.schema_1_0) 
    210             valid = xmlreader.validate_xml() 
    211             self.assertTrue(valid) 
     205            xmlreader = XMLreader(self.write_1_0_filename, self.schema_1_0) 
     206            self.assertTrue(xmlreader.validate_xml()) 
    212207            self._check_data(written_data) 
    213208        if os.path.isfile(self.write_1_0_filename): 
    … …  
    260255        self.loader = Loader() 
    261256        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") 
     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") 
    265263 
    266264    def test_real_data(self): 
    … …  
    273271        self._check_multiple_data(self.data[0]) 
    274272        self._check_multiple_data(self.data[1]) 
    275         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) 
    276305 
    277306    def _check_multiple_data(self, data): 
    278         self.assertTrue(data.title == "MH4_5deg_16T_SLOW") 
    279         self.assertTrue(data.run[0] == '33837') 
    280         self.assertTrue(len(data.run) == 1) 
    281         self.assertTrue(data.instrument == "SANS2D") 
    282         self.assertTrue(data.source.radiation == "Spallation Neutron Source") 
    283         self.assertTrue(len(data.detector) == 1) 
    284         self.assertTrue(data.detector[0].name == "rear-detector") 
    285         self.assertTrue(data.detector[0].distance == 4.385281) 
    286         self.assertTrue(data.detector[0].distance_unit == 'm') 
    287         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) 
    288321 
    289322    def _check_1d_data(self, data): 
    290         self.assertTrue(isinstance(data, Data1D)) 
    291         self.assertTrue(len(data.x) == 66) 
    292         self.assertTrue(len(data.x) == len(data.y)) 
    293         self.assertTrue(data.dy[10] == 0.20721350111248701) 
    294         self.assertTrue(data.y[10] == 24.193889608153476) 
    295         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) 
    296328 
    297329    def _check_2d_data(self, data): 
    298330        self.assertTrue(isinstance(data, Data2D)) 
    299         self.assertTrue(len(data.x) == 66) 
    300         self.assertTrue(len(data.x) == len(data.y)) 
    301         self.assertTrue(data.dy[10] == 0.20721350111248701) 
    302         self.assertTrue(data.y[10] == 24.193889608153476) 
    303         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) 
    304337 
    305338    def _check_example_data(self, data): 
    306         self.assertTrue(data.title == "") 
    307         self.assertTrue(data.x.size == 100) 
    308         self.assertTrue(data._xunit == "A^{-1}") 
    309         self.assertTrue(data._yunit == "cm^{-1}") 
    310         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) 
    311344        self.assertAlmostEqual(data.y[40], 0.952749011516985) 
    312345        self.assertAlmostEqual(data.x[40], 0.3834415188257777) 

  • test/sasdataloader/test/utest_red2d_reader.py

    rf53d684 rfc51d06  
    3131        self.assertEqual(f.qx_data[0],-0.03573497) 
    3232        self.assertEqual(f.qx_data[36863],0.2908819) 
    33         self.assertEqual(f.Q_unit, '1/A') 
    34         self.assertEqual(f.I_unit, '1/cm') 
     33        self.assertEqual(f.Q_unit, 'A^{-1}') 
     34        self.assertEqual(f.I_unit, 'cm^{-1}') 
    3535 
    3636        self.assertEqual(f.meta_data['loader'],"IGOR/DAT 2D Q_map") 

  • test/sasdataloader/test/utest_sesans.py

    rf53d684 rf4e2f22  
    2525            Test .SES in the full loader to make sure that the file type is correctly accepted 
    2626        """ 
    27         file = Loader().load(find("sesans_examples/sphere2micron.ses")) 
     27        file = Loader().load(find("sesans_examples" + os.sep + 
     28                                  "sphere2micron.ses")) 
    2829        f = file[0] 
    2930        # self.assertEqual(f, 5) 
    … …  
    4445            Test .SES loading on a TOF dataset 
    4546        """ 
    46         file = self.loader(find("sesans_examples/sphere_isis.ses")) 
     47        file = self.loader(find("sesans_examples" + os.sep + "sphere_isis.ses")) 
    4748        f = file[0] 
    4849        self.assertEqual(len(file), 1) 
    … …  
    6263            FileContentsException, 
    6364            self.loader, 
    64             find("sesans_examples/sesans_no_data.ses")) 
     65            find("sesans_examples" + os.sep + "sesans_no_data.ses")) 
    6566 
    6667    def test_sesans_no_spin_echo_unit(self): 
    … …  
    7172            FileContentsException, 
    7273            self.loader, 
    73             find("sesans_examples/no_spin_echo_unit.ses")) 
     74            find("sesans_examples" + os.sep + "no_spin_echo_unit.ses")) 
    7475 
    7576    def test_sesans_future_version(self): 
    … …  
    8081            FileContentsException, 
    8182            self.loader, 
    82             find("sesans_examples/next_gen.ses")) 
     83            find("sesans_examples" + os.sep + "next_gen.ses")) 
    8384 
    8485    def test_sesans_mandatory_headers(self): 
    … …  
    8990            FileContentsException, 
    9091            self.loader, 
    91             find("sesans_examples/no_wavelength.ses")) 
     92            find("sesans_examples" + os.sep + "no_wavelength.ses")) 
    9293 
    9394    def test_sesans_columns_match_headers(self): 
    … …  
    9899            FileContentsException, 
    99100            self.loader, 
    100             find("sesans_examples/too_many_headers.ses")) 
     101            find("sesans_examples" + os.sep + "too_many_headers.ses")) 
    101102 
    102103if __name__ == "__main__": 
Note: See TracChangeset for help on using the changeset viewer.