Changeset 9562

Timestamp:

Jan 31, 2015, 7:12:40 PM (10 years ago)

Author:

steve

Message:

Moving test folders to tests foldersy

Location:

trunk/anuga_core/source/anuga

Files:

• abstract_2d_finite_volumes/__init__.py (modified) (2 diffs)
• abstract_2d_finite_volumes/tests/test_general_mesh.py (modified) (7 diffs)
• abstract_2d_finite_volumes/tests/test_generic_domain.py (modified) (1 diff)
• abstract_2d_finite_volumes/tests/test_neighbour_mesh.py (modified) (2 diffs)
• abstract_2d_finite_volumes/tests/test_pmesh2domain.py (modified) (2 diffs)
• abstract_2d_finite_volumes/tests/test_quantity.py (modified) (2 diffs)
• abstract_2d_finite_volumes/tests/test_util.py (modified) (10 diffs)
• advection/__init__.py (modified) (1 diff)
• advection/tests (moved) (moved from trunk/anuga_core/source/anuga/advection/test)
• alpha_shape/__init__.py (modified) (1 diff)
• alpha_shape/tests/test_alpha_shape.py (modified) (3 diffs)
• caching/__init__.py (modified) (1 diff)
• coordinate_transforms/__init__.py (modified) (1 diff)
• coordinate_transforms/test/test_geo_reference.py (modified) (44 diffs)
• coordinate_transforms/test/test_point.py (modified) (8 diffs)
• coordinate_transforms/test/test_redfearn.py (modified) (4 diffs)
• culvert_flows/__init__.py (modified) (1 diff)
• damage_modelling/__init__.py (modified) (1 diff)
• damage_modelling/test/test_exposure.py (modified) (18 diffs)
• damage_modelling/test/test_inundation_damage.py (modified) (4 diffs)
• file/__init__.py (modified) (1 diff)
• file/test/test_ungenerate.py (modified) (7 diffs)
• file_conversion/__init__.py (modified) (1 diff)
• file_conversion/test/test_file_conversion.py (modified) (1 diff)
• file_conversion/test/test_sww2dem.py (modified) (1 diff)
• file_conversion/test/test_urs2sww.py (modified) (2 diffs)
• fit_interpolate/test/test_fit.py (modified) (4 diffs)
• fit_interpolate/test/test_interpolate.py (modified) (7 diffs)
• geometry/__init__.py (modified) (1 diff)
• geometry/test/test_polygon.py (modified) (40 diffs)
• geospatial_data/__init__.py (modified) (1 diff)
• geospatial_data/test/test_geospatial_data.py (modified) (8 diffs)
• lib/__init__.py (modified) (2 diffs)
• lib/test/test_maxasc.py (modified) (7 diffs)
• lib/test/test_order_boundary.py (modified) (2 diffs)
• load_mesh/__init__.py (modified) (1 diff)
• load_mesh/test/test_loadASCII.py (modified) (11 diffs)
• mesh_engine/__init__.py (modified) (1 diff)
• mesh_engine/test/test_generate_mesh.py (modified) (24 diffs)
• operators/__init__.py (modified) (1 diff)
• parallel/__init__.py (modified) (1 diff)
• pmesh/__init__.py (modified) (1 diff)
• pmesh/test/test_mesh.py (modified) (86 diffs)
• pmesh/test/test_mesh_interface.py (modified) (18 diffs)
• pmesh/test/test_meshquad.py (modified) (1 diff)
• pymetis/__init__.py (modified) (1 diff)
• shallow_water/__init__.py (modified) (1 diff)
• shallow_water/test/test_shallow_water_domain.py (modified) (2 diffs)
• structures/__init__.py (modified) (1 diff)
• tsunami_source/__init__.py (modified) (1 diff)
• utilities/__init__.py (modified) (1 diff)
• utilities/numerical_tools.py (modified) (3 diffs)
• utilities/test/test_csv_tools.py (modified) (11 diffs)
• utilities/test/test_file_utils.py (modified) (2 diffs)
• utilities/test/test_numerical_tools.py (modified) (9 diffs)
• utilities/test/test_system_tools.py (modified) (10 diffs)
• validation_utilities/__init__.py (modified) (1 diff)

trunk/anuga_core/source/anuga/abstract_2d_finite_volumes/__init__.py

@@ -7 +7 @@
 """
 
-pass
+from numpy.testing import Tester
+test = Tester().test
 
 
@@ -13 +14 @@
 
 
+
+

trunk/anuga_core/source/anuga/abstract_2d_finite_volumes/tests/test_general_mesh.py

@@ -67 +67 @@
         msg = ("num.array([b,a,c])=\n%s\nshould be close to 'verts'=\n%s"
                % (str(num.array([b,a,c])), str(verts)))
-        self.failUnless(num.allclose(num.array([b,a,c]), verts), msg)
+        self.assertTrue(num.allclose(num.array([b,a,c]), verts), msg)
 
         verts = domain.get_vertex_coordinates(triangle_id=0)       
@@ -170 +170 @@
         msg = ("num.array(1/2[a+c,b+c,a+b])=\n%s\nshould be close to 'verts'=\n%s"
                % (str(num.array([0.5*(a+c),0.5*(b+c),0.5*(a+b)])), str(verts)))
-        self.failUnless(num.allclose(num.array([0.5*(a+c),0.5*(b+c),0.5*(a+b)]), verts), msg)
+        self.assertTrue(num.allclose(num.array([0.5*(a+c),0.5*(b+c),0.5*(a+b)]), verts), msg)
 
 
@@ -444 +444 @@
         node = domain.get_node(2)        
         msg = ('\nc=%s\nnode=%s' % (str(c), str(node)))
-        self.failUnless(num.alltrue(c == node), msg)
+        self.assertTrue(num.alltrue(c == node), msg)
 
         # repeat get_node(), see if result same
         node = domain.get_node(2)        
         msg = ('\nc=%s\nnode=%s' % (str(c), str(node)))
-        self.failUnless(num.alltrue(c == node), msg)
+        self.assertTrue(num.alltrue(c == node), msg)
         
         node = domain.get_node(2, absolute=True)     
         msg = ('\nnodes_absolute[2]=%s\nnode=%s'
                % (str(nodes_absolute[2]), str(node)))
-        self.failUnless(num.alltrue(nodes_absolute[2] == node), msg)
+        self.assertTrue(num.alltrue(nodes_absolute[2] == node), msg)
        
         # repeat get_node(2, absolute=True), see if result same
@@ -460 +460 @@
         msg = ('\nnodes_absolute[2]=%s\nnode=%s'
                % (str(nodes_absolute[2]), str(node)))
-        self.failUnless(num.alltrue(nodes_absolute[2] == node), msg)
+        self.assertTrue(num.alltrue(nodes_absolute[2] == node), msg)
         
 
@@ -492 +492 @@
         # should fail with negative area
         triangles = num.array([[0,1,2], [1,2,4], [4,2,5], [3,1,4]])
-        self.failUnlessRaises(AssertionError, General_mesh, 
+        self.assertRaises(AssertionError, General_mesh, 
                               nodes, triangles, geo_reference=geo)
 
@@ -498 +498 @@
         # max index is 5, use 6, expect assert failure
         triangles = num.array([[1,6,2], [1,2,4], [4,2,5], [3,1,4]])
-        self.failUnlessRaises(AssertionError, General_mesh,
+        self.assertRaises(AssertionError, General_mesh,
                               nodes, triangles, geo_reference=geo)
         
@@ -505 +505 @@
         # max index is 5, use 10, expect assert failure
         triangles = num.array([[1,10,2], [1,2,4], [4,2,5], [3,1,4]])
-        self.failUnlessRaises(AssertionError, General_mesh,
+        self.assertRaises(AssertionError, General_mesh,
                               nodes, triangles, geo_reference=geo)
 

trunk/anuga_core/source/anuga/abstract_2d_finite_volumes/tests/test_generic_domain.py

@@ -817 +817 @@
         domain.set_tag_region([add_to_verts])
 
-        self.failUnless(domain.test == "Mound",
+        self.assertTrue(domain.test == "Mound",
                         'set region failed')
 

trunk/anuga_core/source/anuga/abstract_2d_finite_volumes/tests/test_neighbour_mesh.py

@@ -1157 +1157 @@
 
         #print loners
-        self.failUnless(loners==[2,4],
+        self.assertTrue(loners==[2,4],
                         'FAILED!')
 
@@ -1172 +1172 @@
         mesh.check_integrity()
         loners = mesh.get_lone_vertices()
-        self.failUnless(loners==[0],
+        self.assertTrue(loners==[0],
                         'FAILED!') 
 

trunk/anuga_core/source/anuga/abstract_2d_finite_volumes/tests/test_pmesh2domain.py

@@ -99 +99 @@
          assert num.allclose(tagged_elements['ole nielsen'][0],1)
 
-         self.failUnless( domain.boundary[(1, 0)]  == '1',
-                          "test_tags_to_boundaries  failed. Single boundary wasn't added.")
-         self.failUnless( domain.boundary[(1, 2)]  == '2',
-                          "test_tags_to_boundaries  failed. Single boundary wasn't added.")
-         self.failUnless( domain.boundary[(0, 1)]  == '3',
-                          "test_tags_to_boundaries  failed. Single boundary wasn't added.")
-         self.failUnless( domain.boundary[(0, 0)]  == 'exterior',
+         self.assertTrue( domain.boundary[(1, 0)]  == '1',
+                          "test_tags_to_boundaries  failed. Single boundary wasn't added.")
+         self.assertTrue( domain.boundary[(1, 2)]  == '2',
+                          "test_tags_to_boundaries  failed. Single boundary wasn't added.")
+         self.assertTrue( domain.boundary[(0, 1)]  == '3',
+                          "test_tags_to_boundaries  failed. Single boundary wasn't added.")
+         self.assertTrue( domain.boundary[(0, 0)]  == 'exterior',
                           "test_tags_to_boundaries  failed. Single boundary wasn't added.")
          #print "domain.boundary",domain.boundary
-         self.failUnless( len(domain.boundary)  == 4,
+         self.assertTrue( len(domain.boundary)  == 4,
                           "test_pmesh2Domain Too many boundaries")
          #FIXME change to use get_xllcorner
          #print "d.geo_reference.xllcorner",domain.geo_reference.xllcorner 
-         self.failUnless(domain.geo_reference.xllcorner  == 140.0,
+         self.assertTrue(domain.geo_reference.xllcorner  == 140.0,
                           "bad geo_referece")
     #************
@@ -194 +194 @@
          assert num.allclose(tagged_elements['ole nielsen'][0],1)
 
-         self.failUnless( domain.boundary[(1, 0)]  == '1',
-                          "test_tags_to_boundaries  failed. Single boundary wasn't added.")
-         self.failUnless( domain.boundary[(1, 2)]  == '2',
-                          "test_tags_to_boundaries  failed. Single boundary wasn't added.")
-         self.failUnless( domain.boundary[(0, 1)]  == '3',
-                          "test_tags_to_boundaries  failed. Single boundary wasn't added.")
-         self.failUnless( domain.boundary[(0, 0)]  == 'exterior',
+         self.assertTrue( domain.boundary[(1, 0)]  == '1',
+                          "test_tags_to_boundaries  failed. Single boundary wasn't added.")
+         self.assertTrue( domain.boundary[(1, 2)]  == '2',
+                          "test_tags_to_boundaries  failed. Single boundary wasn't added.")
+         self.assertTrue( domain.boundary[(0, 1)]  == '3',
+                          "test_tags_to_boundaries  failed. Single boundary wasn't added.")
+         self.assertTrue( domain.boundary[(0, 0)]  == 'exterior',
                           "test_tags_to_boundaries  failed. Single boundary wasn't added.")
          #print "domain.boundary",domain.boundary
-         self.failUnless( len(domain.boundary)  == 4,
+         self.assertTrue( len(domain.boundary)  == 4,
                           "test_pmesh2Domain Too many boundaries")
          #FIXME change to use get_xllcorner
          #print "d.geo_reference.xllcorner",domain.geo_reference.xllcorner 
-         self.failUnless(domain.geo_reference.xllcorner  == 140.0,
+         self.assertTrue(domain.geo_reference.xllcorner  == 140.0,
                           "bad geo_referece")
          

trunk/anuga_core/source/anuga/abstract_2d_finite_volumes/tests/test_quantity.py

@@ -1261 +1261 @@
         os.remove(pts_file)
         
-    def verbose_test_set_values_from_UTM_pts(self):
+    def test_set_values_from_UTM_pts_verbose(self):
         quantity = Quantity(self.mesh_onslow)
 
@@ -1318 +1318 @@
         #Check that values can be set from file
         quantity.set_values_from_file(pts_file, att, 0,
-                                      'vertices', None, verbose = True,
+                                      'vertices', None, verbose = False,
                                       max_read_lines=2)
         answer = linear_function(quantity.domain.get_vertex_coordinates())

trunk/anuga_core/source/anuga/abstract_2d_finite_volumes/tests/test_util.py

@@ -49 +49 @@
     #    from anuga.abstract_2d_finite_volumes.util import distance#
     #
-    #    self.failUnless( distance([4,2],[7,6]) == 5.0,
+    #    self.assertTrue( distance([4,2],[7,6]) == 5.0,
     #                     'Distance is wrong!')
-    #    self.failUnless( allclose(distance([7,6],[9,8]), 2.82842712475),
+    #    self.assertTrue( allclose(distance([7,6],[9,8]), 2.82842712475),
     #                    'distance is wrong!')
-    #    self.failUnless( allclose(distance([9,8],[4,2]), 7.81024967591),
+    #    self.assertTrue( allclose(distance([9,8],[4,2]), 7.81024967591),
     #                    'distance is wrong!')
     #
-    #    self.failUnless( distance([9,8],[4,2]) == distance([4,2],[9,8]),
+    #    self.assertTrue( distance([9,8],[4,2]) == distance([4,2],[9,8]),
     #                    'distance is wrong!')
 
@@ -703 +703 @@
                 #print
                 if num.alltrue(q0 == NAN):
-                     self.failUnless(num.alltrue(q == actual), 'Fail!')
+                     self.assertTrue(num.alltrue(q == actual), 'Fail!')
                 else:
                     assert num.allclose(q, actual)
@@ -873 +873 @@
                 #print
                 if q0 == NAN:
-                     self.failUnless( q == actual, 'Fail!')
+                     self.assertTrue( q == actual, 'Fail!')
                 else:
                     assert num.allclose(q, actual)
@@ -919 +919 @@
                 #print
                 if q0 == NAN:
-                     self.failUnless( q == actual, 'Fail!')
+                     self.assertTrue( q == actual, 'Fail!')
                 else:
                     assert num.allclose(q, actual)
@@ -1406 +1406 @@
         tris = [[0,1,2]]
         new_verts, new_tris = remove_lone_verts(verts, tris)
-        self.failUnless(new_verts.tolist() == verts)
-        self.failUnless(new_tris.tolist() == tris)
+        self.assertTrue(new_verts.tolist() == verts)
+        self.assertTrue(new_tris.tolist() == tris)
 
     def test_remove_lone_verts_b(self):
@@ -1413 +1413 @@
         tris = [[0,1,2]]
         new_verts, new_tris = remove_lone_verts(verts, tris)
-        self.failUnless(new_verts.tolist() == verts[0:3])
-        self.failUnless(new_tris.tolist() == tris)
+        self.assertTrue(new_verts.tolist() == verts[0:3])
+        self.assertTrue(new_tris.tolist() == tris)
         
     def test_remove_lone_verts_c(self):
@@ -1420 +1420 @@
         tris = [[1,2,4]]
         new_verts, new_tris = remove_lone_verts(verts, tris)
-        self.failUnless(new_verts.tolist() == [[0,0],[1,0],[0,1]])
-        self.failUnless(new_tris.tolist() == [[0,1,2]])
+        self.assertTrue(new_verts.tolist() == [[0,0],[1,0],[0,1]])
+        self.assertTrue(new_tris.tolist() == [[0,1,2]])
      
     def test_remove_lone_verts_d(self):
@@ -1427 +1427 @@
         tris = [[0,1,3]]
         new_verts, new_tris = remove_lone_verts(verts, tris)
-        self.failUnless(new_verts.tolist() == [[0,0],[1,0],[0,1]])
-        self.failUnless(new_tris.tolist() == [[0,1,2]])
+        self.assertTrue(new_verts.tolist() == [[0,0],[1,0],[0,1]])
+        self.assertTrue(new_tris.tolist() == [[0,1,2]])
         
     def test_remove_lone_verts_e(self):
@@ -1434 +1434 @@
         tris = [[0,1,2]]
         new_verts, new_tris = remove_lone_verts(verts, tris)
-        self.failUnless(new_verts.tolist() == verts[0:3])
-        self.failUnless(new_tris.tolist() == tris)
+        self.assertTrue(new_verts.tolist() == verts[0:3])
+        self.assertTrue(new_tris.tolist() == tris)
      
     def test_remove_lone_verts_f(self):
@@ -1441 +1441 @@
         tris = [[0,1,3],[0,1,5]]
         new_verts, new_tris = remove_lone_verts(verts, tris)
-        self.failUnless(new_verts.tolist() == [[0,0],[1,0],[0,1],[1,1]])
-        self.failUnless(new_tris.tolist() == [[0,1,2],[0,1,3]])
+        self.assertTrue(new_verts.tolist() == [[0,0],[1,0],[0,1],[1,1]])
+        self.assertTrue(new_tris.tolist() == [[0,1,2],[0,1,3]])
         
 ######

trunk/anuga_core/source/anuga/advection/__init__.py

@@ -6 +6 @@
 from advection import Advection_Domain
 
+from numpy.testing import Tester
+test = Tester().test
 
 
 
-

trunk/anuga_core/source/anuga/alpha_shape/__init__.py

@@ -1 +1 @@
 #nothing
+
+from numpy.testing import Tester
+test = Tester().test

trunk/anuga_core/source/anuga/alpha_shape/tests/test_alpha_shape.py

@@ -46 +46 @@
             pass
         else:
-            self.failUnless(0==1, \
+            self.assertTrue(0==1, \
                         'point list with 2 points did not raise an error!')
 
@@ -163 +163 @@
             pass
         else:
-            self.failUnless(0==1,
+            self.assertTrue(0==1,
                         'point list with 2 points did not raise an error!')
 
@@ -197 +197 @@
         file.close()
         os.remove(output_file_name)
-        self.failUnless(lFile[1] == "5,0" and
+        self.assertTrue(lFile[1] == "5,0" and
                         lFile[2] == "0,1" and 
                         lFile[3] == "4,5" and 

trunk/anuga_core/source/anuga/caching/__init__.py

@@ -11 +11 @@
 
 
+from numpy.testing import Tester
+test = Tester().test
+
+
+
+

trunk/anuga_core/source/anuga/coordinate_transforms/__init__.py

@@ -2 +2 @@
 from redfearn import *
 from point import *
- 
+
+from numpy.testing import Tester
+test = Tester().test

trunk/anuga_core/source/anuga/coordinate_transforms/test/test_geo_reference.py

@@ -25 +25 @@
         (z,x,y) = g.get_origin()
 
-        self.failUnless(z == g.get_zone(), ' failed')
-        self.failUnless(x == g.get_xllcorner(), ' failed')
-        self.failUnless(y == g.get_yllcorner(), ' failed') 
+        self.assertTrue(z == g.get_zone(), ' failed')
+        self.assertTrue(x == g.get_xllcorner(), ' failed')
+        self.assertTrue(y == g.get_yllcorner(), ' failed') 
         
     def test_read_write_NetCDF(self):
@@ -43 +43 @@
         os.remove(file_name)
 
-        self.failUnless(g == new_g, 'test_read_write_NetCDF failed')  
+        self.assertTrue(g == new_g, 'test_read_write_NetCDF failed')  
         
     def test_read_NetCDFI(self):
@@ -62 +62 @@
         os.remove(file_name)
 
-        self.failUnless(g == new_g, ' failed')
+        self.assertTrue(g == new_g, ' failed')
         
     def test_read_write_ASCII(self):
@@ -77 +77 @@
         os.remove(file_name)
 
-        self.failUnless(g == new_g, 'test_read_write_ASCII failed')  
+        self.assertTrue(g == new_g, 'test_read_write_ASCII failed')  
     
     def test_read_write_ASCII2(self):
@@ -92 +92 @@
         os.remove(file_name)
 
-        self.failUnless(g == new_g, 'test_read_write_ASCII failed')
+        self.assertTrue(g == new_g, 'test_read_write_ASCII failed')
         
     def test_read_write_ASCII3(self):
@@ -112 +112 @@
             os.remove(file_name)
         else:
-            self.failUnless(0 ==1,
+            self.assertTrue(0 ==1,
                         'bad text file did not raise error!')
             
@@ -122 +122 @@
         new_lofl = g.change_points_geo_ref(lofl)
 
-        self.failUnless(isinstance(new_lofl, list), ' failed')
-        self.failUnless(type(new_lofl) == type(lofl), ' failed')
+        self.assertTrue(isinstance(new_lofl, list), ' failed')
+        self.assertTrue(type(new_lofl) == type(lofl), ' failed')
         for point,new_point in map(None,lofl,new_lofl):
-            self.failUnless(point[0]-x==new_point[0], ' failed')
-            self.failUnless(point[1]-y==new_point[1], ' failed')
+            self.assertTrue(point[0]-x==new_point[0], ' failed')
+            self.assertTrue(point[1]-y==new_point[1], ' failed')
          
         
@@ -136 +136 @@
         new_lofl = g.change_points_geo_ref(lofl)
 
-        self.failUnless(isinstance(new_lofl, list), ' failed')
-        self.failUnless(type(new_lofl) == type(lofl), ' failed')
+        self.assertTrue(isinstance(new_lofl, list), ' failed')
+        self.assertTrue(type(new_lofl) == type(lofl), ' failed')
         for point,new_point in map(None,lofl,new_lofl):
-            self.failUnless(point[0]-x==new_point[0], ' failed')
-            self.failUnless(point[1]-y==new_point[1], ' failed')
+            self.assertTrue(point[0]-x==new_point[0], ' failed')
+            self.assertTrue(point[1]-y==new_point[1], ' failed')
         
     def test_change_points_geo_ref3(self):
@@ -149 +149 @@
         new_lofl = g.change_points_geo_ref(lofl)
 
-        self.failUnless(isinstance(new_lofl, list), ' failed')
-        self.failUnless(type(new_lofl) == type(lofl), ' failed')
+        self.assertTrue(isinstance(new_lofl, list), ' failed')
+        self.assertTrue(type(new_lofl) == type(lofl), ' failed')
         for point,new_point in map(None,[lofl],new_lofl):
-            self.failUnless(point[0]-x==new_point[0], ' failed')
-            self.failUnless(point[1]-y==new_point[1], ' failed')
+            self.assertTrue(point[0]-x==new_point[0], ' failed')
+            self.assertTrue(point[1]-y==new_point[1], ' failed')
         
     
@@ -163 +163 @@
         new_lofl = g.change_points_geo_ref(lofl)
 
-        self.failUnless(isinstance(new_lofl, num.ndarray), ' failed')
-        self.failUnless(type(new_lofl) == type(lofl), ' failed')
+        self.assertTrue(isinstance(new_lofl, num.ndarray), ' failed')
+        self.assertTrue(type(new_lofl) == type(lofl), ' failed')
         lofl[:,0] -= x
         lofl[:,1] -= y
@@ -177 +177 @@
         new_lofl = g.change_points_geo_ref(lofl.copy())
 
-        self.failUnless(isinstance(new_lofl, num.ndarray), ' failed')
-        self.failUnless(type(new_lofl) == type(lofl), ' failed')
+        self.assertTrue(isinstance(new_lofl, num.ndarray), ' failed')
+        self.assertTrue(type(new_lofl) == type(lofl), ' failed')
 
 
         for point,new_point in map(None,lofl,new_lofl):
-            self.failUnless(point[0]-x==new_point[0], ' failed')
-            self.failUnless(point[1]-y==new_point[1], ' failed')
+            self.assertTrue(point[0]-x==new_point[0], ' failed')
+            self.assertTrue(point[1]-y==new_point[1], ' failed')
         
     def test_change_points_geo_ref6(self):
@@ -192 +192 @@
         new_lofl = g.change_points_geo_ref(lofl.copy())        
 
-        self.failUnless(isinstance(new_lofl, num.ndarray), ' failed')
-        self.failUnless(type(new_lofl) == type(lofl), ' failed')
+        self.assertTrue(isinstance(new_lofl, num.ndarray), ' failed')
+        self.assertTrue(type(new_lofl) == type(lofl), ' failed')
         for point,new_point in map(None,[lofl],new_lofl):
-            self.failUnless(point[0]-x==new_point[0], ' failed')
-            self.failUnless(point[1]-y==new_point[1], ' failed')
+            self.assertTrue(point[0]-x==new_point[0], ' failed')
+            self.assertTrue(point[1]-y==new_point[1], ' failed')
      
     def test_change_points_geo_ref7(self):
@@ -208 +208 @@
         new_lofl = g.change_points_geo_ref(lofl,points_geo_ref=points_geo_ref)
 
-        self.failUnless(isinstance(new_lofl, list), ' failed')
-        self.failUnless(type(new_lofl) == type(lofl), ' failed')
+        self.assertTrue(isinstance(new_lofl, list), ' failed')
+        self.assertTrue(type(new_lofl) == type(lofl), ' failed')
         for point,new_point in map(None,lofl,new_lofl):
-            self.failUnless(point[0]+point_x-x==new_point[0], ' failed')
-            self.failUnless(point[1]+point_y-y==new_point[1], ' failed')
+            self.assertTrue(point[0]+point_x-x==new_point[0], ' failed')
+            self.assertTrue(point[1]+point_y-y==new_point[1], ' failed')
 
     def test_get_absolute_list(self):
@@ -223 +223 @@
         new_points = g.get_absolute(points)
 
-        self.failUnless(isinstance(new_points, list), 'failed')
-        self.failUnless(type(new_points) == type(points), 'failed')
+        self.assertTrue(isinstance(new_points, list), 'failed')
+        self.assertTrue(type(new_points) == type(points), 'failed')
         for point, new_point in map(None, points, new_points):
-            self.failUnless(point[0]+x == new_point[0], 'failed')
-            self.failUnless(point[1]+y == new_point[1], 'failed')
+            self.assertTrue(point[0]+x == new_point[0], 'failed')
+            self.assertTrue(point[1]+y == new_point[1], 'failed')
 
         # test with no supplied offsets
@@ -234 +234 @@
         new_points = g.get_absolute(points)
 
-        self.failUnless(isinstance(new_points, list), 'failed')
-        self.failUnless(type(new_points) == type(points), 'failed')
+        self.assertTrue(isinstance(new_points, list), 'failed')
+        self.assertTrue(type(new_points) == type(points), 'failed')
         for point, new_point in map(None, points, new_points):
-            self.failUnless(point[0] == new_point[0], 'failed')
-            self.failUnless(point[1] == new_point[1], 'failed')
+            self.assertTrue(point[0] == new_point[0], 'failed')
+            self.assertTrue(point[1] == new_point[1], 'failed')
             
         # test that calling get_absolute twice does the right thing
@@ -249 +249 @@
         new_points = g.get_absolute(points)
 
-        self.failUnless(isinstance(new_points, list), 'failed')
-        self.failUnless(type(new_points) == type(points), 'failed')
-        self.failUnless(new_points == expected_new_points, 'failed')
+        self.assertTrue(isinstance(new_points, list), 'failed')
+        self.assertTrue(type(new_points) == type(points), 'failed')
+        self.assertTrue(new_points == expected_new_points, 'failed')
 
         # and repeat from 'new_points = g.get_absolute(points)' above
@@ -257 +257 @@
         new_points = g.get_absolute(points)
 
-        self.failUnless(isinstance(new_points, list), 'failed')
-        self.failUnless(type(new_points) == type(points), 'failed')
-        self.failUnless(new_points == expected_new_points, 'failed')
+        self.assertTrue(isinstance(new_points, list), 'failed')
+        self.assertTrue(type(new_points) == type(points), 'failed')
+        self.assertTrue(new_points == expected_new_points, 'failed')
 
     def test_get_absolute_array(self):
@@ -272 +272 @@
         new_points = g.get_absolute(points)
 
-        self.failUnless(isinstance(new_points, num.ndarray), 'failed')
-        self.failUnless(type(new_points) == type(points), 'failed')
+        self.assertTrue(isinstance(new_points, num.ndarray), 'failed')
+        self.assertTrue(type(new_points) == type(points), 'failed')
         msg = 'points=\n%s\nnew_points=\n%s' % (str(points), str(new_points))
         for point, new_point in map(None, points, new_points):
-            self.failUnless(point[0]+x == new_point[0], msg)
-            self.failUnless(point[1]+y == new_point[1], msg)
+            self.assertTrue(point[0]+x == new_point[0], msg)
+            self.assertTrue(point[1]+y == new_point[1], msg)
 
         # test with no supplied offsets
@@ -284 +284 @@
         new_points = g.get_absolute(points)
 
-        self.failUnless(isinstance(new_points, num.ndarray), 'failed')
-        self.failUnless(type(new_points) == type(points), 'failed')
-        self.failUnless(num.alltrue(points == new_points), 'failed')
+        self.assertTrue(isinstance(new_points, num.ndarray), 'failed')
+        self.assertTrue(type(new_points) == type(points), 'failed')
+        self.assertTrue(num.alltrue(points == new_points), 'failed')
 
         # test that calling get_absolute twice does the right thing
@@ -297 +297 @@
         new_points = g.get_absolute(points)
 
-        self.failUnless(isinstance(new_points, num.ndarray), 'failed')
-        self.failUnless(type(new_points) == type(points), 'failed')
+        self.assertTrue(isinstance(new_points, num.ndarray), 'failed')
+        self.assertTrue(type(new_points) == type(points), 'failed')
         msg = ('First call of .get_absolute() returned %s\nexpected %s'
                % (str(new_points), str(expected_new_points)))
-        self.failUnless(num.alltrue(expected_new_points == new_points), msg)
+        self.assertTrue(num.alltrue(expected_new_points == new_points), msg)
 
         # and repeat from 'new_points = g.get_absolute(points)' above
@@ -307 +307 @@
         new_points = g.get_absolute(points)
 
-        self.failUnless(isinstance(new_points, num.ndarray), 'failed')
-        self.failUnless(type(new_points) == type(points), 'failed')
+        self.assertTrue(isinstance(new_points, num.ndarray), 'failed')
+        self.assertTrue(type(new_points) == type(points), 'failed')
         msg = ('Second call of .get_absolute() returned\n%s\nexpected\n%s'
                % (str(new_points), str(expected_new_points)))
-        self.failUnless(num.alltrue(expected_new_points == new_points), msg)
+        self.assertTrue(num.alltrue(expected_new_points == new_points), msg)
 
         # and repeat again to see if *third* call with same input
@@ -317 +317 @@
         new_points = g.get_absolute(points)
 
-        self.failUnless(isinstance(new_points, num.ndarray), 'failed')
-        self.failUnless(type(new_points) == type(points), 'failed')
+        self.assertTrue(isinstance(new_points, num.ndarray), 'failed')
+        self.assertTrue(type(new_points) == type(points), 'failed')
         msg = ('Third call of .get_absolute() returned %s\nexpected %s'
                % (str(new_points), str(expected_new_points)))
-        self.failUnless(num.alltrue(expected_new_points == new_points), msg)
+        self.assertTrue(num.alltrue(expected_new_points == new_points), msg)
 
     def test_get_relative_list(self):
@@ -332 +332 @@
         new_points = g.get_relative(points)
 
-        self.failUnless(isinstance(new_points, list), 'failed')
-        self.failUnless(type(new_points) == type(points), 'failed')
+        self.assertTrue(isinstance(new_points, list), 'failed')
+        self.assertTrue(type(new_points) == type(points), 'failed')
         for point, new_point in map(None, points, new_points):
-            self.failUnless(point[0]-x == new_point[0], 'failed')
-            self.failUnless(point[1]-y == new_point[1], 'failed')
+            self.assertTrue(point[0]-x == new_point[0], 'failed')
+            self.assertTrue(point[1]-y == new_point[1], 'failed')
 
         # test with no supplied offsets
@@ -343 +343 @@
         new_points = g.get_relative(points)
 
-        self.failUnless(isinstance(new_points, list), 'failed')
-        self.failUnless(type(new_points) == type(points), 'failed')
+        self.assertTrue(isinstance(new_points, list), 'failed')
+        self.assertTrue(type(new_points) == type(points), 'failed')
         for point, new_point in map(None, points, new_points):
-            self.failUnless(point[0] == new_point[0], 'failed')
-            self.failUnless(point[1] == new_point[1], 'failed')
+            self.assertTrue(point[0] == new_point[0], 'failed')
+            self.assertTrue(point[1] == new_point[1], 'failed')
             
         # test that calling get_absolute twice does the right thing
@@ -358 +358 @@
         new_points = g.get_relative(points)
 
-        self.failUnless(isinstance(new_points, list), 'failed')
-        self.failUnless(type(new_points) == type(points), 'failed')
-        self.failUnless(new_points == expected_new_points, 'failed')
+        self.assertTrue(isinstance(new_points, list), 'failed')
+        self.assertTrue(type(new_points) == type(points), 'failed')
+        self.assertTrue(new_points == expected_new_points, 'failed')
 
         # and repeat from 'new_points = g.get_absolute(points)' above
@@ -366 +366 @@
         new_points = g.get_relative(points)
 
-        self.failUnless(isinstance(new_points, list), 'failed')
-        self.failUnless(type(new_points) == type(points), 'failed')
-        self.failUnless(new_points == expected_new_points, 'failed')
+        self.assertTrue(isinstance(new_points, list), 'failed')
+        self.assertTrue(type(new_points) == type(points), 'failed')
+        self.assertTrue(new_points == expected_new_points, 'failed')
 
     def test_get_relative_array(self):
@@ -381 +381 @@
         new_points = g.get_relative(points)
 
-        self.failUnless(isinstance(new_points, num.ndarray), 'failed')
-        self.failUnless(type(new_points) == type(points), 'failed')
+        self.assertTrue(isinstance(new_points, num.ndarray), 'failed')
+        self.assertTrue(type(new_points) == type(points), 'failed')
         msg = 'points=\n%s\nnew_points=\n%s' % (str(points), str(new_points))
         for point, new_point in map(None, points, new_points):
-            self.failUnless(point[0]-x == new_point[0], msg)
-            self.failUnless(point[1]-y == new_point[1], msg)
+            self.assertTrue(point[0]-x == new_point[0], msg)
+            self.assertTrue(point[1]-y == new_point[1], msg)
 
         # test with no supplied offsets
@@ -393 +393 @@
         new_points = g.get_relative(points)
 
-        self.failUnless(isinstance(new_points, num.ndarray), 'failed')
-        self.failUnless(type(new_points) == type(points), 'failed')
-        self.failUnless(num.alltrue(points == new_points), 'failed')
+        self.assertTrue(isinstance(new_points, num.ndarray), 'failed')
+        self.assertTrue(type(new_points) == type(points), 'failed')
+        self.assertTrue(num.alltrue(points == new_points), 'failed')
 
         # test that calling get_relative twice does the right thing
@@ -406 +406 @@
         new_points = g.get_relative(points)
 
-        self.failUnless(isinstance(new_points, num.ndarray), 'failed')
-        self.failUnless(type(new_points) == type(points), 'failed')
+        self.assertTrue(isinstance(new_points, num.ndarray), 'failed')
+        self.assertTrue(type(new_points) == type(points), 'failed')
         msg = ('First call of .get_relative() returned %s\nexpected %s'
                % (str(new_points), str(expected_new_points)))
-        self.failUnless(num.alltrue(expected_new_points == new_points), msg)
+        self.assertTrue(num.alltrue(expected_new_points == new_points), msg)
 
         # and repeat from 'new_points = g.get_relative(points)' above
@@ -416 +416 @@
         new_points = g.get_relative(points)
 
-        self.failUnless(isinstance(new_points, num.ndarray), 'failed')
-        self.failUnless(type(new_points) == type(points), 'failed')
+        self.assertTrue(isinstance(new_points, num.ndarray), 'failed')
+        self.assertTrue(type(new_points) == type(points), 'failed')
         msg = ('Second call of .get_relative() returned\n%s\nexpected\n%s'
                % (str(new_points), str(expected_new_points)))
-        self.failUnless(num.alltrue(expected_new_points == new_points), msg)
+        self.assertTrue(num.alltrue(expected_new_points == new_points), msg)
 
         # and repeat again to see if *third* call with same input
@@ -426 +426 @@
         new_points = g.get_relative(points)
 
-        self.failUnless(isinstance(new_points, num.ndarray), 'failed')
-        self.failUnless(type(new_points) == type(points), 'failed')
+        self.assertTrue(isinstance(new_points, num.ndarray), 'failed')
+        self.assertTrue(type(new_points) == type(points), 'failed')
         msg = ('Third call of .get_relative() returned %s\nexpected %s'
                % (str(new_points), str(expected_new_points)))
-        self.failUnless(num.alltrue(expected_new_points == new_points), msg)
+        self.assertTrue(num.alltrue(expected_new_points == new_points), msg)
 
     def test_is_absolute(self):
@@ -447 +447 @@
         new_g = Geo_reference(56,1.9,1.9)
      
-        self.failUnless(g == new_g, 'test___cmp__ failed')   
+        self.assertTrue(g == new_g, 'test___cmp__ failed')   
 
 
@@ -493 +493 @@
             os.remove(point_file)
         else:
-            self.failUnless(0 ==1,
+            self.assertTrue(0 ==1,
                         'bad text file did not raise error!')
             os.remove(point_file)
@@ -517 +517 @@
             os.remove(file_name)
         else:
-            self.failUnless(0 ==1,
+            self.assertTrue(0 ==1,
                         'bad text file did not raise error!')
 
@@ -534 +534 @@
         os.remove(file_name)
 
-        self.failUnless(g == new_g, 'test_read_write_ASCII failed')
+        self.assertTrue(g == new_g, 'test_read_write_ASCII failed')
         
         # this tests a pass
@@ -550 +550 @@
         os.remove(file_name)
 
-        self.failUnless(g == new_g, 'test_read_write_ASCII failed')
+        self.assertTrue(g == new_g, 'test_read_write_ASCII failed')
         
     def test_good_title(self):      
@@ -570 +570 @@
             os.remove(point_file)
         else:
-            self.failUnless(0 ==1,
+            self.assertTrue(0 ==1,
                         'bad text file did not raise error!')
             os.remove(point_file)
@@ -582 +582 @@
             pass
         else:
-            self.failUnless(0 ==1,
+            self.assertTrue(0 ==1,
                         'bad shape did not raise error!')
             os.remove(point_file)
@@ -592 +592 @@
             pass
         else:
-            self.failUnless(0 ==1,
+            self.assertTrue(0 ==1,
                         'bad shape did not raise error!')
             os.remove(point_file)
@@ -609 +609 @@
         new_points[:,0] -= x0
         new_points[:,1] -= y0
-        self.failUnless(num.alltrue(new_points == points))
+        self.assertTrue(num.alltrue(new_points == points))
 
         # points in num.array()
@@ -619 +619 @@
         new_points[:,0] -= x0
         new_points[:,1] -= y0
-        self.failUnless(num.alltrue(new_points == points))
+        self.assertTrue(num.alltrue(new_points == points))
 
     def test_georef_types(self):
@@ -635 +635 @@
         # ensure that basic instance attributes are correct
         g = Geo_reference(56, 1.8, 1.8)
-        self.failUnless(isinstance(g.zone, int),
+        self.assertTrue(isinstance(g.zone, int),
                         "geo_ref .zone should be 'int' type, "
                         "was '%s' type" % type(g.zone))  
-        self.failUnless(isinstance(g.false_easting, int),
+        self.assertTrue(isinstance(g.false_easting, int),
                         "geo_ref .false_easting should be int type, "
                         "was '%s' type" % type(g.false_easting))  
-        self.failUnless(isinstance(g.false_northing, int),
+        self.assertTrue(isinstance(g.false_northing, int),
                         "geo_ref .false_northing should be int type, "
                         "was '%s' type" % type(g.false_northing))
-        self.failUnless(isinstance(g.xllcorner, float),
+        self.assertTrue(isinstance(g.xllcorner, float),
                         "geo_ref .xllcorner should be float type, "
                         "was '%s' type" % type(g.xllcorner))
-        self.failUnless(isinstance(g.yllcorner, float),
+        self.assertTrue(isinstance(g.yllcorner, float),
                         "geo_ref .yllcorner should be float type, "
                         "was '%s' type" % type(g.yllcorner))
@@ -663 +663 @@
         os.remove(file_name)
 
-        self.failUnless(isinstance(new_g.zone, int),
+        self.assertTrue(isinstance(new_g.zone, int),
                         "geo_ref .zone should be 'int' type, "
                         "was '%s' type" % type(new_g.zone))  
-        self.failUnless(isinstance(new_g.false_easting, int),
+        self.assertTrue(isinstance(new_g.false_easting, int),
                         "geo_ref .false_easting should be int type, "
                         "was '%s' type" % type(new_g.false_easting))  
-        self.failUnless(isinstance(new_g.false_northing, int),
+        self.assertTrue(isinstance(new_g.false_northing, int),
                         "geo_ref .false_northing should be int type, "
                         "was '%s' type" % type(new_g.false_northing))
-        self.failUnless(isinstance(new_g.xllcorner, float),
+        self.assertTrue(isinstance(new_g.xllcorner, float),
                         "geo_ref .xllcorner should be float type, "
                         "was '%s' type" % type(new_g.xllcorner))
-        self.failUnless(isinstance(new_g.yllcorner, float),
+        self.assertTrue(isinstance(new_g.yllcorner, float),
                         "geo_ref .yllcorner should be float type, "
                         "was '%s' type" % type(new_g.yllcorner))
@@ -691 +691 @@
         # now provide wrong types but coerceable
         g = Geo_reference(56.0, '1.8', '1.8')
-        self.failUnless(isinstance(g.zone, int),
+        self.assertTrue(isinstance(g.zone, int),
                         "geo_ref .zone should be 'int' type, "
                         "was '%s' type" % type(g.zone))  
-        self.failUnless(isinstance(g.false_easting, int),
+        self.assertTrue(isinstance(g.false_easting, int),
                         "geo_ref .false_easting should be int type, "
                         "was '%s' type" % type(g.false_easting))  
-        self.failUnless(isinstance(g.false_northing, int),
+        self.assertTrue(isinstance(g.false_northing, int),
                         "geo_ref .false_northing should be int type, "
                         "was '%s' type" % type(g.false_northing))
-        self.failUnless(isinstance(g.xllcorner, float),
+        self.assertTrue(isinstance(g.xllcorner, float),
                         "geo_ref .xllcorner should be float type, "
                         "was '%s' type" % type(g.xllcorner))
-        self.failUnless(isinstance(g.yllcorner, float),
+        self.assertTrue(isinstance(g.yllcorner, float),
                         "geo_ref .yllcorner should be float type, "
                         "was '%s' type" % type(g.yllcorner))

trunk/anuga_core/source/anuga/coordinate_transforms/test/test_point.py

@@ -28 +28 @@
 
         # Assert that bearing is correct within double precision
-        self.failUnless((fabs(p1.BearingTo(p2)-0) < eps),\
+        self.assertTrue((fabs(p1.BearingTo(p2)-0) < eps),\
                         'Computed northward bearing: %d, Should have been: %d'\
                          %(p1.BearingTo(p2), 0))
@@ -42 +42 @@
 
         # Assert that bearing is correct within double precision
-        self.failUnless((fabs(p2.BearingTo(p1)-180) < eps),\
+        self.assertTrue((fabs(p2.BearingTo(p1)-180) < eps),\
                         'Computed southhward bearing: %d, Should have been: %d'\
                          %(p2.BearingTo(p1), 180))
@@ -56 +56 @@
 
         # Assert that bearing is correct within double precision
-        self.failUnless((fabs(p3.BearingTo(p1)-270) < eps),\
+        self.assertTrue((fabs(p3.BearingTo(p1)-270) < eps),\
                         'Computed westward bearing: %d, Should have been: %d'\
                          %(p3.BearingTo(p1), 270))
@@ -69 +69 @@
 
         # Assert that bearing is correct within double precision
-        self.failUnless((fabs(p1.BearingTo(p3)-90) < eps),\
+        self.assertTrue((fabs(p1.BearingTo(p3)-90) < eps),\
                         'Computed eastward bearing: %d, Should have been: %d'\
                          %(p1.BearingTo(p3), 90))
@@ -78 +78 @@
         D = 2068   # True Distance to Home
         B = 11     # True Bearing to Home
-        self.failUnless((fabs(self.RSISE.DistanceTo(self.Home) - D)/D < self.eps),\
+        self.assertTrue((fabs(self.RSISE.DistanceTo(self.Home) - D)/D < self.eps),\
                         'Dist to Home failed')
-        self.failUnless((self.RSISE.BearingTo(self.Home) - B == 0),\
+        self.assertTrue((self.RSISE.BearingTo(self.Home) - B == 0),\
                         'Computed bearing to Home: %d, Should have been: %d'\
                          %(self.RSISE.BearingTo(self.Home), B))
@@ -89 +89 @@
         D = 239.5 * 1000   # True Distance to Sydney Airport
         B = 52             # True Bearing to Sydney Airport        
-        self.failUnless((fabs(self.RSISE.DistanceTo(self.Syd) - D)/D < self.eps),\
+        self.assertTrue((fabs(self.RSISE.DistanceTo(self.Syd) - D)/D < self.eps),\
                         'Dist to Sydney failed')
-        self.failUnless((self.RSISE.BearingTo(self.Syd) - B == 0),\
+        self.assertTrue((self.RSISE.BearingTo(self.Syd) - B == 0),\
                         'Computed bearing to Sydney: %d, Should have been: %d'\
                          %(self.RSISE.BearingTo(self.Syd), B))
@@ -99 +99 @@
         D = 3406.1 * 1000   # True Distance to Nadi Airport
         B = 63              # True Bearing to Nadi Airport        
-        self.failUnless((fabs(self.RSISE.DistanceTo(self.Nadi) - D)/D < self.eps),\
+        self.assertTrue((fabs(self.RSISE.DistanceTo(self.Nadi) - D)/D < self.eps),\
                         'Dist to Nadi failed')
         
-        self.failUnless((self.RSISE.BearingTo(self.Nadi) - B == 0),\
+        self.assertTrue((self.RSISE.BearingTo(self.Nadi) - B == 0),\
                         'Computed bearing to Nadi: %d, Should have been: %d'\
                          %(self.RSISE.BearingTo(self.Nadi), B))
@@ -110 +110 @@
         D = 16025 * 1000   # True Distance to Kobenhavn
         B = 319            # True Bearing to Kobenhavn        
-        self.failUnless((fabs(self.RSISE.DistanceTo(self.Kobenhavn) - D)/D < self.eps),\
+        self.assertTrue((fabs(self.RSISE.DistanceTo(self.Kobenhavn) - D)/D < self.eps),\
                         'Computed Distance to Kobenhavn: %d, Should have been: %d' \
                         %(self.RSISE.DistanceTo(self.Kobenhavn), D))
-        self.failUnless((self.RSISE.BearingTo(self.Kobenhavn) - B == 0),\
+        self.assertTrue((self.RSISE.BearingTo(self.Kobenhavn) - B == 0),\
                         'Computed Bearing to Kobenhavn: %d, Should have been: %d' \
                         %(self.RSISE.BearingTo(self.Kobenhavn), B))

trunk/anuga_core/source/anuga/coordinate_transforms/test/test_redfearn.py

@@ -381 +381 @@
         assert num.allclose(points[1][0],  222908.705)
         assert num.allclose(points[1][1], 6233785.284)
-        self.failUnless(zone == 56,
+        self.assertTrue(zone == 56,
                         'Bad zone error!')
         
@@ -406 +406 @@
             pass
         else:
-            self.failUnless(False,
+            self.assertTrue(False,
                             'Error not thrown error!')
             
@@ -429 +429 @@
             pass
         else:
-            self.failUnless(False,
+            self.assertTrue(False,
                             'Error not thrown error!')
 
@@ -452 +452 @@
         assert num.allclose(points[1][0],  222908.705)
         assert num.allclose(points[1][1], 6233785.284)
-        self.failUnless(zone == 56,
+        self.assertTrue(zone == 56,
                         'Bad zone error!')
 

trunk/anuga_core/source/anuga/culvert_flows/__init__.py

@@ -2 +2 @@
 """
 
-pass
+from numpy.testing import Tester
+test = Tester().test
 
 
+
+

trunk/anuga_core/source/anuga/damage_modelling/__init__.py

@@ -2 +2 @@
 """
 
-pass
+from numpy.testing import Tester
+test = Tester().test
 
 

trunk/anuga_core/source/anuga/damage_modelling/test/test_exposure.py

@@ -23 +23 @@
         exposure.get_column("sound")
        
-        self.failUnless(exposure._attribute_dic['sound'][2]==' bang',
-                        'FAILED!')
-        self.failUnless(exposure._attribute_dic['speed'][2]==' 40.0',
+        self.assertTrue(exposure._attribute_dic['sound'][2]==' bang',
+                        'FAILED!')
+        self.assertTrue(exposure._attribute_dic['speed'][2]==' 40.0',
                         'FAILED!')
         
@@ -43 +43 @@
         exposure.get_column("sound")
        
-        self.failUnless(exposure._attribute_dic['sound'][2]==' bang',
-                        'FAILED!')
-        self.failUnless(exposure._attribute_dic['speed'][2]==' 40.0',
+        self.assertTrue(exposure._attribute_dic['sound'][2]==' bang',
+                        'FAILED!')
+        self.assertTrue(exposure._attribute_dic['speed'][2]==' 40.0',
                         'FAILED!')
         
@@ -70 +70 @@
             pass
         else:
-            self.failUnless(0 ==1,  'Assertion not thrown error!')
+            self.assertTrue(0 ==1,  'Assertion not thrown error!')
             
         if not sys.platform == 'win32':
@@ -88 +88 @@
         os.remove(file_name)
 
-        self.failUnless(cmp(e1,e2)==0,
-                        'FAILED!')
-        
-        self.failUnless(cmp(e1,"hey")==1,
+        self.assertTrue(cmp(e1,e2)==0,
+                        'FAILED!')
+        
+        self.assertTrue(cmp(e1,"hey")==1,
                         'FAILED!')
         
@@ -106 +106 @@
         os.remove(file_name)
 
-        self.failUnless(cmp(e3,e2)==0,
+        self.assertTrue(cmp(e3,e2)==0,
                         'FAILED!')
         
@@ -121 +121 @@
         #print "e4",e4._attribute_dic 
         #print "e2",e2._attribute_dic 
-        self.failUnless(cmp(e4,e2)<>0,
+        self.assertTrue(cmp(e4,e2)<>0,
                         'FAILED!')
         
@@ -135 +135 @@
         os.remove(file_name)
 
-        self.failUnless(cmp(e3,e5)<>0,
+        self.assertTrue(cmp(e3,e5)<>0,
                         'FAILED!')
         
@@ -154 +154 @@
         e2 = Exposure(file_name2)
        
-        self.failUnless(cmp(e1,e2)==0,
+        self.assertTrue(cmp(e1,e2)==0,
                         'FAILED!')
         os.remove(file_name)
@@ -176 +176 @@
         assert num.allclose(points[1][0],  222908.705)
         assert num.allclose(points[1][1], 6233785.284)
-        self.failUnless(gsd.get_geo_reference().get_zone() == 56,
+        self.assertTrue(gsd.get_geo_reference().get_zone() == 56,
                         'Bad zone error!')
 
@@ -195 +195 @@
         e1.set_column(new_title, new_values)
         returned_values = e1.get_column(new_title)
-        self.failUnless(returned_values == new_values,
+        self.assertTrue(returned_values == new_values,
                         ' Error!')
         
@@ -202 +202 @@
         e2 = Exposure(file_name2)
         returned_values = e2.get_column(new_title)
-        self.failUnless(returned_values == new_values,
+        self.assertTrue(returned_values == new_values,
                         ' Error!')       
         os.remove(file_name2)
@@ -223 +223 @@
             pass
         else:
-            self.failUnless(0 ==1,  'Error not thrown error!')
+            self.assertTrue(0 ==1,  'Error not thrown error!')
             
         e1.set_column(new_title, new_values, overwrite=True)
         returned_values = e1.get_column(new_title)
-        self.failUnless(returned_values == new_values,
+        self.assertTrue(returned_values == new_values,
                         ' Error!')       
         
@@ -237 +237 @@
             pass
         else:
-            self.failUnless(0 ==1,  'Error not thrown error!')
+            self.assertTrue(0 ==1,  'Error not thrown error!')
             
         new2_title = "long list"
@@ -246 +246 @@
             pass
         else:
-            self.failUnless(0 ==1,  'Error not thrown error!')
+            self.assertTrue(0 ==1,  'Error not thrown error!')
         file_name2 = tempfile.mktemp(".csv")
         e1.save(file_name = file_name2)
@@ -252 +252 @@
         returned_values = e2.get_column(new_title)
         for returned, new in map(None, returned_values, new_values):
-            self.failUnless(returned == str(new), ' Error!')
-        #self.failUnless(returned_values == new_values, ' Error!')       
+            self.assertTrue(returned == str(new), ' Error!')
+        #self.assertTrue(returned_values == new_values, ' Error!')       
         os.remove(file_name2)
         
@@ -261 +261 @@
             pass
         else:
-            self.failUnless(0 ==1,  'Error not thrown error!')
+            self.assertTrue(0 ==1,  'Error not thrown error!')
             
     def test_exposure_csv_loading_x_y(self):
@@ -284 +284 @@
         assert num.allclose(points[2][0], 114.5)
         assert num.allclose(points[2][1], 9)
-        self.failUnless(gsd.get_geo_reference().get_zone() == -1,
+        self.assertTrue(gsd.get_geo_reference().get_zone() == -1,
                         'Bad zone error!')
 
@@ -311 +311 @@
         assert num.allclose(points[2][0], 4.5)
         assert num.allclose(points[2][1], 1.5)
-        self.failUnless(gsd.get_geo_reference().get_zone() == -1,
+        self.assertTrue(gsd.get_geo_reference().get_zone() == -1,
                         'Bad zone error!')
 

trunk/anuga_core/source/anuga/damage_modelling/test/test_inundation_damage.py

@@ -489 +489 @@
         edm._calc_collapse_structures(collapse_probability, verbose_csv=True)
 
-        self.failUnless( edm.struct_damage[0]  == 0.0 and
+        self.assertTrue( edm.struct_damage[0]  == 0.0 and
                          edm.contents_damage[0]  == 0.0,
                         'Error!')
-        self.failUnless( edm.struct_damage[1]  == 1.0 and
+        self.assertTrue( edm.struct_damage[1]  == 1.0 and
                          edm.contents_damage[1]  == 1.0,
                         'Error!')
-        self.failUnless( edm.struct_damage[2]  == 1.0 and
+        self.assertTrue( edm.struct_damage[2]  == 1.0 and
                          edm.contents_damage[2]  == 1.0,
                         'Error!')
-        self.failUnless( edm.struct_damage[3]+ edm.struct_damage[4] == 1.0 and
+        self.assertTrue( edm.struct_damage[3]+ edm.struct_damage[4] == 1.0 and
                          edm.contents_damage[3] + edm.contents_damage[4] ==1.0,
                         'Error!')
@@ -507 +507 @@
             sum_contents += edm.contents_damage[i]
         print "", 
-        self.failUnless( sum_struct == 0.0 and sum_contents  == 0.0,
+        self.assertTrue( sum_struct == 0.0 and sum_contents  == 0.0,
                         'Error!')
         sum_struct = 0.0
@@ -514 +514 @@
             sum_struct += edm.struct_damage[i]
             sum_contents += edm.contents_damage[i]
-        self.failUnless( sum_struct == 2.0 and sum_contents  == 2.0,
+        self.assertTrue( sum_struct == 2.0 and sum_contents  == 2.0,
                         'Error!')
         
@@ -531 +531 @@
         #print "answer",answer 
 
-        self.failUnless( struct_coll_prob ==  answer,
+        self.assertTrue( struct_coll_prob ==  answer,
                         'Error!')
         

trunk/anuga_core/source/anuga/file/__init__.py

@@ -49 +49 @@
 """
 
-pass
+from numpy.testing import Tester
+test = Tester().test
 
+

trunk/anuga_core/source/anuga/file/test/test_ungenerate.py

@@ -62 +62 @@
         Segment.set_default_tag("")
             
-        self.failUnless(len(m.userSegments) ==11,
-                        'Wrong segment list length.')
-        self.failUnless(len(m.userVertices) == 11,
-                        'Wrong vertex list length.')
-        self.failUnless(m.userSegments[10].vertices[0] == m.userVertices[10],
+        self.assertTrue(len(m.userSegments) ==11,
+                        'Wrong segment list length.')
+        self.assertTrue(len(m.userVertices) == 11,
+                        'Wrong vertex list length.')
+        self.assertTrue(m.userSegments[10].vertices[0] == m.userVertices[10],
                         'bad vertex on segment.')
-        self.failUnless(m.userSegments[10].vertices[1] == m.userVertices[8],
+        self.assertTrue(m.userSegments[10].vertices[1] == m.userVertices[8],
                         'Bad segment.')
-        self.failUnless(m.userSegments[10].tag == tag,
+        self.assertTrue(m.userSegments[10].tag == tag,
                         'wrong tag.')
 
@@ -93 +93 @@
         os.remove(fileName)
 
-        self.failUnless(Segment.get_default_tag() == initial_tag,
+        self.assertTrue(Segment.get_default_tag() == initial_tag,
                         'Wrong segment list length.')
         
@@ -100 +100 @@
         Segment.set_default_tag("")
             
-        self.failUnless(len(m.userSegments) ==11,
-                        'Wrong segment list length.')
-        self.failUnless(len(m.userVertices) == 11,
-                        'Wrong vertex list length.')
-        self.failUnless(m.userSegments[10].vertices[0] == m.userVertices[10],
+        self.assertTrue(len(m.userSegments) ==11,
+                        'Wrong segment list length.')
+        self.assertTrue(len(m.userVertices) == 11,
+                        'Wrong vertex list length.')
+        self.assertTrue(m.userSegments[10].vertices[0] == m.userVertices[10],
                         'bad vertex on segment.')
-        self.failUnless(m.userSegments[10].vertices[1] == m.userVertices[8],
+        self.assertTrue(m.userSegments[10].vertices[1] == m.userVertices[8],
                         'Bad segment.')
-        self.failUnless(m.userSegments[10].tag == tag,
+        self.assertTrue(m.userSegments[10].tag == tag,
                         'wrong tag.')
         
@@ -149 +149 @@
         m.addVertsSegs(dict)
 
-        self.failUnless(len(m.userSegments) ==11,
-                        'Wrong segment list length.')
-        self.failUnless(len(m.userVertices) == 11,
+        self.assertTrue(len(m.userSegments) ==11,
+                        'Wrong segment list length.')
+        self.assertTrue(len(m.userVertices) == 11,
                         'Wrong vertex list length.')
 
@@ -173 +173 @@
         os.remove(fileName)
 
-        self.failUnless(Segment.get_default_tag() == initial_tag,
+        self.assertTrue(Segment.get_default_tag() == initial_tag,
                         'Wrong segment list length.')
         m.export_mesh_file("swamp.tsh")
         #print "m.userSegments",m.userSegments
-        self.failUnless(len(m.userSegments) ==11,
-                        'Wrong segment list length.')
-        self.failUnless(len(m.userVertices) == 11,
-                        'Wrong vertex list length.')
-        self.failUnless(len(m.regions) == 2,
+        self.assertTrue(len(m.userSegments) ==11,
+                        'Wrong segment list length.')
+        self.assertTrue(len(m.userVertices) == 11,
+                        'Wrong vertex list length.')
+        self.assertTrue(len(m.regions) == 2,
                         'Wrong regions list length.')
-        self.failUnless(m.regions[0].getTag() == "swamp",
+        self.assertTrue(m.regions[0].getTag() == "swamp",
                         'Wrong regions tag.')
-        self.failUnless(m.regions[1].getTag() == "swamp",
+        self.assertTrue(m.regions[1].getTag() == "swamp",
                         'Wrong regions 1 tag.')
         
@@ -230 +230 @@
         m.addVertsSegs(dict)
 
-        self.failUnless(len(m.userSegments) ==11,
-                        'Wrong segment list length.')
-        self.failUnless(len(m.userVertices) == 11,
+        self.assertTrue(len(m.userSegments) ==11,
+                        'Wrong segment list length.')
+        self.assertTrue(len(m.userVertices) == 11,
                         'Wrong vertex list length.')
 
@@ -254 +254 @@
         os.remove(fileName)
 
-        self.failUnless(Segment.get_default_tag() == initial_tag,
+        self.assertTrue(Segment.get_default_tag() == initial_tag,
                         'Wrong segment list length.')
         m.export_mesh_file("swamp.tsh")
         #print "m.userSegments",m.userSegments
-        self.failUnless(len(m.userSegments) ==11,
-                        'Wrong segment list length.')
-        self.failUnless(len(m.userVertices) == 11,
-                        'Wrong vertex list length.')
-        self.failUnless(len(m.regions) == 2,
+        self.assertTrue(len(m.userSegments) ==11,
+                        'Wrong segment list length.')
+        self.assertTrue(len(m.userVertices) == 11,
+                        'Wrong vertex list length.')
+        self.assertTrue(len(m.regions) == 2,
                         'Wrong regions list length.')
-        self.failUnless(m.regions[0].getTag() == "swamp",
+        self.assertTrue(m.regions[0].getTag() == "swamp",
                         'Wrong regions tag.')
-        self.failUnless(m.regions[1].getTag() == "coastalp",
+        self.assertTrue(m.regions[1].getTag() == "coastalp",
                         'Wrong regions 1 tag.')
         

trunk/anuga_core/source/anuga/file_conversion/__init__.py

@@ -14 +14 @@
 """
 
-pass
+from numpy.testing import Tester
+test = Tester().test
 
 
+

trunk/anuga_core/source/anuga/file_conversion/test/test_file_conversion.py

@@ -843 +843 @@
             pass
         else:
-            self.failUnless(0 ==1,  'Bad input did not throw exception error!')
+            self.assertTrue(0 ==1,  'Bad input did not throw exception error!')
 
     def test_sww_extent(self):

trunk/anuga_core/source/anuga/file_conversion/test/test_sww2dem.py

@@ -1871 +1871 @@
             pass
         else:
-            self.failUnless(0 ==1,  'Bad input did not throw exception error!')
+            self.assertTrue(0 ==1,  'Bad input did not throw exception error!')
         
 

trunk/anuga_core/source/anuga/file_conversion/test/test_urs2sww.py

@@ -381 +381 @@
             pass
         else:
-            self.failUnless(0 ==1, 'Bad input did not throw exception error!')
+            self.assertTrue(0 ==1, 'Bad input did not throw exception error!')
 
         self.delete_mux(files)
@@ -403 +403 @@
             pass
         else:
-            self.failUnless(0 ==1, 'Bad input did not throw exception error!')
+            self.assertTrue(0 ==1, 'Bad input did not throw exception error!')
 
         self.delete_mux(files)

trunk/anuga_core/source/anuga/fit_interpolate/test/test_fit.py

@@ -903 +903 @@
         assert num.allclose(mesh_dic['vertex_attributes'],ans)
 
-        self.failUnless(mesh_dic['vertex_attribute_titles']  ==
+        self.assertTrue(mesh_dic['vertex_attribute_titles']  ==
                         ['elevation','stage'],
                         'test_fit_to_mesh_file failed')
@@ -962 +962 @@
         assert num.allclose(mesh_dic['vertex_attributes'],ans)
 
-        self.failUnless(mesh_dic['vertex_attribute_titles']  ==
+        self.assertTrue(mesh_dic['vertex_attribute_titles']  ==
                         ['elevation','stage'],
                         'test_fit_to_mesh_file failed')
@@ -1016 +1016 @@
                              [1.0, 2.0,5.0,10.0]])
 
-        self.failUnless(mesh_dic['vertex_attribute_titles']  ==
+        self.assertTrue(mesh_dic['vertex_attribute_titles']  ==
                         ['density', 'temp','elevation','stage'],
                         'test_fit_to_mesh_file failed')
@@ -1059 +1059 @@
             pass
         else:
-            #self.failUnless(0 ==1,  'Bad file did not raise error!')
+            #self.assertTrue(0 ==1,  'Bad file did not raise error!')
             raise Exception('Bad file did not raise error!')
             

trunk/anuga_core/source/anuga/fit_interpolate/test/test_interpolate.py

@@ -770 +770 @@
 
         for i in range(4):
-            self.failUnless( z[0,i] == answer[0,i], 'Fail!')
+            self.assertTrue( z[0,i] == answer[0,i], 'Fail!')
         
         z = interp.interpolate(f, point_coords, start_blocking_len = 2)
@@ -778 +778 @@
         
         for i in range(4):
-            self.failUnless( z[0,i] == answer[0,i], 'Fail!')
+            self.assertTrue( z[0,i] == answer[0,i], 'Fail!')
         
         
@@ -1430 +1430 @@
         msg = 'Interpolation failed'
         assert num.allclose(I.precomputed_values['Attribute'][1], [60, 60]), msg
-        #self.failUnless( I.precomputed_values['Attribute'][1] == 60.0,
+        #self.assertTrue( I.precomputed_values['Attribute'][1] == 60.0,
         #                ' failed')
         
@@ -1497 +1497 @@
         t = time[0]
         for j in range(50): #t in [1, 6]
-            self.failUnless(I(t, 5) == NAN, 'Fail!')
+            self.assertTrue(I(t, 5) == NAN, 'Fail!')
             t += 0.1  
             
@@ -1713 +1713 @@
         assert num.allclose(z[4:10], answer[4:10])
         for i in [2,3,11]:
-            self.failUnless( z[i,1] == answer[11,1], 'Fail!')
-            self.failUnless( z[i,0] == answer[11,0], 'Fail!')
+            self.assertTrue( z[i,1] == answer[11,1], 'Fail!')
+            self.assertTrue( z[i,0] == answer[11,0], 'Fail!')
 
 
@@ -1775 +1775 @@
         assert num.allclose(z[5:6], answer[5:6])
         for i in [2,3,4]:
-            self.failUnless( z[i,1] == answer[2,1], 'Fail!')
-            self.failUnless( z[i,0] == answer[2,0], 'Fail!')
+            self.assertTrue( z[i,1] == answer[2,1], 'Fail!')
+            self.assertTrue( z[i,0] == answer[2,0], 'Fail!')
 
 
@@ -1934 +1934 @@
             interp = Interpolate(vertices, triangles)
         except RuntimeError:
-            self.failUnless(0 ==1,  'quad fails with 14 verts at the same \
+            self.assertTrue(0 ==1,  'quad fails with 14 verts at the same \
             position. Should be able to handle any number.')
         f = linear_function(vertices)

trunk/anuga_core/source/anuga/geometry/__init__.py

@@ -6 +6 @@
 
 
-pass
+from numpy.testing import Tester
+test = Tester().test
 
+

trunk/anuga_core/source/anuga/geometry/test/test_polygon.py

@@ -876 +876 @@
         self.failIf(status!=3, 'Expected status 3, got status=%s, value=%s' %
                                (str(status), str(value)))
-        self.failUnless(value is None, 'Expected value of None, got %s' %
+        self.assertTrue(value is None, 'Expected value of None, got %s' %
                                        str(value))
 
@@ -887 +887 @@
         self.failIf(status!=3, 'Expected status 3, got status=%s, value=%s' %
                                (str(status), str(value)))
-        self.failUnless(value is None, 'Expected value of None, got %s' %
+        self.assertTrue(value is None, 'Expected value of None, got %s' %
                                        str(value))
 
@@ -898 +898 @@
         self.failIf(status!=3, 'Expected status 3, got status=%s, value=%s' %
                                (str(status), str(value)))
-        self.failUnless(value is None, 'Expected value of None, got %s' %
+        self.assertTrue(value is None, 'Expected value of None, got %s' %
                                        str(value))
 
@@ -909 +909 @@
         self.failIf(status!=3, 'Expected status 3, got status=%s, value=%s' %
                                (str(status), str(value)))
-        self.failUnless(value is None, 'Expected value of None, got %s' %
+        self.assertTrue(value is None, 'Expected value of None, got %s' %
                                        str(value))
 
@@ -924 +924 @@
         self.failIf(status!=2, 'Expected status 2, got status=%s, value=%s' %
                                (str(status), str(value)))
-        self.failUnless(num.allclose(value, line0))
+        self.assertTrue(num.allclose(value, line0))
 
         # line0 fully within line1, same direction
@@ -936 +936 @@
         self.failIf(status!=2, 'Expected status 2, got status=%s, value=%s' %
                                (str(status), str(value)))
-        self.failUnless(num.allclose(value, line0))
+        self.assertTrue(num.allclose(value, line0))
 
         # line0 fully within line1, opposite direction
@@ -948 +948 @@
         self.failIf(status!=2, 'Expected status 2, got status=%s, value=%s' %
                                (str(status), str(value)))
-        self.failUnless(num.allclose(value, line0))
+        self.assertTrue(num.allclose(value, line0))
 
         # line0 fully within line1, opposite direction
@@ -960 +960 @@
         self.failIf(status!=2, 'Expected status 2, got status=%s, value=%s' %
                                (str(status), str(value)))
-        self.failUnless(num.allclose(value, line0))
+        self.assertTrue(num.allclose(value, line0))
 
         # ----------------------------------------------------------------------
@@ -974 +974 @@
         self.failIf(status!=2, 'Expected status 2, got status=%s, value=%s' %
                                (str(status), str(value)))
-        self.failUnless(num.allclose(value, line1))
+        self.assertTrue(num.allclose(value, line1))
 
         # line1 fully within line0, same direction
@@ -986 +986 @@
         self.failIf(status!=2, 'Expected status 2, got status=%s, value=%s' %
                                (str(status), str(value)))
-        self.failUnless(num.allclose(value, line1))
+        self.assertTrue(num.allclose(value, line1))
 
         # line1 fully within line0, opposite direction
@@ -998 +998 @@
         self.failIf(status!=2, 'Expected status 2, got status=%s, value=%s' %
                                (str(status), str(value)))
-        self.failUnless(num.allclose(value, line1))
+        self.assertTrue(num.allclose(value, line1))
 
         # line1 fully within line0, opposite direction
@@ -1010 +1010 @@
         self.failIf(status!=2, 'Expected status 2, got status=%s, value=%s' %
                                (str(status), str(value)))
-        self.failUnless(num.allclose(value, line1))
+        self.assertTrue(num.allclose(value, line1))
 
         # ----------------------------------------------------------------------
@@ -1024 +1024 @@
         self.failIf(status!=2, 'Expected status 2, got status=%s, value=%s' %
                                (str(status), str(value)))
-        self.failUnless(num.allclose(value, [line1[0],line0[1]]))
+        self.assertTrue(num.allclose(value, [line1[0],line0[1]]))
 
         # line in same direction, partial overlap
@@ -1036 +1036 @@
         self.failIf(status!=2, 'Expected status 2, got status=%s, value=%s' %
                                (str(status), str(value)))
-        self.failUnless(num.allclose(value, [line0[0],line1[1]]))
+        self.assertTrue(num.allclose(value, [line0[0],line1[1]]))
 
         # line in opposite direction, partial overlap
@@ -1048 +1048 @@
         self.failIf(status!=2, 'Expected status 2, got status=%s, value=%s' %
                                (str(status), str(value)))
-        self.failUnless(num.allclose(value, [line0[0],line1[0]]))
+        self.assertTrue(num.allclose(value, [line0[0],line1[0]]))
 
         # line in opposite direction, partial overlap
@@ -1060 +1060 @@
         self.failIf(status!=2, 'Expected status 2, got status=%s, value=%s' %
                                (str(status), str(value)))
-        self.failUnless(num.allclose(value, [line1[1],line0[1]]))
+        self.assertTrue(num.allclose(value, [line1[1],line0[1]]))
 
         # ----------------------------------------------------------------------
@@ -1074 +1074 @@
         self.failIf(status!=2, 'Expected status 2, got status=%s, value=%s' %
                                (str(status), str(value)))
-        self.failUnless(num.allclose(value, [line0[0],line1[1]]))
+        self.assertTrue(num.allclose(value, [line0[0],line1[1]]))
 
         # line in same direction, partial overlap
@@ -1086 +1086 @@
         self.failIf(status!=2, 'Expected status 2, got status=%s, value=%s' %
                                (str(status), str(value)))
-        self.failUnless(num.allclose(value, [line1[0],line0[1]]))
+        self.assertTrue(num.allclose(value, [line1[0],line0[1]]))
 
         # line in opposite direction, partial overlap
@@ -1098 +1098 @@
         self.failIf(status!=2, 'Expected status 2, got status=%s, value=%s' %
                                (str(status), str(value)))
-        self.failUnless(num.allclose(value, [line1[1],line0[1]]))
+        self.assertTrue(num.allclose(value, [line1[1],line0[1]]))
 
         # line in opposite direction, partial overlap
@@ -1110 +1110 @@
         self.failIf(status!=2, 'Expected status 2, got status=%s, value=%s' %
                                (str(status), str(value)))
-        self.failUnless(num.allclose(value, [line0[0],line1[0]]))
+        self.assertTrue(num.allclose(value, [line0[0],line1[0]]))
 
         # ----------------------------------------------------------------------
@@ -1124 +1124 @@
         self.failIf(status!=2, 'Expected status 2, got status=%s, value=%s' %
                                (str(status), str(value)))
-        self.failUnless(num.allclose(value, line0))
+        self.assertTrue(num.allclose(value, line0))
 
         # line in same direction, same left point, line1 longer
@@ -1136 +1136 @@
         self.failIf(status!=2, 'Expected status 2, got status=%s, value=%s' %
                                (str(status), str(value)))
-        self.failUnless(num.allclose(value, line0))
+        self.assertTrue(num.allclose(value, line0))
 
         # line in opposite direction, same left point, line1 longer
@@ -1148 +1148 @@
         self.failIf(status!=2, 'Expected status 2, got status=%s, value=%s' %
                                (str(status), str(value)))
-        self.failUnless(num.allclose(value, line0))
+        self.assertTrue(num.allclose(value, line0))
 
         # line in opposite direction, same start point, line1 longer
@@ -1160 +1160 @@
         self.failIf(status!=2, 'Expected status 2, got status=%s, value=%s' %
                                (str(status), str(value)))
-        self.failUnless(num.allclose(value, line0))
+        self.assertTrue(num.allclose(value, line0))
 
         # ----------------------------------------------------------------------
@@ -1174 +1174 @@
         self.failIf(status!=2, 'Expected status 2, got status=%s, value=%s' %
                                (str(status), str(value)))
-        self.failUnless(num.allclose(value, line0))
+        self.assertTrue(num.allclose(value, line0))
 
         # line in same direction, same left point, same right point
@@ -1186 +1186 @@
         self.failIf(status!=2, 'Expected status 2, got status=%s, value=%s' %
                                (str(status), str(value)))
-        self.failUnless(num.allclose(value, line0))
+        self.assertTrue(num.allclose(value, line0))
 
         # line in opposite direction, same left point, same right point
@@ -1198 +1198 @@
         self.failIf(status!=2, 'Expected status 2, got status=%s, value=%s' %
                                (str(status), str(value)))
-        self.failUnless(num.allclose(value, line0))
+        self.assertTrue(num.allclose(value, line0))
 
         # line in opposite direction, same left point, same right point
@@ -1210 +1210 @@
         self.failIf(status!=2, 'Expected status 2, got status=%s, value=%s' %
                                (str(status), str(value)))
-        self.failUnless(num.allclose(value, line0))
+        self.assertTrue(num.allclose(value, line0))
 
         # ----------------------------------------------------------------------
@@ -1224 +1224 @@
         self.failIf(status!=2, 'Expected status 2, got status=%s, value=%s' %
                                (str(status), str(value)))
-        self.failUnless(num.allclose(value, line0))
+        self.assertTrue(num.allclose(value, line0))
 
         # line in same direction, same right point, line1 longer
@@ -1236 +1236 @@
         self.failIf(status!=2, 'Expected status 2, got status=%s, value=%s' %
                                (str(status), str(value)))
-        self.failUnless(num.allclose(value, line0))
+        self.assertTrue(num.allclose(value, line0))
 
         # line in opposite direction, same right point, line1 longer
@@ -1248 +1248 @@
         self.failIf(status!=2, 'Expected status 2, got status=%s, value=%s' %
                                (str(status), str(value)))
-        self.failUnless(num.allclose(value, line0))
+        self.assertTrue(num.allclose(value, line0))
 
         # line in opposite direction, same right point, line1 longer
@@ -1260 +1260 @@
         self.failIf(status!=2, 'Expected status 2, got status=%s, value=%s' %
                                (str(status), str(value)))
-        self.failUnless(num.allclose(value, line0))
+        self.assertTrue(num.allclose(value, line0))
 
         # ----------------------------------------------------------------------
@@ -1274 +1274 @@
         self.failIf(status!=2, 'Expected status 2, got status=%s, value=%s' %
                                (str(status), str(value)))
-        self.failUnless(num.allclose(value, line1))
+        self.assertTrue(num.allclose(value, line1))
 
         # line in same direction, same left point, line0 longer
@@ -1286 +1286 @@
         self.failIf(status!=2, 'Expected status 2, got status=%s, value=%s' %
                                (str(status), str(value)))
-        self.failUnless(num.allclose(value, line1))
+        self.assertTrue(num.allclose(value, line1))
 
         # line in opposite direction, same left point, line0 longer
@@ -1298 +1298 @@
         self.failIf(status!=2, 'Expected status 2, got status=%s, value=%s' %
                                (str(status), str(value)))
-        self.failUnless(num.allclose(value, line1))
+        self.assertTrue(num.allclose(value, line1))
 
         # line in opposite direction, same left point, line0 longer
@@ -1310 +1310 @@
         self.failIf(status!=2, 'Expected status 2, got status=%s, value=%s' %
                                (str(status), str(value)))
-        self.failUnless(num.allclose(value, line1))
+        self.assertTrue(num.allclose(value, line1))
 
         # ----------------------------------------------------------------------
@@ -1324 +1324 @@
         self.failIf(status!=2, 'Expected status 2, got status=%s, value=%s' %
                                (str(status), str(value)))
-        self.failUnless(num.allclose(value, line1))
+        self.assertTrue(num.allclose(value, line1))
 
         # line in same direction, same right point, line0 longer
@@ -1336 +1336 @@
         self.failIf(status!=2, 'Expected status 2, got status=%s, value=%s' %
                                (str(status), str(value)))
-        self.failUnless(num.allclose(value, line1))
+        self.assertTrue(num.allclose(value, line1))
 
         # line in opposite direction, same right point, line0 longer
@@ -1348 +1348 @@
         self.failIf(status!=2, 'Expected status 2, got status=%s, value=%s' %
                                (str(status), str(value)))
-        self.failUnless(num.allclose(value, line1))
+        self.assertTrue(num.allclose(value, line1))
 
         # line in opposite direction, same right point, line0 longer
@@ -1360 +1360 @@
         self.failIf(status!=2, 'Expected status 2, got status=%s, value=%s' %
                                (str(status), str(value)))
-        self.failUnless(num.allclose(value, line1))
+        self.assertTrue(num.allclose(value, line1))
 
 

trunk/anuga_core/source/anuga/geospatial_data/__init__.py

@@ -5 +5 @@
 
 
+from numpy.testing import Tester
+test = Tester().test
 

trunk/anuga_core/source/anuga/geospatial_data/test/test_geospatial_data.py

@@ -112 +112 @@
         assert num.allclose(V, [79.4, -7])
 
-                # FIXME: use failUnlessRaises()
+                # FIXME: use assertRaises()
         try:
             V = G.get_attributes('hdnoatedu') #Invalid
@@ -1101 +1101 @@
         answer = [10.0, 0.0, 10.4]
         assert num.allclose(results.get_attributes('brightness'), answer)
-        self.failUnless(geo_reference == geo_reference,
+        self.assertTrue(geo_reference == geo_reference,
                         'test_writepts failed. Test geo_reference')
 
@@ -1165 +1165 @@
         assert num.allclose(results.get_data_points(False),
                             [[1.0, 0.0], [0.0, 1.0], [1.0, 0.0]])
-        self.failUnless(geo_reference == geo_reference,
+        self.assertTrue(geo_reference == geo_reference,
                         'test_writepts failed. Test geo_reference')
 
@@ -1329 +1329 @@
         assert num.allclose(G.get_attributes(attribute_name='brightness'),
                             answer)
-        self.failUnless(G.get_geo_reference() == geo_reference1,
+        self.assertTrue(G.get_geo_reference() == geo_reference1,
                         'test_writepts failed. Test geo_reference')
 
@@ -1528 +1528 @@
         assert num.allclose(points[1][0], 222908.705)
         assert num.allclose(points[1][1], 6233785.284)
-        self.failUnless(gsd.get_geo_reference().get_zone() == 56,
+        self.assertTrue(gsd.get_geo_reference().get_zone() == 56,
                         'Bad zone error!')
 
-        # use self.failUnlessRaises(ValueError, Geospatial_data(latitudes=lats))
+        # use self.assertRaises(ValueError, Geospatial_data(latitudes=lats))
         try:
             results = Geospatial_data(latitudes=lats)
@@ -1582 +1582 @@
         assert num.allclose(points[1][0], 222908.705)
         assert num.allclose(points[1][1], 6233785.284)
-        self.failUnless(gsd.get_geo_reference().get_zone() == 56,
+        self.assertTrue(gsd.get_geo_reference().get_zone() == 56,
                         'Bad zone error!')
 
@@ -1640 +1640 @@
             assert num.allclose(points[1][1], 6233785.284)
 
-        self.failUnless(gsd.get_geo_reference().get_zone() == 56,
+        self.assertTrue(gsd.get_geo_reference().get_zone() == 56,
                         'Bad zone error!')
         points = gsd.get_data_points(as_lat_long=True)
@@ -1653 +1653 @@
         points = [[1.0, 2.1], [3.0, 5.3]]
         G = Geospatial_data(points)
-        self.failUnless(2 == len(G), 'Len error!')
+        self.assertTrue(2 == len(G), 'Len error!')
 
         points = [[1.0, 2.1]]
         G = Geospatial_data(points)
-        self.failUnless(1 == len(G), 'Len error!')
+        self.assertTrue(1 == len(G), 'Len error!')
 
         points = [[1.0, 2.1], [3.0, 5.3], [3.0, 5.3], [3.0, 5.3]]
         G = Geospatial_data(points)
-        self.failUnless(4 == len(G), 'Len error!')
+        self.assertTrue(4 == len(G), 'Len error!')
 
     def test_split(self):

trunk/anuga_core/source/anuga/lib/__init__.py

@@ -2 +2 @@
 """
 
-pass
+from numpy.testing import Tester
+test = Tester().test
 
 
@@ -8 +9 @@
 
 
+

trunk/anuga_core/source/anuga/lib/test/test_maxasc.py

@@ -95 +95 @@
         in_file = os.path.join(test_path, 'test1.asc')
         expected_file = os.path.join(test_path, 'test1_bad_num_lines.asc')
-        self.failUnlessRaises(RuntimeError, MaxAsc,
+        self.assertRaises(RuntimeError, MaxAsc,
                               'test.out.asc',
                               [in_file, expected_file])
@@ -103 +103 @@
         in_file = os.path.join(test_path, 'test1.asc')
         expected_file = os.path.join(test_path, 'test1_bad_num_lines.asc')
-        self.failUnlessRaises(RuntimeError, MaxAsc,
+        self.assertRaises(RuntimeError, MaxAsc,
                               'test.out.asc',
                               [in_file, expected_file])
@@ -111 +111 @@
         in_file = os.path.join(test_path, 'test1.asc')
         expected_file = os.path.join(test_path, 'test1_wrong_num_columns.asc')
-        self.failUnlessRaises(RuntimeError, MaxAsc,
+        self.assertRaises(RuntimeError, MaxAsc,
                               'test.out.asc',
                               [in_file, expected_file])
@@ -119 +119 @@
         in_file = os.path.join(test_path, 'test1.asc')
         MaxAsc('test1.out.asc', [in_file])
-        self.failUnless(FilesEqual('test1.out.asc', in_file))
+        self.assertTrue(FilesEqual('test1.out.asc', in_file))
 
 
@@ -126 +126 @@
         in_file = os.path.join(test_path, 'test1.asc')
         MaxAsc('test1.out.asc', [in_file] * 30)
-        self.failUnless(FilesEqual('test1.out.asc', in_file))
+        self.assertTrue(FilesEqual('test1.out.asc', in_file))
 
     def test_different_input2(self):
@@ -134 +134 @@
         expected_file = os.path.join(test_path, 'test2.expected.asc')
         MaxAsc('test2.out.asc', [in_file, in_file2])
-        self.failUnless(FilesEqual('test2.out.asc', expected_file))
+        self.assertTrue(FilesEqual('test2.out.asc', expected_file))
 
     def test_different_input3(self):
@@ -143 +143 @@
         expected_file = os.path.join(test_path, 'test3.expected.asc')
         MaxAsc('test3.out.asc', [in_file, in_file2, in_file3])
-        self.failUnless(FilesEqual('test3.out.asc', expected_file))
+        self.assertTrue(FilesEqual('test3.out.asc', expected_file))
 
 if __name__ == '__main__':

trunk/anuga_core/source/anuga/lib/test/test_order_boundary.py

@@ -97 +97 @@
 
         # check same as Expected
-        self.failUnless(data_list == Expected)
+        self.assertTrue(data_list == Expected)
 
         # clean up
@@ -376 +376 @@
 
         # check same as expected
-        self.failUnless(data_list == expected)
+        self.assertTrue(data_list == expected)
 
         # clean up

trunk/anuga_core/source/anuga/load_mesh/__init__.py

@@ -1 +1 @@
 #nothing
+
+from numpy.testing import Tester
+test = Tester().test

trunk/anuga_core/source/anuga/load_mesh/test/test_loadASCII.py

@@ -194 +194 @@
         loadedDict = import_mesh_file(fileName)
 
-        self.failUnless(num.alltrue(num.array(meshDict['vertices']) ==
+        self.assertTrue(num.alltrue(num.array(meshDict['vertices']) ==
                                     num.array(loadedDict['vertices'])),
                         'test_export_mesh_file failed. Test 1')
-        self.failUnless(num.alltrue(num.array(meshDict['triangles']) ==
+        self.assertTrue(num.alltrue(num.array(meshDict['triangles']) ==
                                     num.array(loadedDict['triangles'])),
                         'test_export_mesh_file failed. Test 2')
-        self.failUnless(num.alltrue(num.array(meshDict['segments']) ==
+        self.assertTrue(num.alltrue(num.array(meshDict['segments']) ==
                                     num.array(loadedDict['segments'])),
                         'test_export_mesh_file failed. Test 3')
-        self.failUnless(num.alltrue(num.array(meshDict['triangle_tags']) ==
+        self.assertTrue(num.alltrue(num.array(meshDict['triangle_tags']) ==
                                     num.array(loadedDict['triangle_tags'])),
                         'test_export_mesh_file failed. Test 4')
 
-        self.failUnless(meshDict['vertex_attributes'] ==
+        self.assertTrue(meshDict['vertex_attributes'] ==
                         loadedDict['vertex_attributes'],
                         'test_export_mesh_file failed. Test 5')
-        self.failUnless(num.alltrue(num.array(meshDict['triangle_neighbors']) ==
+        self.assertTrue(num.alltrue(num.array(meshDict['triangle_neighbors']) ==
                                     num.array(loadedDict['triangle_neighbors'])),
                         'test_export_mesh_file failed. Test 6')
-        self.failUnless(num.alltrue(num.array(meshDict['segment_tags']) ==
+        self.assertTrue(num.alltrue(num.array(meshDict['segment_tags']) ==
                                     num.array(loadedDict['segment_tags'])),
                         'test_export_mesh_file failed. Test 7')
-        self.failUnless(num.alltrue(num.array(meshDict['vertex_attribute_titles']) ==
+        self.assertTrue(num.alltrue(num.array(meshDict['vertex_attribute_titles']) ==
                                     num.array(loadedDict['vertex_attribute_titles'])),
                         'test_export_mesh_file failed. Test 8')
-        self.failUnless(num.alltrue(num.array(meshDict['geo_reference']) ==
+        self.assertTrue(num.alltrue(num.array(meshDict['geo_reference']) ==
                                     num.array(loadedDict['geo_reference'])),
                         'test_export_mesh_file failed. Test 9')
@@ -233 +233 @@
         
 
-        self.failUnless(num.alltrue(num.array(meshDict['vertices']) ==
+        self.assertTrue(num.alltrue(num.array(meshDict['vertices']) ==
                                     num.array(loadedDict['vertices'])),
                         'test_export_mesh_file failed. Test 1')
-        self.failUnless(num.alltrue(num.array(meshDict['triangles']) ==
+        self.assertTrue(num.alltrue(num.array(meshDict['triangles']) ==
                                     num.array(loadedDict['triangles'])),
                         'test_export_mesh_file failed. Test 2')
-        self.failUnless(num.alltrue(num.array(meshDict['segments']) ==
+        self.assertTrue(num.alltrue(num.array(meshDict['segments']) ==
                                     num.array(loadedDict['segments'])),
                         'test_export_mesh_file failed. Test 3')
-        self.failUnless(num.alltrue(num.array(meshDict['triangle_tags']) ==
+        self.assertTrue(num.alltrue(num.array(meshDict['triangle_tags']) ==
                                     num.array(loadedDict['triangle_tags'])),
                         'test_export_mesh_file failed. Test 4')
 
-        self.failUnless(meshDict['vertex_attributes'] ==
+        self.assertTrue(meshDict['vertex_attributes'] ==
                         loadedDict['vertex_attributes'],
                         'test_export_mesh_file failed. Test 5')
-        self.failUnless(num.alltrue(num.array(meshDict['triangle_neighbors']) ==
+        self.assertTrue(num.alltrue(num.array(meshDict['triangle_neighbors']) ==
                                     num.array(loadedDict['triangle_neighbors'])),
                         'test_export_mesh_file failed. Test 6')
-        self.failUnless(num.alltrue(num.array(meshDict['segment_tags']) ==
+        self.assertTrue(num.alltrue(num.array(meshDict['segment_tags']) ==
                                     num.array(loadedDict['segment_tags'])),
                         'test_export_mesh_file failed. Test 7')
-        self.failUnless(num.alltrue(num.array(meshDict['vertex_attribute_titles']) ==
+        self.assertTrue(num.alltrue(num.array(meshDict['vertex_attribute_titles']) ==
                                     num.array(loadedDict['vertex_attribute_titles'])),
                         'test_export_mesh_file failed. Test 8')
-        self.failUnless(num.alltrue(num.array(meshDict['geo_reference']) ==
+        self.assertTrue(num.alltrue(num.array(meshDict['geo_reference']) ==
                                     num.array(loadedDict['geo_reference'])),
                         'test_export_mesh_file failed. Test 9')
@@ -329 +329 @@
             pass
         else:
-            self.failUnless(0 == 1, 'imaginary file did not raise error!')
+            self.assertTrue(0 == 1, 'imaginary file did not raise error!')
 
     def test_read_write_tsh_file_bad(self):
@@ -339 +339 @@
             pass
         else:
-            self.failUnless(0 == 1, 'bad tsh file did not raise error!')
+            self.assertTrue(0 == 1, 'bad tsh file did not raise error!')
 
     def test_import_tsh_bad(self):
@@ -438 +438 @@
                             num.array(dict['outline_segments']))
 
-        self.failUnless(loaded_dict['outline_segment_tags'] ==
+        self.assertTrue(loaded_dict['outline_segment_tags'] ==
                         dict['outline_segment_tags'],
                         fail_string + ' failed!! Test 4')
@@ -445 +445 @@
                             num.array(dict['regions']))
 
-        self.failUnless(loaded_dict['region_tags'] == dict['region_tags'],
+        self.assertTrue(loaded_dict['region_tags'] == dict['region_tags'],
                         fail_string + ' failed!! Test 5')
 
@@ -465 +465 @@
                             loaded_dict['triangle_tags']):
             msg = ('ob=\n%s\nshould be same as ldob=\n%s' % (str(ob), str(ldob)))
-            self.failUnless(ob == ldob,
+            self.assertTrue(ob == ldob,
                             fail_string + ' failed\n' + msg)
 
         # A bit hacky
-        self.failUnless(num.alltrue(loaded_dict['vertex_attributes'] ==
+        self.assertTrue(num.alltrue(loaded_dict['vertex_attributes'] ==
                                     dict['vertex_attributes']) or
                                     (loaded_dict['vertex_attributes'] ==
@@ -483 +483 @@
             msg = ('seg=\n"%s"\nshould be same as ldseg=\n"%s"'
                    % (str(seg), str(ldseg)))
-            self.failUnless(seg == ldseg, fail_string + ' failed\n' + msg)
+            self.assertTrue(seg == ldseg, fail_string + ' failed\n' + msg)
 
         try:
@@ -489 +489 @@
                                 num.array(loaded_dict['vertex_attribute_titles']))
         except IndexError:
-            self.failUnless(num.alltrue(num.array(loaded_dict['vertex_attribute_titles'])
+            self.assertTrue(num.alltrue(num.array(loaded_dict['vertex_attribute_titles'])
                             == num.array(dict['vertex_attribute_titles'])),
                             fail_string + ' failed!! Test 8')
@@ -498 +498 @@
                   % (str(loaded_dict['geo_reference']),
                      str(dict['geo_reference'])))
-            self.failUnless(loaded_dict['geo_reference'] ==
+            self.assertTrue(loaded_dict['geo_reference'] ==
                             dict['geo_reference'],
                             fail_string + ' failed\n' + msg)
@@ -504 +504 @@
             msg = ("'dict' has no key 'geo_reference' "
                    "but loaded_dict['geo_reference'] isn't None")
-            self.failUnless(not dict.has_key('geo_reference') and
+            self.assertTrue(not dict.has_key('geo_reference') and
                                 loaded_dict['geo_reference'] == None,
                             fail_string + ' failed\n' + msg)

trunk/anuga_core/source/anuga/mesh_engine/__init__.py

@@ -1 +1 @@
 #nothing
+
+from numpy.testing import Tester
+test = Tester().test

trunk/anuga_core/source/anuga/mesh_engine/test/test_generate_mesh.py

@@ -44 +44 @@
 
         correct = num.array([(1, 0, 2), (2, 3, 1)])
-        self.failUnless(num.alltrue(data['generatedtrianglelist'].flat == \
+        self.assertTrue(num.alltrue(data['generatedtrianglelist'].flat == \
                                     correct.flat),
                         'trianglelist is wrong!')
         correct = num.array([(0, 1), (1, 3), (3, 2), (2, 0)])
-        self.failUnless(num.alltrue(data['generatedsegmentlist'].flat == \
+        self.assertTrue(num.alltrue(data['generatedsegmentlist'].flat == \
                                     correct.flat),
                         'segmentlist is wrong!')
@@ -54 +54 @@
         correct = num.array([(0.0, 0.0), (0.0, 10.0),
                              (3.0, 0.0), (3.0, 10.0)])
-        self.failUnless(num.allclose(data['generatedpointlist'].flat, \
+        self.assertTrue(num.allclose(data['generatedpointlist'].flat, \
                                      correct.flat),
                         'Failed')
@@ -75 +75 @@
                               pointattlist,segattlist, mode, points)
         correct = num.array([(1, 0, 2), (2, 3, 1)])
-        self.failUnless(num.alltrue(data['generatedtrianglelist'].flat == \
+        self.assertTrue(num.alltrue(data['generatedtrianglelist'].flat == \
                                     correct.flat),
                         'trianglelist is wrong!')
         correct = num.array([(0, 1), (1, 3), (3, 2), (2, 0)])
-        self.failUnless(num.alltrue(data['generatedsegmentlist'].flat == \
+        self.assertTrue(num.alltrue(data['generatedsegmentlist'].flat == \
                                     correct.flat),
                         'segmentlist is wrong!')
@@ -85 +85 @@
         correct = num.array([(0.0, 0.0), (0.0, 10.0),
                              (3.0, 0.0), (3.0, 10.0)])
-        self.failUnless(num.allclose(data['generatedpointlist'].flat, \
+        self.assertTrue(num.allclose(data['generatedpointlist'].flat, \
                                      correct.flat),
                         'Failed')
@@ -111 +111 @@
             pass
         else:
-            self.failUnless(0 ==1,
+            self.assertTrue(0 ==1,
                         'bad list did not raise error!')
             
@@ -136 +136 @@
             pass
         else:
-            self.failUnless(0 ==1,
+            self.assertTrue(0 ==1,
                         'bad list did not raise error!')
             
@@ -155 +155 @@
 
         correct = num.array([(1, 0, 2), (2, 3, 1)])
-        self.failUnless(num.alltrue(data['generatedtrianglelist'].flat == \
+        self.assertTrue(num.alltrue(data['generatedtrianglelist'].flat == \
                                     correct.flat),
                         'trianglelist is wrong!')
         correct = num.array([(0, 1), (1, 3), (3, 2), (2, 0)])
-        self.failUnless(num.alltrue(data['generatedsegmentlist'].flat == \
+        self.assertTrue(num.alltrue(data['generatedsegmentlist'].flat == \
                                     correct.flat),
                         'segmentlist is wrong!')
@@ -165 +165 @@
         correct = num.array([(0.0, 0.0), (0.0, 10.0),
                              (3.0, 0.0), (3.0, 10.0)])
-        self.failUnless(num.allclose(data['generatedpointlist'].flat, \
-                                     correct.flat),
-                        'Failed')
-        
-        self.failUnless(num.alltrue(data['generatedsegmentmarkerlist'] == \
+        self.assertTrue(num.allclose(data['generatedpointlist'].flat, \
+                                     correct.flat),
+                        'Failed')
+        
+        self.assertTrue(num.alltrue(data['generatedsegmentmarkerlist'] == \
                                     num.array([1,2,3,4])),
                         'Failed!')
@@ -193 +193 @@
             pass
         else:
-            self.failUnless(0 ==1,
+            self.assertTrue(0 ==1,
                         'bad region list did not raise error!')
 
@@ -216 +216 @@
             pass
         else:
-            self.failUnless(0==1,
+            self.assertTrue(0==1,
                         'bad region list did not raise error!')
 
@@ -235 +235 @@
                               pointattlist,segattlist,  mode, points)
 
-        self.failUnless(len(data['generatedtrianglelist']) == 2,
+        self.assertTrue(len(data['generatedtrianglelist']) == 2,
                         'testregion_with_maxarea 1: # of tris is wrong!')
         ## Another test case
@@ -251 +251 @@
         # triangle as a back box.
 
-        self.failUnless(len(data['generatedtrianglelist']) >= 6,
+        self.assertTrue(len(data['generatedtrianglelist']) >= 6,
                         'testregion_with_maxarea 2: # of tris is wrong!')
         ## Another test case
@@ -261 +261 @@
         # On unix this returns a 10 triangle result.
         # Windows returns a 8 triangle result.
-        self.failUnless(len(data['generatedtrianglelist']) >= 8,
+        self.assertTrue(len(data['generatedtrianglelist']) >= 8,
                         'testregion_with_maxarea 3: # of tris is wrong!')
 
@@ -273 +273 @@
         # Windows returns a 8 triangle result.
 
-        self.failUnless(len(data['generatedtrianglelist']) >= 8,
+        self.assertTrue(len(data['generatedtrianglelist']) >= 8,
                         'testregion_with_maxarea 4: # of tris is wrong!')
 
@@ -295 +295 @@
             pass
         else:
-            self.failUnless(0 ==1,
+            self.assertTrue(0 ==1,
                         'bad hole list did not raise error!')
 
@@ -316 +316 @@
             pass
         else:
-            self.failUnless(0 ==1,
+            self.assertTrue(0 ==1,
                         'bad segment attribute list did not raise error!')
 
@@ -339 +339 @@
 
         correct = num.array([[77.0], [77.0], [77.0], [77.0]])
-        self.failUnless(num.allclose(data['generatedtriangleattributelist'].flat, 
+        self.assertTrue(num.allclose(data['generatedtriangleattributelist'].flat, 
                                      correct.flat),
                         'Failed')
@@ -363 +363 @@
 
         correct = num.array([[77.0], [77.0], [77.0], [77.0]])
-        self.failUnless(num.allclose(data['generatedtriangleattributelist'].flat, 
+        self.assertTrue(num.allclose(data['generatedtriangleattributelist'].flat, 
                                      correct.flat),
                         'Failed')
@@ -389 +389 @@
      
         correct = num.array([(1, 0, 2), (2, 3, 1)])
-        self.failUnless(num.alltrue(data['generatedtrianglelist'].flat == \
+        self.assertTrue(num.alltrue(data['generatedtrianglelist'].flat == \
                                     correct.flat),
                         'trianglelist is wrong!')
         correct = num.array([(0, 1), (1, 3), (3, 2), (2, 0)])
-        self.failUnless(num.alltrue(data['generatedsegmentlist'].flat == \
+        self.assertTrue(num.alltrue(data['generatedsegmentlist'].flat == \
                                     correct.flat),
                         'segmentlist is wrong!')
@@ -399 +399 @@
         correct = num.array([(0.0, 0.0), (0.0, 10.0),
                              (3.0, 0.0), (3.0, 10.0)])
-        self.failUnless(num.allclose(data['generatedpointlist'].flat, \
+        self.assertTrue(num.allclose(data['generatedpointlist'].flat, \
                                      correct.flat),
                         'Failed')
         
         correct = num.array([[tri_tag], [tri_tag]])
-        self.failUnless(num.allclose(data['generatedtriangleattributelist'].flat, \
+        self.assertTrue(num.allclose(data['generatedtriangleattributelist'].flat, \
                                      correct.flat),
                         'Failed')
         correct = num.array([(0, 1), (1, 3), (3, 2), (2, 0)])
-        self.failUnless(num.alltrue(data['generatedsegmentlist'].flat == \
+        self.assertTrue(num.alltrue(data['generatedsegmentlist'].flat == \
                                     correct.flat),
                         'Failed!')
         
         correct = num.array(segattlist, num.int)
-        self.failUnless(num.allclose(data['generatedsegmentmarkerlist'].flat, 
+        self.assertTrue(num.allclose(data['generatedsegmentmarkerlist'].flat, 
                                      correct.flat),
                         'Failed')
@@ -419 +419 @@
         # I copied these answers from the output, so bad test..
         correct = num.array([(-1, 1, -1), (-1, 0, -1)])
-        self.failUnless(num.alltrue(data['generatedtriangleneighborlist'].flat == \
+        self.assertTrue(num.alltrue(data['generatedtriangleneighborlist'].flat == \
                                     correct.flat),
                         'Failed!')
@@ -441 +441 @@
 
         correct = num.array([[0.0],[0.0],[10],[10]])
-        self.failUnless(num.allclose(data['generatedpointattributelist'].flat, \
+        self.assertTrue(num.allclose(data['generatedpointattributelist'].flat, \
                                      correct.flat),
                         'Failed')
@@ -450 +450 @@
                               pointattlist,segattlist, mode, points)
         correct = num.array([[0.0],[0.0],[10],[10]])
-        self.failUnless(num.allclose(data['generatedpointattributelist'].flat, \
+        self.assertTrue(num.allclose(data['generatedpointattributelist'].flat, \
                                      correct.flat),
                         'Failed')
@@ -460 +460 @@
         #print "data", data
         correct = num.array(pointattlist)
-        self.failUnless(num.allclose(data['generatedpointattributelist'].flat, \
+        self.assertTrue(num.allclose(data['generatedpointattributelist'].flat, \
                                      correct.flat),
                         'Failed')

trunk/anuga_core/source/anuga/operators/__init__.py

@@ -4 +4 @@
 """
 
-pass
+from numpy.testing import Tester
+test = Tester().test
 
 
 
+

trunk/anuga_core/source/anuga/parallel/__init__.py

@@ -6 +6 @@
 """
 
-# Lets import the standard anuga interface
-#from anuga import *
+
+
+from numpy.testing import Tester
+test = Tester().test
 
 

trunk/anuga_core/source/anuga/pmesh/__init__.py

@@ -1 +1 @@
 #nothing
+
+from numpy.testing import Tester
+test = Tester().test

trunk/anuga_core/source/anuga/pmesh/test/test_mesh.py

@@ -28 +28 @@
         b = Point(0.0, 10.0)
         
-        self.failUnless( a.DistanceToPoint(b) == 10.0,
+        self.assertTrue( a.DistanceToPoint(b) == 10.0,
                         'Point DistanceToPoint is wrong!')
     
@@ -35 +35 @@
         b = Vertex (0.0, 10.0)
         
-        self.failUnless( a.DistanceToPoint(b) == 10.0,
+        self.assertTrue( a.DistanceToPoint(b) == 10.0,
                         'Point DistanceToPoint is wrong!')
         
@@ -44 +44 @@
         s = Segment(a,b, tag = 20)     
         
-        self.failUnless( s.vertices[0].DistanceToPoint(s.vertices[1]) == 10.0,
+        self.assertTrue( s.vertices[0].DistanceToPoint(s.vertices[1]) == 10.0,
                         'vertices in a segment are wrong')
         
-        self.failUnless( s.tag == 20.0,
+        self.assertTrue( s.tag == 20.0,
                         'tag in a segment are wrong')
 
@@ -63 +63 @@
 
         mesh.deleteMeshObject (a) 
-        self.failUnless(mesh.userSegments[0] == s3,
+        self.assertTrue(mesh.userSegments[0] == s3,
                         'Bad segment. ')        
-        self.failUnless(len(mesh.userSegments) == 1,
+        self.assertTrue(len(mesh.userSegments) == 1,
                         'Segments not deleted.')
-        self.failUnless(len(mesh.userVertices) == 2,
+        self.assertTrue(len(mesh.userVertices) == 2,
                         'Vertex not deleted.')
        
@@ -96 +96 @@
         verts = m.getMeshVertices()
         x = verts[tri[1][0]][0]
-        #self.failUnless((m.meshTriangles[1].vertices[0].x < result + delta) or
+        #self.assertTrue((m.meshTriangles[1].vertices[0].x < result + delta) or
          #               (m.meshTriangles[1].vertices[0].x > result - delta),
           #              'generated mesh is wrong!')
 
-        self.failUnless((x < result + delta) or
+        self.assertTrue((x < result + delta) or
                         (x > result - delta),
                         'generated mesh is wrong!')
@@ -125 +125 @@
         #print "len(m.meshTriangles)",len(m.meshTriangles)
 
-        self.failUnless(len(m.getTriangulation()) == 2, 
+        self.assertTrue(len(m.getTriangulation()) == 2, 
                         'test_regionalMaxArea 1:generated mesh is wrong!')
         
@@ -135 +135 @@
         m.generateMesh("Q", maxArea = 36 )
         
-        self.failUnless(len(m.getTriangulation()) >= 6,
+        self.assertTrue(len(m.getTriangulation()) >= 6,
                         'testregion_with_maxarea 2: # of tris is wrong!')    
        
@@ -147 +147 @@
         #print "len(m.meshTriangles)",len(m.meshTriangles)
         
-        self.failUnless(len(m.getTriangulation()) >= 8,
+        self.assertTrue(len(m.getTriangulation()) >= 8,
                         'testregion_with_maxarea 3: # of tris is wrong!')
                 
@@ -157 +157 @@
                  regions=[r1,r2] )
         m.generateMesh("Q", maxArea = 8 ) 
-        self.failUnless(len(m.getTriangulation()) >= 8,
+        self.assertTrue(len(m.getTriangulation()) >= 8,
                         'testregion_with_maxarea 4: # of tris is wrong!')    
 
@@ -167 +167 @@
                  regions=[r1,r2] )
         m.generateMesh("Q", maxArea = 36,isRegionalMaxAreas = False )      
-        self.failUnless(len(m.getTriangulation()) == 2, 
+        self.assertTrue(len(m.getTriangulation()) == 2, 
                         'test_regionalMaxArea 5:generated mesh is wrong!')
         
@@ -176 +176 @@
                  regions=[r1,r2] )
         m.generateMesh("Q",isRegionalMaxAreas = False )
-        self.failUnless(len(m.getTriangulation()) == 2, 
+        self.assertTrue(len(m.getTriangulation()) == 2, 
                         'test_regionalMaxArea 5:generated mesh is wrong!')
         
@@ -198 +198 @@
         m.generate_mesh(maximum_triangle_area=36,verbose=False)         
 
-        self.failUnless(len(m.getTriangulation()) == 2, 
+        self.assertTrue(len(m.getTriangulation()) == 2, 
                         'test_regionalMaxArea 1:generated mesh is wrong!')
         
@@ -208 +208 @@
         m.generate_mesh(maximum_triangle_area=36,verbose=False)  
         
-        self.failUnless(len(m.getTriangulation()) >= 6,
+        self.assertTrue(len(m.getTriangulation()) >= 6,
                         'testregion_with_maxarea 2: # of tris is wrong!')    
                
@@ -219 +219 @@
         #print "len(m.getTriangulation())",len(m.getTriangulation())
         
-        self.failUnless(len(m.getTriangulation()) >= 8,
+        self.assertTrue(len(m.getTriangulation()) >= 8,
                         'testregion_with_maxarea 3: # of tris is wrong!')
                          
@@ -228 +228 @@
                  regions=[r1,r2] )
         m.generate_mesh(maximum_triangle_area=8,verbose=False)    
-        self.failUnless(len(m.getTriangulation()) >= 8,
+        self.assertTrue(len(m.getTriangulation()) >= 8,
                         'testregion_with_maxarea 4: # of tris is wrong!')    
 
@@ -237 +237 @@
         m.generate_mesh(verbose=False)
         #print "en(m.getTriangulation())", len(m.getTriangulation())
-        self.failUnless(len(m.getTriangulation()) >= 8,
+        self.assertTrue(len(m.getTriangulation()) >= 8,
         'You have issues!')
         
@@ -253 +253 @@
         
         #print ",s2 in mesh.userSegments" ,s2 in mesh.userSegments
-        self.failUnless(not(s2 in mesh.userSegments),
+        self.assertTrue(not(s2 in mesh.userSegments),
                         'Bad segment. ')        
-        self.failUnless(len(mesh.userSegments) ==2,
+        self.assertTrue(len(mesh.userSegments) ==2,
                         'Segments not deleted.')
-        self.failUnless(len(mesh.userVertices) == 3,
+        self.assertTrue(len(mesh.userVertices) == 3,
                         'Vertex deleted, instead of segment.')
 
@@ -271 +271 @@
         s3 = mesh.addUserSegment(c,b)
 
-        self.failUnless(mesh.isUserSegmentNew(a,d) ,
+        self.assertTrue(mesh.isUserSegmentNew(a,d) ,
                         'Segment should be new. ')
-        self.failUnless(not(mesh.isUserSegmentNew(a,b)) ,
+        self.assertTrue(not(mesh.isUserSegmentNew(a,b)) ,
                         'Segment should not be new. ')
 
@@ -288 +288 @@
         s3 = mesh.addUserSegment(c,b)
 
-        self.failUnless(mesh.representedUserSegment(a,d) == None,
+        self.assertTrue(mesh.representedUserSegment(a,d) == None,
                         'Segment should be new. ')
-        self.failUnless(mesh.representedUserSegment(a,b) == s1 ,
+        self.assertTrue(mesh.representedUserSegment(a,b) == s1 ,
                         'Segment should not be new. ')
         
@@ -305 +305 @@
         
         #print 'Len', len(m.userSegments)
-        self.failUnless(len(m.getUserSegments()) == 4 ,
+        self.assertTrue(len(m.getUserSegments()) == 4 ,
                         'userSegments is wrong!')
      
         m.auto_segment()
-        self.failUnless(len(m.getUserSegments()) == 4 ,
+        self.assertTrue(len(m.getUserSegments()) == 4 ,
                         'userSegments is wrong!')
      
@@ -330 +330 @@
         
         s3 = m.representedAlphaUserSegment(p3,p0)
-        self.failUnless(not (s3 == None) ,
+        self.assertTrue(not (s3 == None) ,
                         'userSegments is wrong!')
 
         
         s6 = m.representedAlphaUserSegment(p1,p4)       
-        self.failUnless(not (s6 == None) ,
+        self.assertTrue(not (s6 == None) ,
                         'userSegments is wrong!')
         
@@ -346 +346 @@
         
         s1_now = m.representedUserSegment(p3,p2)
-        self.failUnless(s1_now == s1 ,
+        self.assertTrue(s1_now == s1 ,
                         'userSegments is wrong!')
         
         s2_now = m.representedUserSegment(p5,p4)       
-        self.failUnless(s2_now == s2 ,
+        self.assertTrue(s2_now == s2 ,
                         'userSegments is wrong!')
         
         s3 = m.representedAlphaUserSegment(p3,p6)       
-        self.failUnless(not (s3 == None) ,
+        self.assertTrue(not (s3 == None) ,
                         'userSegments is wrong!')
         
         s4 = m.representedAlphaUserSegment(p3,p6)       
-        self.failUnless(not (s4 == None) ,
+        self.assertTrue(not (s4 == None) ,
                         'userSegments is wrong!')
         
         s5 = m.representedAlphaUserSegment(p4,p6)       
-        self.failUnless(s5 == None ,
+        self.assertTrue(s5 == None ,
                         'userSegments is wrong!')
         #print m
@@ -403 +403 @@
         #print Triangulation[4].attribute
        
-        self.failUnless(Triangulation[0] == "" and
+        self.assertTrue(Triangulation[0] == "" and
                         Triangulation[1] == "22" and
                         Triangulation[2] == "" and
@@ -428 +428 @@
         vert = m.getMeshVerticeAttributes()
         
-        self.failUnless(num.all(vert[0] == [12.0, 2.0]) and
+        self.assertTrue(num.all(vert[0] == [12.0, 2.0]) and
                         num.all(vert[1] == [9.0, 7.0]) and
                         num.all(vert[2] == [14.0,3.0]) and
@@ -456 +456 @@
         vert = m.getMeshVerticeAttributes()
         #print "vert", vert
-        self.failUnless(vert == [],
+        self.assertTrue(vert == [],
                         'vertex attributes are wrong!')
 
@@ -480 +480 @@
         #print "seg[0].tag"
         
-        self.failUnless(seg[0] == 5 and
+        self.assertTrue(seg[0] == 5 and
                         seg[1] == 7 and
                         seg[2] == 9 and
@@ -505 +505 @@
 
         seg = m.getMeshSegmentTags()
-        self.failUnless(seg[0] == "exterior" and
+        self.assertTrue(seg[0] == "exterior" and
                         seg[1] == "exterior" and
                         seg[2] == "exterior" and
@@ -542 +542 @@
 
         # no need to check the title again
-        #self.failUnless(lFile[0] == "5 0 # <vertex #> <x> <y> [attributes] ...Triangulation Vertices..."
+        #self.assertTrue(lFile[0] == "5 0 # <vertex #> <x> <y> [attributes] ...Triangulation Vertices..."
           #              ,'Ascii file is wrong, vertex title')
-        self.failUnless(lFile[1] == "0 0.0 0.0 " and #1.1 " and
+        self.assertTrue(lFile[1] == "0 0.0 0.0 " and #1.1 " and
                         lFile[2] == "1 0.0 4.0 " and #1.2 " and
                         lFile[3] == "2 4.0 0.0 " and #1.3 " and
@@ -552 +552 @@
                         'Ascii file is wrong, vertex')
         
-        #self.failUnless(lFile[6] == "# attribute column titles ...Triangulation Vertex Titles..."
+        #self.assertTrue(lFile[6] == "# attribute column titles ...Triangulation Vertex Titles..."
           #              ,'Ascii file is wrong, attribute column title')
-        self.failUnless(lFile[8] == "0 3 2 4 -1 2 3  " and
+        self.assertTrue(lFile[8] == "0 3 2 4 -1 2 3  " and
                         lFile[9] == "1 1 0 3 3 2 -1  " and
                         lFile[10] == "2 3 4 1 -1 1 0  " and
@@ -561 +561 @@
                         'Ascii file is wrong, triangle') 
 
-        self.failUnless( lFile[13] == "0 0 1 exterior" and
+        self.assertTrue( lFile[13] == "0 0 1 exterior" and
                         lFile[14] == "1 1 4 exterior" and
                         lFile[15] == "2 2 0 exterior" and
@@ -568 +568 @@
                         'Ascii file is wrong, segment')
         
-       # self.failUnless(lFile[18] == '4 0 # <vertex #> <x> <y> [attributes] ...Mesh Vertices...',
+       # self.assertTrue(lFile[18] == '4 0 # <vertex #> <x> <y> [attributes] ...Mesh Vertices...',
         #                'Ascii file is wrong, Mesh Vertices Title')
         
-        self.failUnless(lFile[19] == '0 0.0 0.0 ' and #1.1 ' and
+        self.assertTrue(lFile[19] == '0 0.0 0.0 ' and #1.1 ' and
                         lFile[20] == '1 0.0 4.0 ' and #1.2 ' and
                         lFile[21] == '2 4.0 0.0 ' and #1.3 ' and
@@ -578 +578 @@
                         'Ascii file is wrong, Mesh Vertices II')
         
-        self.failUnless(lFile[24] == '0 0 1 ' and
+        self.assertTrue(lFile[24] == '0 0 1 ' and
                         lFile[25] == '1 1 2 ' and
                         lFile[26] == '2 0 2 ' and
@@ -614 +614 @@
         #    print l,"<"
         #print "@^@^"
-        self.failUnless(lFile[0] == "5 0 # <# of verts> <# of vert attributes>, next lines <vertex #> <x> <y> [attributes] ...Triangulation Vertices..."
+        self.assertTrue(lFile[0] == "5 0 # <# of verts> <# of vert attributes>, next lines <vertex #> <x> <y> [attributes] ...Triangulation Vertices..."
                         ,
                         'Ascii file is wrong, vertex title')
-        self.failUnless(lFile[1] == "0 0.0 0.0 " and #1.1 " and
+        self.assertTrue(lFile[1] == "0 0.0 0.0 " and #1.1 " and
                         lFile[2] == "1 0.0 4.0 " and #1.2 " and
                         lFile[3] == "2 4.0 0.0 " and #1.3 " and
@@ -625 +625 @@
                         'Ascii file is wrong, vertex')
         
-        self.failUnless(lFile[6] == "# attribute column titles ...Triangulation Vertex Titles..."
+        self.assertTrue(lFile[6] == "# attribute column titles ...Triangulation Vertex Titles..."
                         ,
                         'Ascii file is wrong, attribute column title')
-        self.failUnless(lFile[7] == "4 # <# of triangles>, next lines <triangle #> [<vertex #>] [<neigbouring triangle #>] [attribute of region] ...Triangulation Triangles..." and
+        self.assertTrue(lFile[7] == "4 # <# of triangles>, next lines <triangle #> [<vertex #>] [<neigbouring triangle #>] [attribute of region] ...Triangulation Triangles..." and
                         lFile[8] == "0 3 2 4 -1 2 3  " and
                         lFile[9] == "1 1 0 3 3 2 -1  " and
@@ -636 +636 @@
                         'Ascii file is wrong, triangle') 
 
-        self.failUnless(lFile[12] == "5 # <# of segments>, next lines <segment #> <vertex #>  <vertex #> [boundary tag] ...Triangulation Segments..." and
+        self.assertTrue(lFile[12] == "5 # <# of segments>, next lines <segment #> <vertex #>  <vertex #> [boundary tag] ...Triangulation Segments..." and
                         lFile[13] == "0 0 1 exterior" and
                         lFile[14] == "1 1 4 exterior" and
@@ -644 +644 @@
                         'Ascii file is wrong, segment')
         
-        self.failUnless(lFile[18] == '4 0 # <# of verts> <# of vert attributes>, next lines <vertex #> <x> <y> [attributes] ...Mesh Vertices...',
+        self.assertTrue(lFile[18] == '4 0 # <# of verts> <# of vert attributes>, next lines <vertex #> <x> <y> [attributes] ...Mesh Vertices...',
                         'Ascii file is wrong, Mesh Vertices Title')
         
-        self.failUnless(lFile[19] == '0 0.0 0.0 ' and #1.1 ' and
+        self.assertTrue(lFile[19] == '0 0.0 0.0 ' and #1.1 ' and
                         lFile[20] == '1 0.0 4.0 ' and #1.2 ' and
                         lFile[21] == '2 4.0 0.0 ' and #1.3 ' and
@@ -654 +654 @@
                         'Ascii file is wrong, Mesh Vertices II')
         
-        self.failUnless(lFile[23] == '4 # <# of segments>, next lines <segment #> <vertex #>  <vertex #> [boundary tag] ...Mesh Segments...' and
+        self.assertTrue(lFile[23] == '4 # <# of segments>, next lines <segment #> <vertex #>  <vertex #> [boundary tag] ...Mesh Segments...' and
                         lFile[24] == '0 0 1 ' and
                         lFile[25] == '1 1 2 ' and
@@ -679 +679 @@
         m.thinoutVertices(10)
          
-        self.failUnless(v1 in m.userVertices,
+        self.assertTrue(v1 in m.userVertices,
                         'test_thinoutVertices, test 1 failed')
-        self.failUnless(v3 in m.userVertices,
+        self.assertTrue(v3 in m.userVertices,
                         'test_thinoutVertices, test 2 failed')
-        self.failUnless(v4 in m.userVertices,
+        self.assertTrue(v4 in m.userVertices,
                         'test_thinoutVertices, test 3 failed')
-        self.failUnless(v6 in m.userVertices,
+        self.assertTrue(v6 in m.userVertices,
                         'test_thinoutVertices, test 4 failed')
-        self.failUnless(v7 in m.userVertices,
+        self.assertTrue(v7 in m.userVertices,
                         'test_thinoutVertices, test 5 failed')
-        self.failUnless(v9 in m.userVertices,
+        self.assertTrue(v9 in m.userVertices,
                         'test_thinoutVertices, test 6 failed')
-        self.failUnless(v5 not in m.userVertices,
+        self.assertTrue(v5 not in m.userVertices,
                         'test_thinoutVertices, test 7 failed')
-        self.failUnless(v2 not in m.userVertices,
+        self.assertTrue(v2 not in m.userVertices,
                         'test_thinoutVertices, test 8 failed')
-        self.failUnless(v8 not in m.userVertices,
+        self.assertTrue(v8 not in m.userVertices,
                         'test_thinoutVertices, test 9 failed')
 
@@ -703 +703 @@
         f.same_x_y(v)
 
-        self.failUnless(f.same_x_y(v),
+        self.assertTrue(f.same_x_y(v),
                         'same_x_y True failed')
         e = Point(7,9)
-        self.failUnless(not f.same_x_y(e),
+        self.assertTrue(not f.same_x_y(e),
                         'same_x_y False failed')
 
@@ -746 +746 @@
         #print "****************** fileName", fileName
         os.remove(fileName)
-        self.failUnless(0 == m.__cmp__(m_returned),
+        self.assertTrue(0 == m.__cmp__(m_returned),
                         'loading and saving of a mesh failed')
         # do this when .msh supports geo_refs
-        #self.failUnless(m.geo_reference == m_returned.geo_reference,
+        #self.assertTrue(m.geo_reference == m_returned.geo_reference,
         #                'loading and saving of a mesh geo refs failed')
 
@@ -791 +791 @@
         #print "m.geo_reference",m.geo_reference
         #print "m_returned.geo_reference,",m_returned.geo_reference
-        self.failUnless(0 == m.__cmp__(m_returned),
+        self.assertTrue(0 == m.__cmp__(m_returned),
                         'loading and saving of a mesh failed')
-        self.failUnless(m.geo_reference == m_returned.geo_reference,
+        self.assertTrue(m.geo_reference == m_returned.geo_reference,
                         'loading and saving of a mesh geo refs failed')
 
@@ -820 +820 @@
         [xmin, ymin, xmax, ymax] = m.boxsize()
         [attmin, attmax] = m.maxMinVertAtt(0)
-        self.failUnless(attmin == 0.0 and attmax == 1.0,
+        self.assertTrue(attmin == 0.0 and attmax == 1.0,
                         'normalise failed')
-        self.failUnless(xmin == 0.0 and ymin == 0.0 and xmax == 0.5 and ymax == 1.0,
+        self.assertTrue(xmin == 0.0 and ymin == 0.0 and xmax == 0.5 and ymax == 1.0,
                         'normalise failed')
         m.normaliseMesh(200,-100,5)
         [xmin, ymin, xmax, ymax] = m.boxsize()
         [attmin, attmax] = m.maxMinVertAtt(0)
-        self.failUnless(attmin == 0.0 and attmax == 5.0,
+        self.assertTrue(attmin == 0.0 and attmax == 5.0,
                         'normalise failed')
-        self.failUnless(xmin == -100.0 and ymin == -100.0 and xmax == 0.0 and ymax == 100.0,
+        self.assertTrue(xmin == -100.0 and ymin == -100.0 and xmax == 0.0 and ymax == 100.0,
                         'normalise failed')
         
@@ -869 +869 @@
         #print "mesh ***************dsg*", m
         #print "(m.__cmp__(m_returned)", m.__cmp__(m_returned) 
-        self.failUnless(0 == m.__cmp__(m),
+        self.assertTrue(0 == m.__cmp__(m),
                         'test_exportASCIIsegmentoutlinefile:loading and saving of a mesh failed')
         # Having problems with this on linux.
         #The ordering of the dictionary values wasn't the same as the windows
         #returned value (verts.values())
-        #self.failUnless(0 == m.__cmp__(m_returned),
+        #self.assertTrue(0 == m.__cmp__(m_returned),
         #                'test_exportASCIIsegmentoutlinefile:loading and saving of a mesh failed')
         
-        self.failUnless(3 == len(m_returned.userVertices),
+        self.assertTrue(3 == len(m_returned.userVertices),
                         'segmentoutlinefile:IO of a mesh failed')
-        self.failUnless(len(m.userSegments) == len(m_returned.userSegments),
+        self.assertTrue(len(m.userSegments) == len(m_returned.userSegments),
                         'segmentoutlinefile:IO of a mesh failed')
         for i in range(len(m.userSegments)):
-            self.failUnless(m.userSegments[i].vertices[0].x ==
+            self.assertTrue(m.userSegments[i].vertices[0].x ==
                             m_returned.userSegments[i].vertices[0].x,
                         'loading and saving of a mesh outline fialed')
-            self.failUnless(m.userSegments[i].vertices[0].y ==
+            self.assertTrue(m.userSegments[i].vertices[0].y ==
                             m_returned.userSegments[i].vertices[0].y,
                         'loading and saving of a mesh outline fialed')
-            self.failUnless(m.userSegments[i].vertices[1].x ==
+            self.assertTrue(m.userSegments[i].vertices[1].x ==
                             m_returned.userSegments[i].vertices[1].x,
                         'loading and saving of a mesh outline fialed')
-            self.failUnless(m.userSegments[i].vertices[1].y ==
+            self.assertTrue(m.userSegments[i].vertices[1].y ==
                             m_returned.userSegments[i].vertices[1].y,
                         'loading and saving of a mesh outline fialed')
@@ -930 +930 @@
         #print "mesh ***************dsg*", m
         #print "(m.__cmp__(m_returned)", m.__cmp__(m_returned) 
-        self.failUnless(0 == m.__cmp__(m),
+        self.assertTrue(0 == m.__cmp__(m),
                         'loading and saving of a mesh failed')
 
-        self.failUnless(5 == len(m_returned.userVertices),
+        self.assertTrue(5 == len(m_returned.userVertices),
                         'segmentoutlinefile:IO of a mesh failed')
-        self.failUnless(len(m.userSegments) == len(m_returned.userSegments),
+        self.assertTrue(len(m.userSegments) == len(m_returned.userSegments),
                         'segmentoutlinefile:IO of a mesh failed')
         for i in range(len(m.userSegments)):
-            self.failUnless(m.userSegments[i].vertices[0].x ==
+            self.assertTrue(m.userSegments[i].vertices[0].x ==
                             m_returned.userSegments[i].vertices[0].x,
                         'loading and saving of a mesh outline fialed')
-            self.failUnless(m.userSegments[i].vertices[0].y ==
+            self.assertTrue(m.userSegments[i].vertices[0].y ==
                             m_returned.userSegments[i].vertices[0].y,
                         'loading and saving of a mesh outline fialed')
-            self.failUnless(m.userSegments[i].vertices[1].x ==
+            self.assertTrue(m.userSegments[i].vertices[1].x ==
                             m_returned.userSegments[i].vertices[1].x,
                         'loading and saving of a mesh outline fialed')
-            self.failUnless(m.userSegments[i].vertices[1].y ==
+            self.assertTrue(m.userSegments[i].vertices[1].y ==
                             m_returned.userSegments[i].vertices[1].y,
                         'loading and saving of a mesh outline fialed')
@@ -970 +970 @@
         m = importMeshFromFile(fileName)
         os.remove(fileName)
-        self.failUnless(m.userVertices[0].x == 1.0,
+        self.assertTrue(m.userVertices[0].x == 1.0,
                         'loadxy, test 1 failed')
-        self.failUnless(m.userVertices[0].y == 0.0,
+        self.assertTrue(m.userVertices[0].y == 0.0,
                         'loadxy, test 2 failed')
-        #self.failUnless(m.userVertices[0].attributes == [10.0,0.0],
+        #self.assertTrue(m.userVertices[0].attributes == [10.0,0.0],
         #                'loadxy, test 2.2 failed')
-        self.failUnless(m.userVertices[1].x == 0.0,
+        self.assertTrue(m.userVertices[1].x == 0.0,
                         'loadxy, test 3 failed')
-        self.failUnless(m.userVertices[1].y == 1.0,
+        self.assertTrue(m.userVertices[1].y == 1.0,
                         'loadxy, test 4 failed')
-        #self.failUnless(m.userVertices[1].attributes == [0.0,10.0],
+        #self.assertTrue(m.userVertices[1].attributes == [0.0,10.0],
         #                'loadxy, test 5 failed')
         
@@ -1011 +1011 @@
         file.close()
         os.remove(fileName)
-        self.failUnless(lFile[0] == "x,y," and
+        self.assertTrue(lFile[0] == "x,y," and
                         lFile[1] == "0.0,0.0" and
                         lFile[2] == "0.0,3.0" and
@@ -1017 +1017 @@
                         ,
                         'exported Ascii csv file is wrong')
-        self.failUnless(lFile[4] == "1.0,2.0" and
+        self.assertTrue(lFile[4] == "1.0,2.0" and
                         lFile[5] == "3.0,1.0" 
                         ,
@@ -1034 +1034 @@
         os.remove(fileName)
         
-        self.failUnless(lFile[0] == "x,y," and
+        self.assertTrue(lFile[0] == "x,y," and
                         lFile[1] == "0.0,0.0" and
                         lFile[2] == "0.0,3.0" and
@@ -1072 +1072 @@
 
         os.remove(fileName)
-        self.failUnless(lFile[0] == "x,y" and
+        self.assertTrue(lFile[0] == "x,y" and
                         lFile[1] == "0,0" and
                         lFile[2] == "0,3" and
@@ -1078 +1078 @@
                         ,
                         'exported Ascii csv file is wrong')
-        self.failUnless(lFile[4] == "1,2" and
+        self.assertTrue(lFile[4] == "1,2" and
                         lFile[5] == "3,1" 
                         ,
@@ -1095 +1095 @@
         os.remove(fileName)
         
-        self.failUnless(lFile[0] == "x,y" and
+        self.assertTrue(lFile[0] == "x,y" and
                         lFile[1] == "0.0,0.0" and
                         lFile[2] == "0.0,3.0" and
@@ -1117 +1117 @@
         #print "lFile",lFile 
         #print "************* test_mesh exportPointsFilefile"
-        self.failUnless(lFile[0] == "" 
+        self.assertTrue(lFile[0] == "" 
                         ,
                         'exported Ascii csv file is wrong')
@@ -1125 +1125 @@
         preset = ["moat", "internal boundary"]
         [intlist, converter] = segment_strings2ints(list,preset )
-        self.failUnless(intlist == [2,3 ,0 ,2 ,0 ,0 ]
+        self.assertTrue(intlist == [2,3 ,0 ,2 ,0 ,0 ]
                         ,
                         'test_strings2ints produces bad intlist')
-        self.failUnless(converter == ['moat', 'internal boundary',
+        self.assertTrue(converter == ['moat', 'internal boundary',
                                       'sea', 'river inlet']
                         ,
@@ -1141 +1141 @@
         [intlist, converter] = segment_strings2ints(list,preset )
         newlist = segment_ints2strings(intlist, converter)
-        self.failUnless(outlist == newlist
+        self.assertTrue(outlist == newlist
                         ,
                         'test_strings2ints produces bad intlist')
-        self.failUnless(converter == ['moat', 'internal boundary',
+        self.assertTrue(converter == ['moat', 'internal boundary',
                                       'sea', 'river inlet']
                         ,
@@ -1155 +1155 @@
         newlist = segment_ints2strings(intlist, converter)
         outlist = ['moat', 'moat', 'moat']
-        self.failUnless(outlist == newlist
+        self.assertTrue(outlist == newlist
                         ,
                         'test_strings2ints produces bad intlist')
-        self.failUnless(converter == ['moat', 'internal boundary']
+        self.assertTrue(converter == ['moat', 'internal boundary']
                         ,
                         'test_strings2ints produces bad converter')
@@ -1185 +1185 @@
         
          
-        self.failUnless(UserVerts == inputVerts_noDups,
+        self.assertTrue(UserVerts == inputVerts_noDups,
                             'duplicate verts not removed')
         #for userVert, inputVert in map(None, UserVerts, inputVerts_noDups): 
-        #    self.failUnless(userVert.x == inputVert.x,
+        #    self.assertTrue(userVert.x == inputVert.x,
         #                    'x duplicate verts not removed')
-        #    self.failUnless(userVert.y == inputVert.y,
+        #    self.assertTrue(userVert.y == inputVert.y,
         #                    'y duplicate verts not removed')
 
@@ -1206 +1206 @@
 
         
-        self.failUnless(len(m.userSegments) ==2,
+        self.assertTrue(len(m.userSegments) ==2,
                         'Wrong segment list length.')
-        self.failUnless(len(m.userVertices) == 3,
+        self.assertTrue(len(m.userVertices) == 3,
                         'Wrong vertex list length.')
-        self.failUnless(m.userSegments[0].tag =='food',
+        self.assertTrue(m.userSegments[0].tag =='food',
                         'Wrong segment tag length.')
-        self.failUnless(m.userSegments[1].tag =='do-op',
+        self.assertTrue(m.userSegments[1].tag =='do-op',
                         'Wrong segment tag.')
         
@@ -1239 +1239 @@
 
         
-        self.failUnless(m.userSegments[5].vertices[0].y == 3,
+        self.assertTrue(m.userSegments[5].vertices[0].y == 3,
                         'Wrong vertex connected.')
-        self.failUnless(m.userSegments[5].vertices[1].y == 1,
+        self.assertTrue(m.userSegments[5].vertices[1].y == 1,
                         'Wrong vertex connected.')
             
@@ -1257 +1257 @@
 
         
-        self.failUnless(len(m.userSegments) ==2,
+        self.assertTrue(len(m.userSegments) ==2,
                         'Wrong segment list length.')
-        self.failUnless(len(m.userVertices) == 3,
+        self.assertTrue(len(m.userVertices) == 3,
                         'Wrong vertex list length.')
-        self.failUnless(m.userSegments[0].tag =='food',
+        self.assertTrue(m.userSegments[0].tag =='food',
                         'Wrong segment tag length.')
-        self.failUnless(m.userSegments[1].tag =='hair',
+        self.assertTrue(m.userSegments[1].tag =='hair',
                         'Wrong segment tag.')
         
@@ -1279 +1279 @@
 
         
-        self.failUnless(len(m.userSegments) ==2,
+        self.assertTrue(len(m.userSegments) ==2,
                         'Wrong segment list length.')
-        self.failUnless(len(m.userVertices) == 3,
+        self.assertTrue(len(m.userVertices) == 3,
                         'Wrong vertex list length.')
-        self.failUnless(m.userSegments[0].tag =='food',
+        self.assertTrue(m.userSegments[0].tag =='food',
                         'Wrong segment tag length.')
-        self.failUnless(m.userSegments[1].tag =='hair',
+        self.assertTrue(m.userSegments[1].tag =='hair',
                         'Wrong segment tag.')
         
@@ -1332 +1332 @@
         #print '**@@@@@******'
         
-        self.failUnless( new_m == m,
+        self.assertTrue( new_m == m,
                          'loadASCIITestCase failed. test new 1')
             
@@ -1397 +1397 @@
         #print "dict",dict 
         
-        self.failUnless( dict['vertex_attribute_titles'] == titles,
+        self.assertTrue( dict['vertex_attribute_titles'] == titles,
                          'test_Mesh2IOTriangulationDict failed. test 1')
         answer = [a_xy,[0.0, 4.0],[4.0,0.0], [1.0,1.0], [2.0,2.0]]
@@ -1403 +1403 @@
         #print "dict['vertices']",dict['vertices']
         
-        self.failUnless(num.alltrue(dict['vertices'] == answer),
+        self.assertTrue(num.alltrue(dict['vertices'] == answer),
                         'test_Mesh2IOTriangulationDict failed. test 2')
 
-        self.failUnless(num.alltrue(dict['vertices'].flatten() ==
+        self.assertTrue(num.alltrue(dict['vertices'].flatten() ==
                                     verts.flatten()),
                          'test_Mesh2IOTriangulationDict failed. test vert')
-        self.failUnless(num.alltrue(dict['vertex_attributes'].flatten() ==
+        self.assertTrue(num.alltrue(dict['vertex_attributes'].flatten() ==
                                     vert_as.flatten()),
                          'test_Mesh2IOTriangulationDict failed. test vert ats')
 
-        self.failUnless(num.alltrue(dict['segments'][0] == [0,1]),
+        self.assertTrue(num.alltrue(dict['segments'][0] == [0,1]),
                         'test_Mesh2IODict failed. test 3')
         
-        self.failUnless( dict['segment_tags'] == seg_tags,
+        self.assertTrue( dict['segment_tags'] == seg_tags,
                         'test_Mesh2IODict failed. test 3')
         #print " dict['triangles'][0]", dict['triangles'][0] 
-        self.failUnless(num.alltrue(dict['triangles'][0] == [3,2,4]),
+        self.assertTrue(num.alltrue(dict['triangles'][0] == [3,2,4]),
                         'test_Mesh2IODict failed. test 5')
-        self.failUnless(num.alltrue(dict['triangle_neighbors'][0] == [-1,2,3]),
+        self.assertTrue(num.alltrue(dict['triangle_neighbors'][0] == [-1,2,3]),
                         'test_Mesh2IODict failed. test 6')
         #print "dict['triangle_tags'][0]", dict['triangle_tags'][0]
-        self.failUnless( dict['triangle_tags'][0] == "1.3",
+        self.assertTrue( dict['triangle_tags'][0] == "1.3",
                          'test_Mesh2IODict failed. test 7')
 
@@ -1460 +1460 @@
         #print "dict",dict 
         
-        self.failUnless( dict['vertex_attribute_titles'] == titles,
+        self.assertTrue( dict['vertex_attribute_titles'] == titles,
                          'test_Mesh2IOTriangulationDict failed. test 1')
         answer = [a_xy,[0.0, 4.0],[4.0,0.0], [1.0,1.0], [2.0,2.0]]
@@ -1466 +1466 @@
         #print "dict['vertices']",dict['vertices']
         
-        self.failUnless(num.alltrue(dict['vertices'] == answer),
+        self.assertTrue(num.alltrue(dict['vertices'] == answer),
                         'test_Mesh2IOTriangulationDict failed. test 2')
 
-        self.failUnless(num.alltrue(dict['vertices'] == verts),
+        self.assertTrue(num.alltrue(dict['vertices'] == verts),
                         'test_Mesh2IOTriangulationDict failed. test vert')
-        self.failUnless(num.alltrue(dict['vertex_attributes'] == vert_as),
+        self.assertTrue(num.alltrue(dict['vertex_attributes'] == vert_as),
                         'test_Mesh2IOTriangulationDict failed. test vert ats')
 
-        self.failUnless(num.alltrue(dict['segments'][0] == [0,1]),
+        self.assertTrue(num.alltrue(dict['segments'][0] == [0,1]),
                         'test_Mesh2IODict failed. test 3')
         
-        self.failUnless(dict['segment_tags'] == seg_tags,
+        self.assertTrue(dict['segment_tags'] == seg_tags,
                         'test_Mesh2IODict failed. test 3')
         #print " dict['triangles'][0]", dict['triangles'][0] 
-        self.failUnless(num.alltrue(dict['triangles'][0] == [3,2,4]),
+        self.assertTrue(num.alltrue(dict['triangles'][0] == [3,2,4]),
                         'test_Mesh2IODict failed. test 5')
-        self.failUnless(num.alltrue(dict['triangle_neighbors'][0] == [-1,2,3]),
+        self.assertTrue(num.alltrue(dict['triangle_neighbors'][0] == [-1,2,3]),
                         'test_Mesh2IODict failed. test 6')
         #print "dict['triangle_tags'][0]", dict['triangle_tags'][0]
-        self.failUnless(dict['triangle_tags'][0] == "1.3",
+        self.assertTrue(dict['triangle_tags'][0] == "1.3",
                         'test_Mesh2IODict failed. test 7')
 
@@ -1494 +1494 @@
         
         for pimport,pactual,pimpatt in map(None,dict['points'],points,dict['point_attributes']):
-            self.failUnless( pimport == [pactual.x,pactual.y],
+            self.assertTrue( pimport == [pactual.x,pactual.y],
                         'test_Mesh2IODict failed. test 1')
-            self.failUnless( pimpatt == pactual.attributes,
+            self.assertTrue( pimpatt == pactual.attributes,
                         'test_Mesh2IODict failed. test 1.1')
-        self.failUnless( dict['outline_segments'][0] == [0,1],
+        self.assertTrue( dict['outline_segments'][0] == [0,1],
                         'test_Mesh2IODict failed. test 3')
         for segimp,segactual in map(None,dict['outline_segment_tags'],seg):
-            self.failUnless( segimp == segactual.tag,
+            self.assertTrue( segimp == segactual.tag,
                         'test_Mesh2IODict failed. test 4')
         for holeimp,holeactual in map(None,dict['holes'],holes):
-            self.failUnless( holeimp == [holeactual.x,holeactual.y],
+            self.assertTrue( holeimp == [holeactual.x,holeactual.y],
                         'test_Mesh2IODict failed. test 5')
         
         for regimp,regactual,regattimp, regmaxarea in map(None,dict['regions'],regions, dict['region_tags'], dict['region_max_areas']):
-            self.failUnless( regimp == [regactual.x,regactual.y],
+            self.assertTrue( regimp == [regactual.x,regactual.y],
                         'loadASCIITestCase failed. test 6')
-            self.failUnless( regattimp == regactual.getTag(),
+            self.assertTrue( regattimp == regactual.getTag(),
                         'loadASCIITestCase failed. test 7')
-            self.failUnless( regmaxarea == regactual.getMaxArea(),
+            self.assertTrue( regmaxarea == regactual.getMaxArea(),
                         'loadASCIITestCase failed. test 7')
     
@@ -1552 +1552 @@
         
         for pimport,pactual,pimpatt in map(None,dict['points'],points,dict['point_attributes']):
-            self.failUnless( pimport == [pactual.x,pactual.y],
+            self.assertTrue( pimport == [pactual.x,pactual.y],
                         'loadASCIITestCase failed. test 1')
-            self.failUnless( pimpatt == pactual.attributes,
+            self.assertTrue( pimpatt == pactual.attributes,
                         'loadASCIITestCase failed. test 1.1')
-        self.failUnless( dict['outline_segments'][0] == [0,1],
+        self.assertTrue( dict['outline_segments'][0] == [0,1],
                         'loadASCIITestCase failed. test 3')
         for segimp,segactual in map(None,dict['outline_segment_tags'],seg):
-            self.failUnless( segimp == segactual.tag,
+            self.assertTrue( segimp == segactual.tag,
                         'loadASCIITestCase failed. test 4')
         for holeimp,holeactual in map(None,dict['holes'],holes):
-            self.failUnless( holeimp == [holeactual.x,holeactual.y],
+            self.assertTrue( holeimp == [holeactual.x,holeactual.y],
                         'loadASCIITestCase failed. test 5')
         #for regimp,regactual in map(None,dict['regions'],regions):
-         #   self.failUnless( [regimp[0],regimp[1]]==[regactual.x,regactual.y],
+         #   self.assertTrue( [regimp[0],regimp[1]]==[regactual.x,regactual.y],
           #              'loadASCIITestCase failed. test 6')
-           # self.failUnless( regimp[2] == regactual.getTag(),
+           # self.assertTrue( regimp[2] == regactual.getTag(),
             #            'loadASCIITestCase failed. test 7')
-            #self.failUnless( regimp[3] == regactual.getMaxArea(),
+            #self.assertTrue( regimp[3] == regactual.getMaxArea(),
              #           'loadASCIITestCase failed. test 7')
 
             
         for regimp,regactual,regattimp, regmaxarea in map(None,dict['regions'],regions, dict['region_tags'], dict['region_max_areas']):
-            self.failUnless( regimp == [regactual.x,regactual.y],
+            self.assertTrue( regimp == [regactual.x,regactual.y],
                         'loadASCIITestCase failed. test 6')
-            self.failUnless( regattimp == regactual.getTag(),
+            self.assertTrue( regattimp == regactual.getTag(),
                         'loadASCIITestCase failed. test 7')
-            self.failUnless( regmaxarea == regactual.getMaxArea(),
+            self.assertTrue( regmaxarea == regactual.getMaxArea(),
                         'loadASCIITestCase failed. test 7')
 
@@ -1587 +1587 @@
                                   max_triangle_area = 88,
                                            region_tag='cassady')
-        self.failUnless(len(m.regions)==1,
-                        'FAILED!')
-        self.failUnless(region.getMaxArea()==88,
-                        'FAILED!')
-        self.failUnless(len(m.getUserSegments())==3,
-                        'FAILED!')
-        self.failUnless(len(m.userVertices)==3,
-                        'FAILED!')
-        self.failUnless(region.getTag()=='cassady',
+        self.assertTrue(len(m.regions)==1,
+                        'FAILED!')
+        self.assertTrue(region.getMaxArea()==88,
+                        'FAILED!')
+        self.assertTrue(len(m.getUserSegments())==3,
+                        'FAILED!')
+        self.assertTrue(len(m.userVertices)==3,
+                        'FAILED!')
+        self.assertTrue(region.getTag()=='cassady',
                         'FAILED!')
        
@@ -1603 +1603 @@
                                {'tagin':[0,1],'bom':[2]},
                                   max_triangle_area=10)
-        self.failUnless(len(m.regions)==1,
+        self.assertTrue(len(m.regions)==1,
                         'FAILED!')
         segs = m.getUserSegments()
-        self.failUnless(len(segs)==4,
-                        'FAILED!')
-        self.failUnless(len(m.userVertices)==4,
+        self.assertTrue(len(segs)==4,
+                        'FAILED!')
+        self.assertTrue(len(m.userVertices)==4,
                         'FAILED!') 
-        self.failUnless(segs[0].tag=='tagin',
+        self.assertTrue(segs[0].tag=='tagin',
                         'FAILED!')  
-        self.failUnless(segs[1].tag=='tagin',
+        self.assertTrue(segs[1].tag=='tagin',
                         'FAILED!') 
          
-        self.failUnless(segs[2].tag=='bom',
-                        'FAILED!')
-        self.failUnless(segs[3].tag=='',
+        self.assertTrue(segs[2].tag=='bom',
+                        'FAILED!')
+        self.assertTrue(segs[3].tag=='',
                         'FAILED!') 
        
@@ -1639 +1639 @@
         # poly_point values are relative to the mesh geo-ref
         # make them absolute
-        self.failUnless(is_inside_polygon([poly_point.x+x,poly_point.y+y],
+        self.assertTrue(is_inside_polygon([poly_point.x+x,poly_point.y+y],
                                        polygon_absolute, closed = False),
                         'FAILED!')
                
-        self.failUnless(len(m.regions)==1,
+        self.assertTrue(len(m.regions)==1,
                         'FAILED!')
         segs = m.getUserSegments()
-        self.failUnless(len(segs)==4,
-                        'FAILED!')
-        self.failUnless(len(m.userVertices)==4,
+        self.assertTrue(len(segs)==4,
+                        'FAILED!')
+        self.assertTrue(len(m.userVertices)==4,
                         'FAILED!') 
-        self.failUnless(segs[0].tag=='tagin',
+        self.assertTrue(segs[0].tag=='tagin',
                         'FAILED!')  
-        self.failUnless(segs[1].tag=='tagin',
+        self.assertTrue(segs[1].tag=='tagin',
                         'FAILED!') 
          
-        self.failUnless(segs[2].tag=='bom',
+        self.assertTrue(segs[2].tag=='bom',
                         'FAILED!') 
-        self.failUnless(segs[3].tag=='',
+        self.assertTrue(segs[3].tag=='',
                         'FAILED!')
         verts = m.getUserVertices()
@@ -1673 +1673 @@
             #print "new_point_y",new_point_y 
             
-            self.failUnless(point_x == new_point_x, ' failed')
-            self.failUnless(point_y == new_point_y, ' failed')
+            self.assertTrue(point_x == new_point_x, ' failed')
+            self.assertTrue(point_y == new_point_y, ' failed')
             
          
@@ -1686 +1686 @@
                                {'tagin':[0,1],'bom':[2]},
                                   max_triangle_area=10)
-        self.failUnless(len(m.regions)==1,
+        self.assertTrue(len(m.regions)==1,
                         'FAILED!')
         segs = m.getUserSegments()
-        self.failUnless(len(segs)==4,
-                        'FAILED!')
-        self.failUnless(len(m.userVertices)==4,
+        self.assertTrue(len(segs)==4,
+                        'FAILED!')
+        self.assertTrue(len(m.userVertices)==4,
                         'FAILED!') 
-        self.failUnless(segs[0].tag=='tagin',
+        self.assertTrue(segs[0].tag=='tagin',
                         'FAILED!')  
-        self.failUnless(segs[1].tag=='tagin',
+        self.assertTrue(segs[1].tag=='tagin',
                         'FAILED!') 
          
-        self.failUnless(segs[2].tag=='bom',
+        self.assertTrue(segs[2].tag=='bom',
                         'FAILED!') 
-        self.failUnless(segs[3].tag=='',
+        self.assertTrue(segs[3].tag=='',
                         'FAILED!')
         verts = m.getUserVertices()
@@ -1714 +1714 @@
             new_point_y = new_point.y + m.geo_reference.get_yllcorner()
             
-            self.failUnless(point_x == new_point_x, ' failed')
-            self.failUnless(point_y == new_point_y, ' failed')
+            self.assertTrue(point_x == new_point_x, ' failed')
+            self.assertTrue(point_y == new_point_y, ' failed')
 
 
@@ -1739 +1739 @@
         #print "poly_point.y+y",poly_point.y+y
         #print "polygon_absolute", polygon_absolute 
-        self.failUnless(is_inside_polygon([poly_point.x+x,poly_point.y+y],
+        self.assertTrue(is_inside_polygon([poly_point.x+x,poly_point.y+y],
                                        polygon_absolute, closed = False),
                         'FAILED!')
                
-        self.failUnless(len(m.holes)==1,
+        self.assertTrue(len(m.holes)==1,
                         'FAILED!')
         segs = m.getUserSegments()
-        self.failUnless(len(segs)==4,
-                        'FAILED!')
-        self.failUnless(len(m.userVertices)==4,
+        self.assertTrue(len(segs)==4,
+                        'FAILED!')
+        self.assertTrue(len(m.userVertices)==4,
                         'FAILED!') 
-        self.failUnless(segs[0].tag=='tagin',
+        self.assertTrue(segs[0].tag=='tagin',
                         'FAILED!')  
-        self.failUnless(segs[1].tag=='tagin',
+        self.assertTrue(segs[1].tag=='tagin',
                         'FAILED!') 
          
-        self.failUnless(segs[2].tag=='bom',
+        self.assertTrue(segs[2].tag=='bom',
                         'FAILED!') 
-        self.failUnless(segs[3].tag=='interior',
+        self.assertTrue(segs[3].tag=='interior',
                         'FAILED!')
         verts = m.getUserVertices()
@@ -1773 +1773 @@
             #print "new_point_y",new_point_y 
             
-            self.failUnless(point_x == new_point_x, ' failed')
-            self.failUnless(point_y == new_point_y, ' failed')
+            self.assertTrue(point_x == new_point_x, ' failed')
+            self.assertTrue(point_y == new_point_y, ' failed')
 
 
@@ -1800 +1800 @@
         #print "poly_point.y+y",poly_point.y+y
         #print "polygon_absolute", polygon_absolute 
-        self.failUnless(is_inside_polygon([poly_point.x+x,poly_point.y+y],
+        self.assertTrue(is_inside_polygon([poly_point.x+x,poly_point.y+y],
                                        polygon_absolute, closed = False),
                         'FAILED!')
                
-        self.failUnless(len(m.holes)==1,
+        self.assertTrue(len(m.holes)==1,
                         'FAILED!')
         segs = m.getUserSegments()
-        self.failUnless(len(segs)==4,
-                        'FAILED!')
-        self.failUnless(len(m.userVertices)==4,
-                        'FAILED!')
-        
-        self.failUnless(segs[0].tag=='interior',
+        self.assertTrue(len(segs)==4,
+                        'FAILED!')
+        self.assertTrue(len(m.userVertices)==4,
+                        'FAILED!')
+        
+        self.assertTrue(segs[0].tag=='interior',
                         'FAILED!')  
-        self.failUnless(segs[1].tag=='interior',
+        self.assertTrue(segs[1].tag=='interior',
                         'FAILED!') 
          
-        self.failUnless(segs[2].tag=='interior',
+        self.assertTrue(segs[2].tag=='interior',
                         'FAILED!') 
-        self.failUnless(segs[3].tag=='interior',
+        self.assertTrue(segs[3].tag=='interior',
                         'FAILED!')
         verts = m.getUserVertices()
@@ -1835 +1835 @@
             #print "new_point_y",new_point_y 
             
-            self.failUnless(point_x == new_point_x, ' failed')
-            self.failUnless(point_y == new_point_y, ' failed')            
+            self.assertTrue(point_x == new_point_x, ' failed')
+            self.assertTrue(point_y == new_point_y, ' failed')            
 
     def test_add_circle(self):
@@ -1866 +1866 @@
         #m.export_mesh_file("aaat.msh")
         
-        self.failUnless(len(m.regions)==1,
+        self.assertTrue(len(m.regions)==1,
                         'FAILED!')
         segs = m.getUserSegments()
-        self.failUnless(len(segs)==segment_count,
-                        'FAILED!')
-        self.failUnless(len(m.userVertices)==segment_count,
+        self.assertTrue(len(segs)==segment_count,
+                        'FAILED!')
+        self.assertTrue(len(m.userVertices)==segment_count,
                         'FAILED!') 
-        self.failUnless(segs[0].tag==tag,
+        self.assertTrue(segs[0].tag==tag,
                         'FAILED!')  
-        self.failUnless(segs[1].tag==tag,
+        self.assertTrue(segs[1].tag==tag,
                         'FAILED!') 
          
@@ -1928 +1928 @@
         #m.export_mesh_file("from_test_mesh.tsh")
         seg = m.getMeshSegments()
-        self.failUnless(4==len(seg),
+        self.assertTrue(4==len(seg),
                         'FAILED!') 
 
         vert = m.getMeshVertices() 
-        self.failUnless(4==len(vert),
+        self.assertTrue(4==len(vert),
                         'FAILED!')
  
@@ -1970 +1970 @@
         #m.export_mesh_file("from_test_mesh.tsh")
         seg = m.getMeshSegments()
-        self.failUnless(4==len(seg),
+        self.assertTrue(4==len(seg),
                         'FAILED!') 
 
         vert = m.getMeshVertices() 
-        self.failUnless(4==len(vert),
+        self.assertTrue(4==len(vert),
                         'FAILED!')
    
@@ -1989 +1989 @@
         vert = m.getUserVertices()
         #print "vert",vert 
-        self.failUnless(4==len(vert),
+        self.assertTrue(4==len(vert),
                         'FAILED!')
         vert= m.get_user_vertices(absolute=True)
         
-        self.failUnless(num.allclose(vert, points_ab),
+        self.assertTrue(num.allclose(vert, points_ab),
                         'FAILED!')        
 
@@ -2006 +2006 @@
         vert = m.getUserVertices()
         #print "vert",vert 
-        self.failUnless(4==len(vert),
+        self.assertTrue(4==len(vert),
                         'FAILED!')
         vert = m.get_user_vertices(absolute=True)
         
-        self.failUnless(num.alltrue(vert.flatten() ==
+        self.assertTrue(num.alltrue(vert.flatten() ==
                                     num.array(points).flatten()),
                         'FAILED!')
@@ -2025 +2025 @@
         vert = m.getUserVertices()
         #print "vert",vert 
-        self.failUnless(4==len(vert),
+        self.assertTrue(4==len(vert),
                         'FAILED!')
         vert= m.get_user_vertices(absolute=True)
         
-        self.failUnless(num.allclose(vert, points_ab),
+        self.assertTrue(num.allclose(vert, points_ab),
                         'FAILED!')
 
@@ -2042 +2042 @@
         vert = m.getUserVertices()
         #print "vert",vert 
-        self.failUnless(4==len(vert),
+        self.assertTrue(4==len(vert),
                         'FAILED!')
         vert= m.get_user_vertices(absolute=True)
         
-        self.failUnless(num.allclose(vert, points_ab),
+        self.assertTrue(num.allclose(vert, points_ab),
                         'FAILED!')
 
@@ -2064 +2064 @@
         vert = m.getUserVertices()
         #print "vert",vert 
-        self.failUnless(4==len(vert),
+        self.assertTrue(4==len(vert),
                         'FAILED!')
         vert= m.get_user_vertices(absolute=True)
-        self.failUnless(num.allclose(vert, points_ab),
+        self.assertTrue(num.allclose(vert, points_ab),
                         'FAILED!')
         vert= m.get_user_vertices(absolute=False)
         points_new = m.geo_reference.get_absolute(vert)
         
-        self.failUnless(num.allclose(points_ab, points_new),
+        self.assertTrue(num.allclose(points_ab, points_new),
                         'FAILED!')
 
@@ -2110 +2110 @@
         #print "calc_mesh_area", calc_mesh_area
         delta  = 0.0000000001
-        self.failUnless((8.0 < calc_mesh_area + delta) or
+        self.assertTrue((8.0 < calc_mesh_area + delta) or
                         (8.0 > calc_mesh_area - delta),
                         'generated mesh is wrong!')

trunk/anuga_core/source/anuga/pmesh/test/test_mesh_interface.py

@@ -53 +53 @@
 
         # Test the mesh instance
-        self.failUnless(len(m.regions)==3, 'FAILED!')
+        self.assertTrue(len(m.regions)==3, 'FAILED!')
         segs = m.getUserSegments()
-        self.failUnless(len(segs)==12, 'FAILED!')
-        self.failUnless(len(m.userVertices)==12, 'FAILED!')
-        self.failUnless(segs[0].tag=='walls', 'FAILED!')
-        self.failUnless(segs[1].tag=='walls', 'FAILED!')
-        self.failUnless(segs[2].tag=='bom', 'FAILED!')
-        self.failUnless(segs[3].tag=='bom', 'FAILED!')
+        self.assertTrue(len(segs)==12, 'FAILED!')
+        self.assertTrue(len(m.userVertices)==12, 'FAILED!')
+        self.assertTrue(segs[0].tag=='walls', 'FAILED!')
+        self.assertTrue(segs[1].tag=='walls', 'FAILED!')
+        self.assertTrue(segs[2].tag=='bom', 'FAILED!')
+        self.assertTrue(segs[3].tag=='bom', 'FAILED!')
 
         # Assuming the order of the region points is known.
@@ -72 +72 @@
                % (str(poly_point.x+x), str(poly_point.y+y),
                   str(polygon_absolute)))
-        self.failUnless(is_inside_polygon([poly_point.x+x, poly_point.y+y],
+        self.assertTrue(is_inside_polygon([poly_point.x+x, poly_point.y+y],
                                           polygon_absolute, closed=False),
                         msg)
@@ -83 +83 @@
         # poly_point values are relative to the mesh geo-ref
         # make them absolute
-        self.failUnless(is_inside_polygon([poly_point.x+x, poly_point.y+y],
+        self.assertTrue(is_inside_polygon([poly_point.x+x, poly_point.y+y],
                                           inner1_polygon_absolute,
                                           closed=False),
@@ -95 +95 @@
         # poly_point values are relative to the mesh geo-ref
         # make them absolute
-        self.failUnless(is_inside_polygon([poly_point.x+x, poly_point.y+y],
+        self.assertTrue(is_inside_polygon([poly_point.x+x, poly_point.y+y],
                                           inner2_polygon_absolute,
                                           closed=False),
@@ -153 +153 @@
 
         # Test the mesh instance
-        self.failUnless(len(m.regions)==3, 'FAILED!')
+        self.assertTrue(len(m.regions)==3, 'FAILED!')
         segs = m.getUserSegments()
-        self.failUnless(len(segs)==12, 'FAILED!')
-        self.failUnless(len(m.userVertices)==12, 'FAILED!')
-        self.failUnless(segs[0].tag=='walls', 'FAILED!')
-        self.failUnless(segs[1].tag=='walls', 'FAILED!')
-        self.failUnless(segs[2].tag=='bom', 'FAILED!')
-        self.failUnless(segs[3].tag=='bom', 'FAILED!')
+        self.assertTrue(len(segs)==12, 'FAILED!')
+        self.assertTrue(len(m.userVertices)==12, 'FAILED!')
+        self.assertTrue(segs[0].tag=='walls', 'FAILED!')
+        self.assertTrue(segs[1].tag=='walls', 'FAILED!')
+        self.assertTrue(segs[2].tag=='bom', 'FAILED!')
+        self.assertTrue(segs[3].tag=='bom', 'FAILED!')
 
         # Assuming the order of the region points is known.
@@ -169 +169 @@
         # poly_point values are relative to the mesh geo-ref
         # make them absolute
-        self.failUnless(is_inside_polygon([poly_point.x+x, poly_point.y+y],
+        self.assertTrue(is_inside_polygon([poly_point.x+x, poly_point.y+y],
                                           polygon_absolute,
                                           closed=False),
@@ -181 +181 @@
         # poly_point values are relative to the mesh geo-ref
         # make them absolute
-        self.failUnless(is_inside_polygon([poly_point.x+x, poly_point.y+y],
+        self.assertTrue(is_inside_polygon([poly_point.x+x, poly_point.y+y],
                                           inner1_polygon_absolute,
                                           closed=False),
@@ -193 +193 @@
         # poly_point values are relative to the mesh geo-ref
         # make them absolute
-        self.failUnless(is_inside_polygon([poly_point.x+x, poly_point.y+y],
+        self.assertTrue(is_inside_polygon([poly_point.x+x, poly_point.y+y],
                                           inner2_polygon_absolute,
                                           closed=False),
@@ -238 +238 @@
 
         # Test the mesh instance
-        self.failUnless(len(m.regions)==3, 'FAILED!')
+        self.assertTrue(len(m.regions)==3, 'FAILED!')
         segs = m.getUserSegments()
-        self.failUnless(len(segs)==12, 'FAILED!')
-        self.failUnless(len(m.userVertices)==12, 'FAILED!')
-        self.failUnless(segs[0].tag=='walls', 'FAILED!')
-        self.failUnless(segs[1].tag=='walls', 'FAILED!')
-        self.failUnless(segs[2].tag=='bom', 'FAILED!')
-        self.failUnless(segs[3].tag=='bom', 'FAILED!')
-        self.failUnless(m.geo_reference.get_zone()==zone, 'FAILED!')
-        self.failUnless(m.geo_reference.get_xllcorner()==min_x, 'FAILED!')
-        self.failUnless(m.geo_reference.get_yllcorner()==min_y, 'FAILED!')              
+        self.assertTrue(len(segs)==12, 'FAILED!')
+        self.assertTrue(len(m.userVertices)==12, 'FAILED!')
+        self.assertTrue(segs[0].tag=='walls', 'FAILED!')
+        self.assertTrue(segs[1].tag=='walls', 'FAILED!')
+        self.assertTrue(segs[2].tag=='bom', 'FAILED!')
+        self.assertTrue(segs[3].tag=='bom', 'FAILED!')
+        self.assertTrue(m.geo_reference.get_zone()==zone, 'FAILED!')
+        self.assertTrue(m.geo_reference.get_xllcorner()==min_x, 'FAILED!')
+        self.assertTrue(m.geo_reference.get_yllcorner()==min_y, 'FAILED!')              
                 
     def test_create_mesh_from_regions3(self):
@@ -278 +278 @@
 
         # Test the mesh instance
-        self.failUnless(len(m.regions) == 3, 'FAILED!')
+        self.assertTrue(len(m.regions) == 3, 'FAILED!')
         segs = m.getUserSegments()
-        self.failUnless(len(segs) == 12, 'FAILED!')
-        self.failUnless(len(m.userVertices) == 12, 'FAILED!')
-        self.failUnless(segs[0].tag == 'walls', 'FAILED!')
-        self.failUnless(segs[1].tag == 'walls', 'FAILED!')
-        self.failUnless(segs[2].tag == 'bom', 'FAILED!')
-        self.failUnless(segs[3].tag == 'bom', 'FAILED!')
-        self.failUnless(m.geo_reference.get_zone() == DEFAULT_ZONE, 'FAILED!')
-        self.failUnless(m.geo_reference.get_xllcorner() == min_x, 'FAILED!')
-        self.failUnless(m.geo_reference.get_yllcorner() == min_y, 'FAILED!')
+        self.assertTrue(len(segs) == 12, 'FAILED!')
+        self.assertTrue(len(m.userVertices) == 12, 'FAILED!')
+        self.assertTrue(segs[0].tag == 'walls', 'FAILED!')
+        self.assertTrue(segs[1].tag == 'walls', 'FAILED!')
+        self.assertTrue(segs[2].tag == 'bom', 'FAILED!')
+        self.assertTrue(segs[3].tag == 'bom', 'FAILED!')
+        self.assertTrue(m.geo_reference.get_zone() == DEFAULT_ZONE, 'FAILED!')
+        self.assertTrue(m.geo_reference.get_xllcorner() == min_x, 'FAILED!')
+        self.assertTrue(m.geo_reference.get_yllcorner() == min_y, 'FAILED!')
 
     def test_create_mesh_from_regions4(self):
@@ -318 +318 @@
         m = importMeshFromFile(file_name)
 
-        self.failUnless(len(m.getTriangulation()) <= 900,
+        self.assertTrue(len(m.getTriangulation()) <= 900,
                         'Test mesh interface failed!')
-        self.failUnless(len(m.getTriangulation()) >= 200,
+        self.assertTrue(len(m.getTriangulation()) >= 200,
                         'Test mesh interface failed!')
 
@@ -331 +331 @@
         m = importMeshFromFile(file_name)
 
-        self.failUnless(len(m.getTriangulation()) <= 100,
+        self.assertTrue(len(m.getTriangulation()) <= 100,
                         'Test mesh interface failed!')
 
@@ -364 +364 @@
 
         m = importMeshFromFile(file_name)
-        self.failUnless(len(m.getTriangulation()) <= 2000,
+        self.assertTrue(len(m.getTriangulation()) <= 2000,
                         'Test mesh interface failed!')
-        self.failUnless(len(m.getTriangulation()) >= 900,
+        self.assertTrue(len(m.getTriangulation()) >= 900,
                         'Test mesh interface failed!')
 
@@ -406 +406 @@
 
         m = importMeshFromFile(file_name)
-        self.failUnless(len(m.getTriangulation()) <= 2000,
+        self.assertTrue(len(m.getTriangulation()) <= 2000,
                         'Test mesh interface failed!')
-        self.failUnless(len(m.getTriangulation()) >= 900,
+        self.assertTrue(len(m.getTriangulation()) >= 900,
                         'Test mesh interface failed!')
 
@@ -451 +451 @@
 
         m = importMeshFromFile(file_name)
-        self.failUnless(len(m.getTriangulation()) <= 3000,
+        self.assertTrue(len(m.getTriangulation()) <= 3000,
                         'Test mesh interface failed!')
-        self.failUnless(len(m.getTriangulation()) >= 2000,
+        self.assertTrue(len(m.getTriangulation()) >= 2000,
                         'Test mesh interface failed!')
 
@@ -646 +646 @@
                                      breaklines=[[[50,50],[2000,2000]]])
                                                                          
-        self.failUnless(len(m.regions) == 1, 'FAILED!')
+        self.assertTrue(len(m.regions) == 1, 'FAILED!')
         segs = m.getUserSegments()
-        self.failUnless(len(segs) == 5, 'FAILED!')
-        self.failUnless(len(m.userVertices) == 6, 'FAILED!')
+        self.assertTrue(len(segs) == 5, 'FAILED!')
+        self.assertTrue(len(m.userVertices) == 6, 'FAILED!')
 
 
@@ -668 +668 @@
                                      interior_holes=[interior_poly1])
 
-        self.failUnless(len(m.getUserSegments()) == 7, 'FAILED!')
-        self.failUnless(len(m.userVertices) == 7, 'FAILED!')
+        self.assertTrue(len(m.getUserSegments()) == 7, 'FAILED!')
+        self.assertTrue(len(m.userVertices) == 7, 'FAILED!')
 
 
@@ -680 +680 @@
         #print len(m.userVertices)
         
-        self.failUnless(len(m.getUserSegments()) == 10, 'FAILED!')
-        self.failUnless(len(m.userVertices) == 10, 'FAILED!')
+        self.assertTrue(len(m.getUserSegments()) == 10, 'FAILED!')
+        self.assertTrue(len(m.userVertices) == 10, 'FAILED!')
 
         #-------------------------------------

trunk/anuga_core/source/anuga/pmesh/test/test_meshquad.py

@@ -118 +118 @@
             pass
         else:
-            self.failUnless(0 ==1,  'many verts at the same position no  \
+            self.assertTrue(0 ==1,  'many verts at the same position no  \
             longer causes as error')
     

trunk/anuga_core/source/anuga/pymetis/__init__.py

@@ -2 +2 @@
 """
 
-pass
+from numpy.testing import Tester
+test = Tester().test
 
-

trunk/anuga_core/source/anuga/shallow_water/__init__.py

@@ -6 +6 @@
 """
 
-pass
+from numpy.testing import Tester
+test = Tester().test
+
 
  

trunk/anuga_core/source/anuga/shallow_water/test/test_shallow_water_domain.py

@@ -6886 +6886 @@
 
          msg = "test_tags_to_boundaries failed. Single boundary wasn't added."
-         self.failUnless( domain.boundary[(1, 0)]  == '1', msg)
-         self.failUnless( domain.boundary[(1, 2)]  == '2', msg)
-         self.failUnless( domain.boundary[(0, 1)]  == '3', msg)
-         self.failUnless( domain.boundary[(0, 0)]  == 'exterior', msg)
+         self.assertTrue( domain.boundary[(1, 0)]  == '1', msg)
+         self.assertTrue( domain.boundary[(1, 2)]  == '2', msg)
+         self.assertTrue( domain.boundary[(0, 1)]  == '3', msg)
+         self.assertTrue( domain.boundary[(0, 0)]  == 'exterior', msg)
          msg = "test_pmesh2Domain Too many boundaries"
-         self.failUnless( len(domain.boundary)  == 4, msg)
+         self.assertTrue( len(domain.boundary)  == 4, msg)
 
          # FIXME change to use get_xllcorner
          msg = 'Bad geo-reference'
-         self.failUnless(domain.geo_reference.xllcorner  == 140.0, msg)
+         self.assertTrue(domain.geo_reference.xllcorner  == 140.0, msg)
 
          domain = Domain(fileName)
@@ -6919 +6919 @@
 
          msg = "test_tags_to_boundaries failed. Single boundary wasn't added."
-         self.failUnless(domain.boundary[(1, 0)]  == '1', msg)
-         self.failUnless(domain.boundary[(1, 2)]  == '2', msg)
-         self.failUnless(domain.boundary[(0, 1)]  == '3', msg)
-         self.failUnless(domain.boundary[(0, 0)]  == 'exterior', msg)
+         self.assertTrue(domain.boundary[(1, 0)]  == '1', msg)
+         self.assertTrue(domain.boundary[(1, 2)]  == '2', msg)
+         self.assertTrue(domain.boundary[(0, 1)]  == '3', msg)
+         self.assertTrue(domain.boundary[(0, 0)]  == 'exterior', msg)
          msg = "test_pmesh2Domain Too many boundaries"
-         self.failUnless(len(domain.boundary)  == 4, msg)
+         self.assertTrue(len(domain.boundary)  == 4, msg)
 
          # FIXME change to use get_xllcorner
          msg = 'Bad geo_reference'
-         self.failUnless(domain.geo_reference.xllcorner  == 140.0, msg)
+         self.assertTrue(domain.geo_reference.xllcorner  == 140.0, msg)
 
          os.remove(fileName)

trunk/anuga_core/source/anuga/structures/__init__.py

@@ -1 +1 @@
 
-pass
+
+from numpy.testing import Tester
+test = Tester().test
+

trunk/anuga_core/source/anuga/tsunami_source/__init__.py

@@ -6 +6 @@
 """
 
-pass
+from numpy.testing import Tester
+test = Tester().test
+
 
 

trunk/anuga_core/source/anuga/utilities/__init__.py

@@ -6 +6 @@
 """
 
-pass
+from numpy.testing import Tester
+test = Tester().test
 
 

trunk/anuga_core/source/anuga/utilities/numerical_tools.py

@@ -33 +33 @@
     if x < -1.0:
         if x < -1.0 - eps:
-            raise ValueError, errmsg
+            raise ValueError, error_msg
         else:
             warn(warning_msg)
@@ -40 +40 @@
     if x > 1.0:
         if x > 1.0 + eps:
-            raise ValueError, errmsg
+            raise ValueError, error_msg
         else:
             log.critical('NOTE: changing argument to acos from %.18f to 1.0' %x)
@@ -389 +389 @@
 #Initialise module
 
-from util_ext import gradient, gradient2
+#from .util_ext import gradient, gradient2
 
 

trunk/anuga_core/source/anuga/utilities/test/test_csv_tools.py

@@ -95 +95 @@
                '--------------------\n'
                % (expected, got))
-        self.failUnless(self.str_cmp(got, expected), msg)
+        self.assertTrue(self.str_cmp(got, expected), msg)
 
 
@@ -130 +130 @@
                '--------------------\n'
                % (expected, got))
-        self.failUnless(self.str_cmp(got, expected), msg)
+        self.assertTrue(self.str_cmp(got, expected), msg)
 
 
@@ -165 +165 @@
                '--------------------\n'
                % (expected, got))
-        self.failUnless(self.str_cmp(got, expected), msg)
+        self.assertTrue(self.str_cmp(got, expected), msg)
 
 
@@ -202 +202 @@
                '--------------------\n'
                % (expected, got))
-        self.failUnless(self.str_cmp(got, expected), msg)
+        self.assertTrue(self.str_cmp(got, expected), msg)
 
 
@@ -245 +245 @@
                '--------------------\n'
                % (expected, got))
-        self.failUnless(self.str_cmp(got, expected), msg)
+        self.assertTrue(self.str_cmp(got, expected), msg)
 
 
@@ -253 +253 @@
         file_title_list = [(self.filenames[0], 'test0'),
                            (self.filenames[2], 'test2')]
-        self.failUnlessRaises(Exception,
+        self.assertRaises(Exception,
                               csv_tools.merge_csv_key_values,
                               file_title_list,
@@ -266 +266 @@
 
         file_title_list = []
-        self.failUnlessRaises(Exception,
+        self.assertRaises(Exception,
                               csv_tools.merge_csv_key_values,
                               file_title_list,
@@ -280 +280 @@
         file_title_list = [(self.filenames[0], 'test0'),
                            (self.filenames[2], 'test2')]
-        self.failUnlessRaises(Exception,
+        self.assertRaises(Exception,
                               csv_tools.merge_csv_key_values,
                               file_title_list,
@@ -305 +305 @@
         file_title_list = [(self.filenames[0], 'test0'),
                            (test_filename, 'test2')]
-        self.failUnlessRaises(Exception,
+        self.assertRaises(Exception,
                               csv_tools.merge_csv_key_values,
                               file_title_list,
@@ -336 +336 @@
         file_title_list = [(self.filenames[0], 'test0'),
                            (test_filename, 'test2')]
-        self.failUnlessRaises(Exception,
+        self.assertRaises(Exception,
                               csv_tools.merge_csv_key_values,
                               file_title_list,
@@ -399 +399 @@
                '--------------------\n'
                % (expected, got))
-        self.failUnless(self.str_cmp(got, expected), msg)
+        self.assertTrue(self.str_cmp(got, expected), msg)
 
         try:

trunk/anuga_core/source/anuga/utilities/test/test_file_utils.py

@@ -47 +47 @@
 
         # test that files were actually copied
-        self.failUnless(os.access(os.path.join(dst_dir, f1), os.F_OK))
-        self.failUnless(os.access(os.path.join(dst_dir, f2), os.F_OK))
-        self.failUnless(os.access(os.path.join(dst_dir, f3), os.F_OK))
-        self.failUnless(os.access(os.path.join(dst_dir, f4), os.F_OK))
-        self.failUnless(os.access(os.path.join(dst_dir, f5), os.F_OK))
+        self.assertTrue(os.access(os.path.join(dst_dir, f1), os.F_OK))
+        self.assertTrue(os.access(os.path.join(dst_dir, f2), os.F_OK))
+        self.assertTrue(os.access(os.path.join(dst_dir, f3), os.F_OK))
+        self.assertTrue(os.access(os.path.join(dst_dir, f4), os.F_OK))
+        self.assertTrue(os.access(os.path.join(dst_dir, f5), os.F_OK))
 
         # clean up
@@ -140 +140 @@
         outfile = 'test_out.sww'
         _sww_merge(['test1.sww', 'test2.sww'], outfile)
-        self.failUnless(os.access(outfile, os.F_OK))  
+        self.assertTrue(os.access(outfile, os.F_OK))  
         
         # remove temp files

trunk/anuga_core/source/anuga/utilities/test/test_numerical_tools.py

@@ -125 +125 @@
 
         # strings input should raise exception
-        self.failUnlessRaises(Exception, ensure_numeric(['abc',]))
-        self.failUnlessRaises(Exception, ensure_numeric(('abc',)))
-        self.failUnlessRaises(Exception, ensure_numeric(num.array(('abc',))))
+        self.assertRaises(Exception, ensure_numeric(['abc',]))
+        self.assertRaises(Exception, ensure_numeric(('abc',)))
+        self.assertRaises(Exception, ensure_numeric(num.array(('abc',))))
 
     def NO_test_ensure_numeric_char(self):
@@ -482 +482 @@
 
         msg = 'ensure_numeric() should return a copy of a list'
-        self.failUnless(points_new_id != points_id, msg)
-
-        # should never change it's input parameter
-        msg = "ensure_numeric() changed it's input parameter"
-        self.failUnless(points_id == id(points), msg)
+        self.assertTrue(points_new_id != points_id, msg)
+
+        # should never change it's input parameter
+        msg = "ensure_numeric() changed it's input parameter"
+        self.assertTrue(points_id == id(points), msg)
 
         #####
@@ -499 +499 @@
 
         msg = 'ensure_numeric() should return a copy of a list'
-        self.failUnless(points_new_id != points_id, msg)
-
-        # should never change it's input parameter
-        msg = "ensure_numeric() changed it's input parameter"
-        self.failUnless(points_id == id(points), msg)
+        self.assertTrue(points_new_id != points_id, msg)
+
+        # should never change it's input parameter
+        msg = "ensure_numeric() changed it's input parameter"
+        self.assertTrue(points_id == id(points), msg)
 
         #####
@@ -516 +516 @@
 
         msg = 'ensure_numeric() should return the original input'
-        self.failUnless(points_new_id == points_id, msg)
-
-        # should never change it's input parameter
-        msg = "ensure_numeric() changed it's input parameter"
-        self.failUnless(points_id == id(points), msg)
+        self.assertTrue(points_new_id == points_id, msg)
+
+        # should never change it's input parameter
+        msg = "ensure_numeric() changed it's input parameter"
+        self.assertTrue(points_id == id(points), msg)
 
         #####
@@ -533 +533 @@
 
         msg = 'ensure_numeric() should return a copy of the input'
-        self.failUnless(points_new_id != points_id, msg)
-
-        # should never change it's input parameter
-        msg = "ensure_numeric() changed it's input parameter"
-        self.failUnless(points_id == id(points), msg)
+        self.assertTrue(points_new_id != points_id, msg)
+
+        # should never change it's input parameter
+        msg = "ensure_numeric() changed it's input parameter"
+        self.assertTrue(points_id == id(points), msg)
 
         #####
@@ -550 +550 @@
 
         msg = 'ensure_numeric() should return the original input'
-        self.failUnless(points_new_id == points_id, msg)
-
-        # should never change it's input parameter
-        msg = "ensure_numeric() changed it's input parameter"
-        self.failUnless(points_id == id(points), msg)
+        self.assertTrue(points_new_id == points_id, msg)
+
+        # should never change it's input parameter
+        msg = "ensure_numeric() changed it's input parameter"
+        self.assertTrue(points_id == id(points), msg)
 
         #####
@@ -567 +567 @@
 
         msg = 'ensure_numeric() should return the original input'
-        self.failUnless(points_new_id == points_id, msg)
-
-        # should never change it's input parameter
-        msg = "ensure_numeric() changed it's input parameter"
-        self.failUnless(points_id == id(points), msg)
+        self.assertTrue(points_new_id == points_id, msg)
+
+        # should never change it's input parameter
+        msg = "ensure_numeric() changed it's input parameter"
+        self.assertTrue(points_id == id(points), msg)
 
         #####
@@ -584 +584 @@
 
         msg = 'ensure_numeric() should return a copy of the input'
-        self.failUnless(points_new_id != points_id, msg)
-
-        # should never change it's input parameter
-        msg = "ensure_numeric() changed it's input parameter"
-        self.failUnless(points_id == id(points), msg)
+        self.assertTrue(points_new_id != points_id, msg)
+
+        # should never change it's input parameter
+        msg = "ensure_numeric() changed it's input parameter"
+        self.assertTrue(points_id == id(points), msg)
 
         #####
@@ -601 +601 @@
 
         msg = 'ensure_numeric() should return the original input'
-        self.failUnless(points_new_id == points_id, msg)
+        self.assertTrue(points_new_id == points_id, msg)
         #msg = 'ensure_numeric() should return a copy of the input'
-        #self.failUnless(points_new_id != points_id, msg)
-
-        # should never change it's input parameter
-        msg = "ensure_numeric() changed it's input parameter"
-        self.failUnless(points_id == id(points), msg)
+        #self.assertTrue(points_new_id != points_id, msg)
+
+        # should never change it's input parameter
+        msg = "ensure_numeric() changed it's input parameter"
+        self.assertTrue(points_id == id(points), msg)
 
 ################################################################################

trunk/anuga_core/source/anuga/utilities/test/test_system_tools.py

@@ -146 +146 @@
     def clean_line_test(self, instr, delim, expected):
         result = clean_line(instr, delim)
-        self.failUnless(result == expected,
+        self.assertTrue(result == expected,
                         "clean_line('%s', '%s'), expected %s, got %s"
                         % (str(instr), str(delim), str(expected), str(result)))
@@ -209 +209 @@
         new_str_list = char_to_string(x)
 
-        self.failUnlessEqual(new_str_list, str_list)
+        self.assertTrueEqual(new_str_list, str_list)
 
     # special test - input list is ['']
@@ -219 +219 @@
         new_str_list = char_to_string(x)
 
-        self.failUnlessEqual(new_str_list, str_list)
+        self.assertTrueEqual(new_str_list, str_list)
 
 
@@ -282 +282 @@
         new_str_list = self.helper_read_msh_file(FILENAME)
 
-        self.failUnlessEqual(new_str_list, str_list)
+        self.assertTrueEqual(new_str_list, str_list)
         os.remove(FILENAME)
 
@@ -295 +295 @@
         new_str_list = self.helper_read_msh_file(FILENAME)
 
-        self.failUnlessEqual(new_str_list, str_list)
+        self.assertTrueEqual(new_str_list, str_list)
         os.remove(FILENAME)
 
@@ -308 +308 @@
             msg = ("Source: '%s'\nResult: %s\nExpected: %s"
                    % (source, str(result), str(expected)))
-            self.failUnlessEqual(result, expected, msg)
+            self.assertTrueEqual(result, expected, msg)
                 
         source = 'fred'
@@ -365 +365 @@
 
             msg = "Original file %s isn't the same as untarred copy?" % file
-            self.failUnless(orig == copy, msg)
+            self.assertTrue(orig == copy, msg)
 
         # clean up
@@ -404 +404 @@
         msg = ("Digest string wrong, got '%s', expected '%s'"
                % (digest, expected_digest))
-        self.failUnless(expected_digest == digest, msg)
+        self.assertTrue(expected_digest == digest, msg)
 
         # check that digest is as expected, file
@@ -412 +412 @@
         digest = fd.readline()
         fd.close()
-        self.failUnless(expected_digest == digest, msg)
+        self.assertTrue(expected_digest == digest, msg)
 
 
@@ -443 +443 @@
         size1 = file_length(test_file1)
         msg = 'Expected file_length() to return 0, but got %d' % size1
-        self.failUnless(size1 == 0, msg)
+        self.assertTrue(size1 == 0, msg)
         size2 = file_length(test_file2)
         msg = 'Expected file_length() to return 5, but got %d' % size2
-        self.failUnless(size2 == 5, msg)
+        self.assertTrue(size2 == 5, msg)
         size3 = file_length(test_file3)
         msg = 'Expected file_length() to return 1, but got %d' % size3
-        self.failUnless(size3 == 1, msg)
+        self.assertTrue(size3 == 1, msg)
         size4 = file_length(test_file4)
         msg = 'Expected file_length() to return 1000, but got %d' % size4
-        self.failUnless(size4 == 1000, msg)
+        self.assertTrue(size4 == 1000, msg)
         
         

trunk/anuga_core/source/anuga/validation_utilities/__init__.py

@@ -2 +2 @@
     Validation tests
 """
+
+from numpy.testing import Tester
+test = Tester().test