Index: test/calculatorview/test/utest_gui_sld.py
===================================================================
--- test/calculatorview/test/utest_gui_sld.py	(revision 959eb0181ad06828a748f04512f953aad5b31659)
+++ test/calculatorview/test/utest_gui_sld.py	(revision 88d2e70bb28d8f9c855c86d94ad8ddd63154277b)
@@ -33,5 +33,5 @@
         self.sld_frame.panel.ProcessEvent(clickEvent)
         bkg = self.sld_frame.panel.compound_ctl.GetBackgroundColour()
-        self.assert_(bkg.GetAsString() == 'pink')
+        self.assertTrue(bkg.GetAsString() == 'pink')
         #compute invariant without entering a value for compound
         self.sld_frame.panel.compound_ctl.SetValue("")
@@ -39,5 +39,5 @@
         self.sld_frame.panel.ProcessEvent(clickEvent)
         bkg = self.sld_frame.panel.compound_ctl.GetBackgroundColour()
-        self.assert_(bkg.GetAsString() == 'pink')
+        self.assertTrue(bkg.GetAsString() == 'pink')
         #compute invariant without entering a value for compound
         self.sld_frame.panel.compound_ctl.SetValue("H2O")
@@ -45,5 +45,5 @@
         self.sld_frame.panel.ProcessEvent(clickEvent)
         bkg = self.sld_frame.panel.compound_ctl.GetBackgroundColour()
-        self.assert_(bkg.GetAsString() == 'white')
+        self.assertTrue(bkg.GetAsString() == 'white')
        
     def testDensityTextCtrl(self):
@@ -59,5 +59,5 @@
         self.sld_frame.panel.ProcessEvent(clickEvent)
         bkg = self.sld_frame.panel.density_ctl.GetBackgroundColour()
-        self.assert_(bkg.GetAsString() == 'pink')
+        self.assertTrue(bkg.GetAsString() == 'pink')
         #compute invariant without entering a value for density
         self.sld_frame.panel.compound_ctl.SetValue("H2O")
@@ -65,5 +65,5 @@
         self.sld_frame.panel.ProcessEvent(clickEvent)
         bkg = self.sld_frame.panel.density_ctl.GetBackgroundColour()
-        self.assert_(bkg.GetAsString() == 'pink')
+        self.assertTrue(bkg.GetAsString() == 'pink')
         #compute invariant without entering a value for density
         self.sld_frame.panel.compound_ctl.SetValue("H2O")
@@ -71,5 +71,5 @@
         self.sld_frame.panel.ProcessEvent(clickEvent)
         bkg = self.sld_frame.panel.density_ctl.GetBackgroundColour()
-        self.assert_(bkg.GetAsString() == 'white')
+        self.assertTrue(bkg.GetAsString() == 'white')
         
     def testWavelengthTextCtrl(self):
@@ -86,5 +86,5 @@
         self.sld_frame.panel.ProcessEvent(clickEvent)
         bkg = self.sld_frame.panel.wavelength_ctl.GetBackgroundColour()
-        self.assert_(bkg.GetAsString() == 'pink')
+        self.assertTrue(bkg.GetAsString() == 'pink')
         #compute invariant without entering a value for wavelegnth
         self.sld_frame.panel.compound_ctl.SetValue("H2O")
@@ -93,11 +93,11 @@
         self.sld_frame.panel.ProcessEvent(clickEvent)
         cp_bkg = self.sld_frame.panel.compound_ctl.GetBackgroundColour()
-        self.assert_(cp_bkg.GetAsString() == 'white')
+        self.assertTrue(cp_bkg.GetAsString() == 'white')
         ds_bkg = self.sld_frame.panel.density_ctl.GetBackgroundColour()
-        self.assert_(ds_bkg.GetAsString() == 'white')
+        self.assertTrue(ds_bkg.GetAsString() == 'white')
         wv_bkg = self.sld_frame.panel.wavelength_ctl.GetBackgroundColour()
         value = self.sld_frame.panel.wavelength_ctl.GetValue()
-        self.assert_(wv_bkg.GetAsString() == 'white')
-        self.assert_(float(value) == WAVELENGTH)
+        self.assertTrue(wv_bkg.GetAsString() == 'white')
+        self.assertTrue(float(value) == WAVELENGTH)
         sld_real = self.sld_frame.panel.neutron_sld_real_ctl.GetValue()
         sld_im = self.sld_frame.panel.neutron_sld_im_ctl.GetValue()
@@ -110,17 +110,17 @@
         length = self.sld_frame.panel.neutron_length_ctl.GetValue()
         
-        self.assertAlmostEquals(float(sld_real), 1.04e-6, 1)
-        self.assertAlmostEquals(float(sld_im), -1.5e-7, 1)
+        self.assertAlmostEqual(float(sld_real), 1.04e-6, 1)
+        self.assertAlmostEqual(float(sld_im), -1.5e-7, 1)
         #test absorption value
-        self.assertAlmostEquals(float(abs) , 0.0741, 2)
-        self.assertAlmostEquals(float(incoh), 5.62, 2)
+        self.assertAlmostEqual(float(abs) , 0.0741, 2)
+        self.assertAlmostEqual(float(incoh), 5.62, 2)
         #Test length
-        self.assertAlmostEquals(float(length), 0.1755, 2)
+        self.assertAlmostEqual(float(length), 0.1755, 2)
         #test Cu sld
-        self.assertAlmostEquals(float(cu_real), 9.46e-6, 1)
-        self.assertAlmostEquals(float(cu_im), 3.01e-8)
+        self.assertAlmostEqual(float(cu_real), 9.46e-6, 1)
+        self.assertAlmostEqual(float(cu_im), 3.01e-8)
         # test Mo sld
-        self.assertAlmostEquals(float(mo_real), 9.43e-6)
-        self.assertAlmostEquals(float(mo_im), 5.65e-7, 1)
+        self.assertAlmostEqual(float(mo_real), 9.43e-6)
+        self.assertAlmostEqual(float(mo_im), 5.65e-7, 1)
         #compute invariant with all correct inputs value
         self.sld_frame.panel.compound_ctl.SetValue("H2O")
@@ -130,6 +130,6 @@
         bkg = self.sld_frame.panel.wavelength_ctl.GetBackgroundColour()
         value = self.sld_frame.panel.wavelength_ctl.GetValue()
-        self.assert_(bkg.GetAsString() == 'white')
-        self.assert_(float(value) == WAVELENGTH/2)
+        self.assertTrue(bkg.GetAsString() == 'white')
+        self.assertTrue(float(value) == WAVELENGTH/2)
         
     def testSomeCombination(self):
@@ -145,9 +145,9 @@
         self.sld_frame.panel.ProcessEvent(clickEvent)
         cp_bkg = self.sld_frame.panel.compound_ctl.GetBackgroundColour()
-        self.assert_(cp_bkg.GetAsString() == 'white')
+        self.assertTrue(cp_bkg.GetAsString() == 'white')
         ds_bkg = self.sld_frame.panel.density_ctl.GetBackgroundColour()
-        self.assert_(ds_bkg.GetAsString() == 'white')
+        self.assertTrue(ds_bkg.GetAsString() == 'white')
         wv_bkg = self.sld_frame.panel.wavelength_ctl.GetBackgroundColour()
-        self.assert_(wv_bkg.GetAsString() == 'pink')
+        self.assertTrue(wv_bkg.GetAsString() == 'pink')
         #density, wavelength is invalid
         self.sld_frame.panel.compound_ctl.SetValue("H2O")
@@ -158,9 +158,9 @@
         self.sld_frame.panel.ProcessEvent(clickEvent)
         cp_bkg = self.sld_frame.panel.compound_ctl.GetBackgroundColour()
-        self.assert_(cp_bkg.GetAsString() == 'white')
+        self.assertTrue(cp_bkg.GetAsString() == 'white')
         ds_bkg = self.sld_frame.panel.density_ctl.GetBackgroundColour()
-        self.assert_(ds_bkg.GetAsString() == 'pink')
+        self.assertTrue(ds_bkg.GetAsString() == 'pink')
         wv_bkg = self.sld_frame.panel.wavelength_ctl.GetBackgroundColour()
-        self.assert_(wv_bkg.GetAsString() == 'pink')
+        self.assertTrue(wv_bkg.GetAsString() == 'pink')
         #density, wavelength is invalid
         self.sld_frame.panel.compound_ctl.SetValue("invalid compound")
@@ -171,11 +171,11 @@
         self.sld_frame.panel.ProcessEvent(clickEvent)
         cp_bkg = self.sld_frame.panel.compound_ctl.GetBackgroundColour()
-        self.assert_(cp_bkg.GetAsString() == 'pink')
+        self.assertTrue(cp_bkg.GetAsString() == 'pink')
         ds_bkg = self.sld_frame.panel.density_ctl.GetBackgroundColour()
-        self.assert_(ds_bkg.GetAsString() == 'pink')
+        self.assertTrue(ds_bkg.GetAsString() == 'pink')
         wv_bkg = self.sld_frame.panel.wavelength_ctl.GetBackgroundColour()
-        self.assert_(wv_bkg.GetAsString() == 'white')
+        self.assertTrue(wv_bkg.GetAsString() == 'white')
         value = self.sld_frame.panel.wavelength_ctl.GetValue()
-        self.assert_(float(value) == WAVELENGTH)
+        self.assertTrue(float(value) == WAVELENGTH)
 
         
Index: test/pr_inversion/test/utest_explorer.py
===================================================================
--- test/pr_inversion/test/utest_explorer.py	(revision f53d684ed4a54de3601e5f4bc601f78376d98e83)
+++ test/pr_inversion/test/utest_explorer.py	(revision 88d2e70bb28d8f9c855c86d94ad8ddd63154277b)
@@ -5,7 +5,7 @@
 import os.path
 import unittest, math, numpy
-from utest_invertor import load
 from sas.sascalc.pr.invertor import Invertor
 from sas.sascalc.pr.distance_explorer import DistExplorer
+from .utest_invertor import load
 
 
Index: test/sascalculator/test/utest_sld.py
===================================================================
--- test/sascalculator/test/utest_sld.py	(revision a50da8251d0d92f4c04979ecac4b78ac2c43b925)
+++ test/sascalculator/test/utest_sld.py	(revision 88d2e70bb28d8f9c855c86d94ad8ddd63154277b)
@@ -51,17 +51,17 @@
                                   molecule_formula=self.sld_formula)
         #test sld
-        self.assertAlmostEquals(sld_real * _SCALE, -5.6e-7, 1)
-        self.assertAlmostEquals(sld_im * _SCALE, 0)
+        self.assertAlmostEqual(sld_real * _SCALE, -5.6e-7, 1)
+        self.assertAlmostEqual(sld_im * _SCALE, 0)
         #test absorption value
-        self.assertAlmostEquals(abs, 0.0741, 2)
-        self.assertAlmostEquals(incoh, 5.62, 2)
+        self.assertAlmostEqual(abs, 0.0741, 2)
+        self.assertAlmostEqual(incoh, 5.62, 2)
         #Test length
-        self.assertAlmostEquals(length, 0.1755, 3)
+        self.assertAlmostEqual(length, 0.1755, 3)
         #test Cu sld
-        self.assertAlmostEquals(cu_real * _SCALE, 9.46e-6, 1)
-        self.assertAlmostEquals(cu_im * _SCALE, 3.01e-8)
+        self.assertAlmostEqual(cu_real * _SCALE, 9.46e-6, 1)
+        self.assertAlmostEqual(cu_im * _SCALE, 3.01e-8)
         # test Mo sld
-        self.assertAlmostEquals(mo_real * _SCALE, 9.43e-6)
-        self.assertAlmostEquals(mo_im * _SCALE, 5.65e-7,1)
+        self.assertAlmostEqual(mo_real * _SCALE, 9.43e-6)
+        self.assertAlmostEqual(mo_im * _SCALE, 5.65e-7,1)
 
 
@@ -91,17 +91,17 @@
                                   molecule_formula=self.sld_formula)
         #test sld
-        self.assertAlmostEquals(sld_real * _SCALE, 6.33e-6, 1)
-        self.assertAlmostEquals(sld_im * _SCALE, 0)
+        self.assertAlmostEqual(sld_real * _SCALE, 6.33e-6, 1)
+        self.assertAlmostEqual(sld_im * _SCALE, 0)
         #test absorption value
-        self.assertAlmostEquals(abs, 1.35e-4, 2)
-        self.assertAlmostEquals(incoh, 0.138, 2)
+        self.assertAlmostEqual(abs, 1.35e-4, 2)
+        self.assertAlmostEqual(incoh, 0.138, 2)
         #Test length
-        self.assertAlmostEquals(length, 1.549, 3)
+        self.assertAlmostEqual(length, 1.549, 3)
         #test Cu sld
-        self.assertAlmostEquals(cu_real * _SCALE, 9.36e-6, 1)
-        self.assertAlmostEquals(cu_im * _SCALE, 2.98e-8)
+        self.assertAlmostEqual(cu_real * _SCALE, 9.36e-6, 1)
+        self.assertAlmostEqual(cu_im * _SCALE, 2.98e-8)
         # test Mo sld
-        self.assertAlmostEquals(mo_real * _SCALE, 9.33e-6)
-        self.assertAlmostEquals(mo_im * _SCALE, 5.59e-9,1)
+        self.assertAlmostEqual(mo_real * _SCALE, 9.33e-6)
+        self.assertAlmostEqual(mo_im * _SCALE, 5.59e-9,1)
 
 
@@ -131,17 +131,17 @@
                                   molecule_formula=self.sld_formula)
         #test sld
-        self.assertAlmostEquals(sld_real * _SCALE, 1.04e-6, 1)
-        self.assertAlmostEquals(sld_im * _SCALE, -1.5e-7, 1)
+        self.assertAlmostEqual(sld_real * _SCALE, 1.04e-6, 1)
+        self.assertAlmostEqual(sld_im * _SCALE, -1.5e-7, 1)
         #test absorption value
-        self.assertAlmostEquals(abs, 180.0,0)
-        self.assertAlmostEquals(incoh, 0.0754, 2)
+        self.assertAlmostEqual(abs, 180.0,0)
+        self.assertAlmostEqual(incoh, 0.0754, 2)
         #Test length
-        self.assertAlmostEquals(length, 0.005551, 4)
+        self.assertAlmostEqual(length, 0.005551, 4)
         #test Cu sld
-        self.assertAlmostEquals(cu_real * _SCALE, 2.89e-5, 1)
-        self.assertAlmostEquals(cu_im * _SCALE, 2.81e-6)
+        self.assertAlmostEqual(cu_real * _SCALE, 2.89e-5, 1)
+        self.assertAlmostEqual(cu_im * _SCALE, 2.81e-6)
         # test Mo sld
-        self.assertAlmostEquals(mo_real * _SCALE, 2.84e-5, 1)
-        self.assertAlmostEquals(mo_im * _SCALE, 7.26e-7,1)
+        self.assertAlmostEqual(mo_real * _SCALE, 2.84e-5, 1)
+        self.assertAlmostEqual(mo_im * _SCALE, 7.26e-7,1)
 
 if __name__ == '__main__':
Index: test/sasdataloader/plugins/test_reader.py
===================================================================
--- test/sasdataloader/plugins/test_reader.py	(revision aaf5e497ff1af2aa7b8b3d361ab951e2a0ca7c93)
+++ test/sasdataloader/plugins/test_reader.py	(revision 88d2e70bb28d8f9c855c86d94ad8ddd63154277b)
@@ -40,5 +40,5 @@
                     input_f =  open(path,'r')
                 except :
-                    raise  RuntimeError, "ascii_reader: cannot open %s" % path
+                    raise  RuntimeError("ascii_reader: cannot open %s" % path)
                 buff = input_f.read()
                 lines = buff.split('\n')
@@ -55,5 +55,5 @@
                 return output
         else:
-            raise RuntimeError, "%s is not a file" % path
+            raise RuntimeError("%s is not a file" % path)
         return None
     
Index: test/sasdataloader/test/utest_abs_reader.py
===================================================================
--- test/sasdataloader/test/utest_abs_reader.py	(revision bd5c3b11a604dfd75fa3d6424e1ea40bcafd3727)
+++ test/sasdataloader/test/utest_abs_reader.py	(revision 88d2e70bb28d8f9c855c86d94ad8ddd63154277b)
@@ -80,8 +80,8 @@
         data_cor = Loader().load(find("sam14_cor.cor"))
         for i in range(0, len(data_abs) - 1):
-            self.assertEquals(data_abs.x[i], data_cor.x[i])
-            self.assertEquals(data_abs.y[i], data_cor.y[i])
-            self.assertEquals(data_abs.dxl[i], data_cor.dxl[i])
-            self.assertEquals(data_abs.dxw[i], data_cor.dxw[i])
+            self.assertEqual(data_abs.x[i], data_cor.x[i])
+            self.assertEqual(data_abs.y[i], data_cor.y[i])
+            self.assertEqual(data_abs.dxl[i], data_cor.dxl[i])
+            self.assertEqual(data_abs.dxw[i], data_cor.dxw[i])
             self.assertTrue(data_abs.dxl > 0)
 
@@ -358,5 +358,5 @@
         self.assertEqual(self.data.dy[0], 3)
         self.assertEqual(self.data.x[1], 0.03)
-        self.assertAlmostEquals(self.data.y[1], 1001.0)
+        self.assertAlmostEqual(self.data.y[1], 1001.0)
         self.assertEqual(self.data.dxl[1], 0.005)
         self.assertEqual(self.data.dxw[1], 0.001)
Index: test/sasdataloader/test/utest_generic_file_reader_class.py
===================================================================
--- test/sasdataloader/test/utest_generic_file_reader_class.py	(revision 4a8d55c05d1355e27bf5afa880633879b6178acc)
+++ test/sasdataloader/test/utest_generic_file_reader_class.py	(revision 88d2e70bb28d8f9c855c86d94ad8ddd63154277b)
@@ -45,5 +45,5 @@
         last_f = f[0]
         if hasattr(last_f, "errors"):
-            self.assertEquals(len(last_f.errors), 1)
+            self.assertEqual(len(last_f.errors), 1)
         else:
             self.fail("Errors did not propogate to the file properly.")
@@ -70,12 +70,12 @@
         self.check_unknown_extension(xml_load[0])
         # Be sure the deprecation warning is passed with the file
-        self.assertEquals(len(asc_load[0].errors), 1)
-        self.assertEquals(len(nxs_load[0].errors), 1)
+        self.assertEqual(len(asc_load[0].errors), 1)
+        self.assertEqual(len(nxs_load[0].errors), 1)
 
     def check_unknown_extension(self, data):
         self.assertTrue(isinstance(data, Data1D))
-        self.assertEquals(len(data.x), 138)
-        self.assertEquals(data.sample.ID, "TK49 c10_SANS")
-        self.assertEquals(data.meta_data["loader"], "CanSAS XML 1D")
+        self.assertEqual(len(data.x), 138)
+        self.assertEqual(data.sample.ID, "TK49 c10_SANS")
+        self.assertEqual(data.meta_data["loader"], "CanSAS XML 1D")
 
     def tearDown(self):
Index: test/sasinvariant/test/utest_data_handling.py
===================================================================
--- test/sasinvariant/test/utest_data_handling.py	(revision f53d684ed4a54de3601e5f4bc601f78376d98e83)
+++ test/sasinvariant/test/utest_data_handling.py	(revision 88d2e70bb28d8f9c855c86d94ad8ddd63154277b)
@@ -45,6 +45,6 @@
 
         # Test results
-        self.assertAlmostEquals(p[0], 1.0, 5)
-        self.assertAlmostEquals(p[1], 0.0, 5)
+        self.assertAlmostEqual(p[0], 1.0, 5)
+        self.assertAlmostEqual(p[1], 0.0, 5)
 
     def test_fit_linear_data_with_noise(self):
@@ -74,6 +74,6 @@
 
         # Test results
-        self.assertAlmostEquals(p[0], 1.0, 5)
-        self.assertAlmostEquals(p[1], 0.0, 5)
+        self.assertAlmostEqual(p[0], 1.0, 5)
+        self.assertAlmostEqual(p[1], 0.0, 5)
 
     def test_fit_linear_data_with_noise_and_fixed_par(self):
@@ -506,5 +506,5 @@
         for i in range(len(self.data.x)):
             value  = math.fabs(test_y[i]-self.data.y[i])/self.data.y[i]
-            self.assert_(value < 0.001)
+            self.assertTrue(value < 0.001)
             
 class TestDataExtraLowSlitGuinier(unittest.TestCase):
@@ -553,9 +553,9 @@
 
         test_y = inv._low_extrapolation_function.evaluate_model(x=self.data.x[:inv._low_extrapolation_npts])
-        self.assert_(len(test_y) == len(self.data.y[:inv._low_extrapolation_npts]))
+        self.assertTrue(len(test_y) == len(self.data.y[:inv._low_extrapolation_npts]))
         
         for i in range(inv._low_extrapolation_npts):
             value  = math.fabs(test_y[i]-self.data.y[i])/self.data.y[i]
-            self.assert_(value < 0.001)
+            self.assertTrue(value < 0.001)
             
     def test_low_data(self):
@@ -589,8 +589,8 @@
                                                npts = inv._low_extrapolation_npts) 
         test_y = data_in_range.y
-        self.assert_(len(test_y) == len(self.data.y[:inv._low_extrapolation_npts]))
+        self.assertTrue(len(test_y) == len(self.data.y[:inv._low_extrapolation_npts]))
         for i in range(inv._low_extrapolation_npts):
             value  = math.fabs(test_y[i]-self.data.y[i])/self.data.y[i]
-            self.assert_(value < 0.001)    
+            self.assertTrue(value < 0.001)
        
             
@@ -642,9 +642,9 @@
         
         test_y = inv._high_extrapolation_function.evaluate_model(x=self.data.x[start: ])
-        self.assert_(len(test_y) == len(self.data.y[start:]))
+        self.assertTrue(len(test_y) == len(self.data.y[start:]))
         
         for i in range(len(self.data.x[start:])):
             value  = math.fabs(test_y[i]-self.data.y[start+i])/self.data.y[start+i]
-            self.assert_(value < 0.001)
+            self.assertTrue(value < 0.001)
             
     def test_high_data(self):
@@ -677,8 +677,8 @@
                                                npts = inv._high_extrapolation_npts) 
         test_y = data_in_range.y
-        self.assert_(len(test_y) == len(self.data.y[start:]))
+        self.assertTrue(len(test_y) == len(self.data.y[start:]))
         temp = self.data.y[start:]
         
         for i in range(len(self.data.x[start:])):
             value  = math.fabs(test_y[i]- temp[i])/temp[i]
-            self.assert_(value < 0.001)                
+            self.assertTrue(value < 0.001)
Index: test/sasinvariant/test/utest_use_cases.py
===================================================================
--- test/sasinvariant/test/utest_use_cases.py	(revision f53d684ed4a54de3601e5f4bc601f78376d98e83)
+++ test/sasinvariant/test/utest_use_cases.py	(revision 88d2e70bb28d8f9c855c86d94ad8ddd63154277b)
@@ -39,6 +39,6 @@
 
         # Test results
-        self.assertAlmostEquals(p[0], 2.3983,3)
-        self.assertAlmostEquals(p[1], 0.87833,3)
+        self.assertAlmostEqual(p[0], 2.3983,3)
+        self.assertAlmostEqual(p[1], 0.87833,3)
 
     def test_fit_line_data_fixed(self):
@@ -54,6 +54,6 @@
 
         # Test results
-        self.assertAlmostEquals(p[0], 4)
-        self.assertAlmostEquals(p[1], -4.0676,3)
+        self.assertAlmostEqual(p[0], 4)
+        self.assertAlmostEqual(p[1], -4.0676,3)
 
 
@@ -78,6 +78,6 @@
 
         # Test results
-        self.assertAlmostEquals(p[0], 2.4727,3)
-        self.assertAlmostEquals(p[1], 0.6,3)
+        self.assertAlmostEqual(p[0], 2.4727,3)
+        self.assertAlmostEqual(p[1], 0.6,3)
 
     def test_fit_line_data_fixed_no_weight(self):
@@ -93,6 +93,6 @@
 
         # Test results
-        self.assertAlmostEquals(p[0], 4)
-        self.assertAlmostEquals(p[1], -7.8,3)
+        self.assertAlmostEqual(p[0], 4)
+        self.assertAlmostEqual(p[1], -7.8,3)
 
 
@@ -132,7 +132,7 @@
 
         # Test results
-        self.assertAlmostEquals(qstar, 7.48959e-5,2)
-        self.assertAlmostEquals(v, 0.005644689, 4)
-        self.assertAlmostEquals(s , 941.7452, 3)
+        self.assertAlmostEqual(qstar, 7.48959e-5,2)
+        self.assertAlmostEqual(v, 0.005644689, 4)
+        self.assertAlmostEqual(s , 941.7452, 3)
 
     def test_use_case_2(self):
@@ -153,7 +153,7 @@
         s, ds = inv.get_surface_with_error(contrast=2.6e-6, porod_const=2)
         # Test results
-        self.assertAlmostEquals(qstar, 7.48959e-5,2)
-        self.assertAlmostEquals(v, 0.005644689, 1)
-        self.assertAlmostEquals(s , 941.7452, 3)
+        self.assertAlmostEqual(qstar, 7.48959e-5,2)
+        self.assertAlmostEqual(v, 0.005644689, 1)
+        self.assertAlmostEqual(s , 941.7452, 3)
 
     def test_use_case_3(self):
@@ -190,7 +190,7 @@
 
         # Test results
-        self.assertAlmostEquals(qstar, 7.49e-5, 1)
-        self.assertAlmostEquals(v, 0.005648401, 4)
-        self.assertAlmostEquals(s , 941.7452, 3)
+        self.assertAlmostEqual(qstar, 7.49e-5, 1)
+        self.assertAlmostEqual(v, 0.005648401, 4)
+        self.assertAlmostEqual(s , 941.7452, 3)
 
     def test_use_case_4(self):
@@ -218,7 +218,7 @@
 
         # Test results
-        self.assertAlmostEquals(qstar, 7.49e-5,2)
-        self.assertAlmostEquals(v, 0.005952674, 3)
-        self.assertAlmostEquals(s , 941.7452, 3)
+        self.assertAlmostEqual(qstar, 7.49e-5,2)
+        self.assertAlmostEqual(v, 0.005952674, 3)
+        self.assertAlmostEqual(s , 941.7452, 3)
 
     def test_use_case_5(self):
@@ -247,7 +247,7 @@
 
         # Test results
-        self.assertAlmostEquals(qstar, 7.88981e-5,2)
-        self.assertAlmostEquals(v, 0.005952674, 3)
-        self.assertAlmostEquals(s , 941.7452, 3)
+        self.assertAlmostEqual(qstar, 7.88981e-5,2)
+        self.assertAlmostEqual(v, 0.005952674, 3)
+        self.assertAlmostEqual(s , 941.7452, 3)
 
     def test_use_case_6(self):
@@ -273,7 +273,7 @@
 
         # Test results
-        self.assertAlmostEquals(qstar, 7.49e-5,2)
-        self.assertAlmostEquals(v, 0.005952674, 3)
-        self.assertAlmostEquals(s , 941.7452, 3)
+        self.assertAlmostEqual(qstar, 7.49e-5,2)
+        self.assertAlmostEqual(v, 0.005952674, 3)
+        self.assertAlmostEqual(s , 941.7452, 3)
 
 
@@ -297,7 +297,7 @@
         s = inv.get_surface(contrast=2.6e-6, porod_const=2)
         # Test results
-        self.assertAlmostEquals(qstar, 1.361677e-3, 4)
-        self.assertAlmostEquals(v, 0.115352622, 2)
-        self.assertAlmostEquals(s , 941.7452, 3 )
+        self.assertAlmostEqual(qstar, 1.361677e-3, 4)
+        self.assertAlmostEqual(v, 0.115352622, 2)
+        self.assertAlmostEqual(s , 941.7452, 3 )
 
     def test_use_case_2(self):
@@ -315,7 +315,7 @@
         s, ds = inv.get_surface_with_error(contrast=2.6e-6, porod_const=2)
         # Test results
-        self.assertAlmostEquals(qstar, 1.361677e-3, 4)
-        self.assertAlmostEquals(v, 0.115352622, 2)
-        self.assertAlmostEquals(s , 941.7452, 3 )
+        self.assertAlmostEqual(qstar, 1.361677e-3, 4)
+        self.assertAlmostEqual(v, 0.115352622, 2)
+        self.assertAlmostEqual(s , 941.7452, 3 )
 
     def test_use_case_3(self):
@@ -336,7 +336,7 @@
 
         # Test results
-        self.assertAlmostEquals(qstar, 0.00138756,2)
-        self.assertAlmostEquals(v, 0.117226896,2)
-        self.assertAlmostEquals(s ,941.7452, 3)
+        self.assertAlmostEqual(qstar, 0.00138756,2)
+        self.assertAlmostEqual(v, 0.117226896,2)
+        self.assertAlmostEqual(s ,941.7452, 3)
 
     def test_use_case_4(self):
@@ -354,5 +354,5 @@
 
         # Test results
-        self.assertAlmostEquals(qstar, 0.0045773,2)
+        self.assertAlmostEqual(qstar, 0.0045773,2)
 
     def test_use_case_5(self):
@@ -374,5 +374,5 @@
 
         # Test results
-        self.assertAlmostEquals(qstar, 0.00460319,3)
+        self.assertAlmostEqual(qstar, 0.00460319,3)
       
   
Index: test/sasrealspace/test/utest_oriented.py
===================================================================
--- test/sasrealspace/test/utest_oriented.py	(revision 1cdbcd86f80ac59e1681b673122c51157177496f)
+++ test/sasrealspace/test/utest_oriented.py	(revision 88d2e70bb28d8f9c855c86d94ad8ddd63154277b)
@@ -59,5 +59,5 @@
         ana_val = self.ana.runXY([0.1, 0.1])
         sim_val = self.model.getIq2D(0.1, 0.1)
-        self.assert_( math.fabs(sim_val/ana_val-1.0)<0.1 )
+        self.assertTrue( math.fabs(sim_val/ana_val-1.0)<0.1 )
 
 class TestCylinderAddObject(unittest.TestCase):
@@ -101,5 +101,5 @@
         #print ana_val, sim_val, sim_val/ana_val
 
-        self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
+        self.assertTrue( math.fabs(sim_val/ana_val-1.0)<0.05 )
 
 
@@ -143,5 +143,5 @@
         #print ana_val, sim_val, sim_val/ana_val
 
-        self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
+        self.assertTrue( math.fabs(sim_val/ana_val-1.0)<0.05 )
 
     def testalongZ(self):
@@ -156,5 +156,5 @@
         #print ana_val, sim_val, sim_val/ana_val
 
-        self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
+        self.assertTrue( math.fabs(sim_val/ana_val-1.0)<0.05 )
 
     def testalongX(self):
@@ -169,5 +169,5 @@
         #print ana_val, sim_val, sim_val/ana_val
 
-        self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
+        self.assertTrue( math.fabs(sim_val/ana_val-1.0)<0.05 )
 
 class TestEllipsoid(unittest.TestCase):
@@ -213,5 +213,5 @@
         #print ana_val, sim_val, sim_val/ana_val
 
-        self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
+        self.assertTrue( math.fabs(sim_val/ana_val-1.0)<0.05 )
 
     def testalongZ(self):
@@ -226,5 +226,5 @@
         #print ana_val, sim_val, sim_val/ana_val
 
-        self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
+        self.assertTrue( math.fabs(sim_val/ana_val-1.0)<0.05 )
 
     def testalongY(self):
@@ -240,5 +240,5 @@
 
         try:
-            self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
+            self.assertTrue( math.fabs(sim_val/ana_val-1.0)<0.05 )
         except Exception:
             print("Error", ana_val, sim_val, sim_val/ana_val)
@@ -295,5 +295,5 @@
         sim_val, err = self.canvas.getIq2DError(0.1, 0.2)
 
-        self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
+        self.assertTrue( math.fabs(sim_val/ana_val-1.0)<0.05 )
 
 class TestCoreShellError(unittest.TestCase):
@@ -347,5 +347,5 @@
         sim_val, err = self.canvas.getIq2DError(0.1, 0.2)
 
-        self.assert_( math.fabs(sim_val-ana_val) < 3.0 * err )
+        self.assertTrue( math.fabs(sim_val-ana_val) < 3.0 * err )
 
 class TestRunMethods(unittest.TestCase):
@@ -392,5 +392,5 @@
 
         try:
-            self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
+            self.assertTrue( math.fabs(sim_val/ana_val-1.0)<0.05 )
         except Exception:
             print("Error", ana_val, sim_val, sim_val/ana_val)
@@ -404,5 +404,5 @@
 
         try:
-            self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
+            self.assertTrue( math.fabs(sim_val/ana_val-1.0)<0.05 )
         except Exception:
             print("Error", ana_val, sim_val, sim_val/ana_val)
@@ -416,5 +416,5 @@
 
         try:
-            self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
+            self.assertTrue( math.fabs(sim_val/ana_val-1.0)<0.05 )
         except Exception:
             print("Error", ana_val, sim_val, sim_val/ana_val)
@@ -428,5 +428,5 @@
 
         try:
-            self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
+            self.assertTrue( math.fabs(sim_val/ana_val-1.0)<0.05 )
         except Exception:
             print("Error", ana_val, sim_val, sim_val/ana_val)
@@ -471,5 +471,5 @@
         sim_val = self.model.getIq2D(0.1, 0.2)
 
-        self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
+        self.assertTrue( math.fabs(sim_val/ana_val-1.0)<0.05 )
 
         # Change the radius a re-evaluate
@@ -479,5 +479,5 @@
         ana_val = self.ana.runXY([0.1, 0.2])
         sim_val = self.model.getIq2D(0.1, 0.2)
-        self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
+        self.assertTrue( math.fabs(sim_val/ana_val-1.0)<0.05 )
 
 
Index: test/sasrealspace/test/utest_realspace.py
===================================================================
--- test/sasrealspace/test/utest_realspace.py	(revision 1cdbcd86f80ac59e1681b673122c51157177496f)
+++ test/sasrealspace/test/utest_realspace.py	(revision 88d2e70bb28d8f9c855c86d94ad8ddd63154277b)
@@ -38,5 +38,5 @@
         self.model.add('ellipsoid','elli2')
         self.model.delete('elli2')
-        self.assert_('elli2' not in self.model.getShapeList())
+        self.assertTrue('elli2' not in self.model.getShapeList())
 
     def testsetParam(self):
@@ -81,5 +81,5 @@
         value_2 = self.canvas.getIq(0.001)
 
-        self.assert_( (value_1-value_2)/value_1 < 0.1)
+        self.assertTrue( (value_1-value_2)/value_1 < 0.1)
 
     def testSetDensityTiming(self):
@@ -99,9 +99,9 @@
         t_2 = time.time()-t_0
 
-        self.assert_( t_2 < t_1 and (t_1-t_2)/t_2 > 2)
+        self.assertTrue( t_2 < t_1 and (t_1-t_2)/t_2 > 2)
 
     def testGetParamList(self):
         """ Test GetParamList on empty canvas"""
-        self.assert_('lores_density' in self.canvas.getParamList())
+        self.assertTrue('lores_density' in self.canvas.getParamList())
         handle = self.canvas.add('sphere')
 
@@ -109,5 +109,5 @@
         """ Test GetParamList on filled canvas"""
         self.canvas.add('sphere')
-        self.assert_('lores_density' in self.canvas.getParamList())
+        self.assertTrue('lores_density' in self.canvas.getParamList())
 
     def testAdd(self):
@@ -151,8 +151,8 @@
         # THIS WILL DEPEND ON THE NUMBER OF SPACE POINTS:
         # that why we need some error analysis.
-        self.assert_( (sim_2*ana_1/sim_1 - ana_2)/ana_2 < 0.1)
+        self.assertTrue( (sim_2*ana_1/sim_1 - ana_2)/ana_2 < 0.1)
 
         # test the absolute amplitude
-        self.assert_( math.fabs(sim_2-ana_2)/ana_2 < 0.1)
+        self.assertTrue( math.fabs(sim_2-ana_2)/ana_2 < 0.1)
 
     def testGetIq2(self):
@@ -196,5 +196,5 @@
         sim_2 = self.canvas.getIq(0.01)
 
-        self.assert_((sim_2-sim_1)/sim_1<0.05)
+        self.assertTrue((sim_2-sim_1)/sim_1<0.05)
 
     def testGetIq_time(self):
@@ -216,5 +216,5 @@
         delta_2 = time.time()-t_0
 
-        self.assert_((delta_2-delta_1)/delta_1<0.05)
+        self.assertTrue((delta_2-delta_1)/delta_1<0.05)
 
 
@@ -342,5 +342,5 @@
         ana = self.sphere.run(0.05)
         val, err = self.canvas.getIqError(0.05)
-        self.assert_(math.fabs(ana-val)<2.0*err)
+        self.assertTrue(math.fabs(ana-val)<2.0*err)
 
     def testRightOrder(self):
@@ -350,5 +350,5 @@
         val, err = self.canvas.getIqError(0.05)
         #print 'right', ana, val, err
-        self.assert_(math.fabs(ana-val)/ana < 1.1)
+        self.assertTrue(math.fabs(ana-val)/ana < 1.1)
 
     def testWrongOrder(self):
@@ -365,5 +365,5 @@
         val, err = self.canvas.getIqError(0.05)
         #print 'wrong', ana, val, err
-        self.assert_(math.fabs(ana-val)/ana < 1.1)
+        self.assertTrue(math.fabs(ana-val)/ana < 1.1)
 
 
