Changeset 88d2e70 in sasview


Ignore:
Timestamp:
Oct 11, 2018 2:03:40 PM (6 years ago)
Author:
Paul Kienzle <pkienzle@…>
Branches:
master, magnetic_scatt, release-4.2.2, ticket-1009, ticket-1094-headless, ticket-1242-2d-resolution, ticket-1249
Children:
7c4bb4d
Parents:
e090ba90
Message:

support for py37 in unit tests

Location:
test
Files:
10 edited

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 r88d2e70  
    55import os.path 
    66import unittest, math, numpy 
    7 from utest_invertor import load 
    87from sas.sascalc.pr.invertor import Invertor 
    98from sas.sascalc.pr.distance_explorer import DistExplorer 
     9from .utest_invertor import load 
    1010 
    1111 

  • 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

    rbd5c3b1 r88d2e70  
    8080        data_cor = Loader().load(find("sam14_cor.cor")) 
    8181        for i in range(0, len(data_abs) - 1): 
    82             self.assertEquals(data_abs.x[i], data_cor.x[i]) 
    83             self.assertEquals(data_abs.y[i], data_cor.y[i]) 
    84             self.assertEquals(data_abs.dxl[i], data_cor.dxl[i]) 
    85             self.assertEquals(data_abs.dxw[i], data_cor.dxw[i]) 
     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]) 
    8686            self.assertTrue(data_abs.dxl > 0) 
    8787 
    … …  
    358358        self.assertEqual(self.data.dy[0], 3) 
    359359        self.assertEqual(self.data.x[1], 0.03) 
    360         self.assertAlmostEquals(self.data.y[1], 1001.0) 
     360        self.assertAlmostEqual(self.data.y[1], 1001.0) 
    361361        self.assertEqual(self.data.dxl[1], 0.005) 
    362362        self.assertEqual(self.data.dxw[1], 0.001) 

  • test/sasdataloader/test/utest_generic_file_reader_class.py

    r4a8d55c r88d2e70  
    4545        last_f = f[0] 
    4646        if hasattr(last_f, "errors"): 
    47             self.assertEquals(len(last_f.errors), 1) 
     47            self.assertEqual(len(last_f.errors), 1) 
    4848        else: 
    4949            self.fail("Errors did not propogate to the file properly.") 
    … …  
    7070        self.check_unknown_extension(xml_load[0]) 
    7171        # Be sure the deprecation warning is passed with the file 
    72         self.assertEquals(len(asc_load[0].errors), 1) 
    73         self.assertEquals(len(nxs_load[0].errors), 1) 
     72        self.assertEqual(len(asc_load[0].errors), 1) 
     73        self.assertEqual(len(nxs_load[0].errors), 1) 
    7474 
    7575    def check_unknown_extension(self, data): 
    7676        self.assertTrue(isinstance(data, Data1D)) 
    77         self.assertEquals(len(data.x), 138) 
    78         self.assertEquals(data.sample.ID, "TK49 c10_SANS") 
    79         self.assertEquals(data.meta_data["loader"], "CanSAS XML 1D") 
     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") 
    8080 
    8181    def tearDown(self): 

  • 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 
Note: See TracChangeset for help on using the changeset viewer.