[Scipy-svn] r2529 - in trunk/Lib: . fftpack fftpack/tests integrate integrate/tests interpolate interpolate/tests io io/tests lib lib/blas lib/blas/tests lib/lapack lib/lapack/tests linalg linalg/tests linsolve linsolve/umfpack linsolve/umfpack/tests maxentropy maxentropy/tests misc ndimage ndimage/tests optimize optimize/tests sandbox/arpack/tests sandbox/arraysetops/tests sandbox/cdavid/tests sandbox/exmplpackage/tests sandbox/exmplpackage/yyy/tests sandbox/models/tests sandbox/montecarlo/tests sandbox/spline sandbox/spline/tests signal signal/tests sparse sparse/tests special special/tests stats stats/tests weave weave/tests

scipy-svn at scipy.org scipy-svn at scipy.org
Wed Jan 10 22:23:29 CST 2007


Author: jarrod.millman
Date: 2007-01-10 22:22:41 -0600 (Wed, 10 Jan 2007)
New Revision: 2529

Modified:
   trunk/Lib/__init__.py
   trunk/Lib/fftpack/__init__.py
   trunk/Lib/fftpack/tests/test_basic.py
   trunk/Lib/fftpack/tests/test_helper.py
   trunk/Lib/fftpack/tests/test_pseudo_diffs.py
   trunk/Lib/integrate/__init__.py
   trunk/Lib/integrate/tests/test_integrate.py
   trunk/Lib/integrate/tests/test_quadpack.py
   trunk/Lib/integrate/tests/test_quadrature.py
   trunk/Lib/interpolate/__init__.py
   trunk/Lib/interpolate/tests/test_fitpack.py
   trunk/Lib/interpolate/tests/test_interpolate.py
   trunk/Lib/io/__init__.py
   trunk/Lib/io/tests/test_array_import.py
   trunk/Lib/io/tests/test_mio.py
   trunk/Lib/io/tests/test_mmio.py
   trunk/Lib/io/tests/test_recaster.py
   trunk/Lib/lib/__init__.py
   trunk/Lib/lib/blas/__init__.py
   trunk/Lib/lib/blas/tests/test_blas.py
   trunk/Lib/lib/blas/tests/test_fblas.py
   trunk/Lib/lib/lapack/__init__.py
   trunk/Lib/lib/lapack/tests/test_lapack.py
   trunk/Lib/linalg/__init__.py
   trunk/Lib/linalg/tests/test_basic.py
   trunk/Lib/linalg/tests/test_blas.py
   trunk/Lib/linalg/tests/test_decomp.py
   trunk/Lib/linalg/tests/test_fblas.py
   trunk/Lib/linalg/tests/test_lapack.py
   trunk/Lib/linalg/tests/test_matfuncs.py
   trunk/Lib/linsolve/__init__.py
   trunk/Lib/linsolve/umfpack/__init__.py
   trunk/Lib/linsolve/umfpack/tests/test_umfpack.py
   trunk/Lib/maxentropy/__init__.py
   trunk/Lib/maxentropy/tests/test_maxentropy.py
   trunk/Lib/misc/__init__.py
   trunk/Lib/misc/ppimport.py
   trunk/Lib/ndimage/__init__.py
   trunk/Lib/ndimage/tests/test_ndimage.py
   trunk/Lib/optimize/__init__.py
   trunk/Lib/optimize/tests/test_cobyla.py
   trunk/Lib/optimize/tests/test_optimize.py
   trunk/Lib/optimize/tests/test_zeros.py
   trunk/Lib/sandbox/arpack/tests/test_arpack.py
   trunk/Lib/sandbox/arpack/tests/test_speigs.py
   trunk/Lib/sandbox/arraysetops/tests/test_arraysetops.py
   trunk/Lib/sandbox/cdavid/tests/test_autocorr.py
   trunk/Lib/sandbox/cdavid/tests/test_lpc.py
   trunk/Lib/sandbox/exmplpackage/tests/test_foo.py
   trunk/Lib/sandbox/exmplpackage/yyy/tests/test_yyy.py
   trunk/Lib/sandbox/models/tests/test_formula.py
   trunk/Lib/sandbox/montecarlo/tests/test_dictsampler.py
   trunk/Lib/sandbox/montecarlo/tests/test_intsampler.py
   trunk/Lib/sandbox/spline/__init__.py
   trunk/Lib/sandbox/spline/tests/test_fitpack.py
   trunk/Lib/sandbox/spline/tests/test_interpolate.py
   trunk/Lib/signal/__init__.py
   trunk/Lib/signal/tests/test_signaltools.py
   trunk/Lib/sparse/__init__.py
   trunk/Lib/sparse/tests/test_sparse.py
   trunk/Lib/special/__init__.py
   trunk/Lib/special/tests/test_basic.py
   trunk/Lib/stats/__init__.py
   trunk/Lib/stats/tests/test_distributions.py
   trunk/Lib/stats/tests/test_morestats.py
   trunk/Lib/stats/tests/test_stats.py
   trunk/Lib/weave/__init__.py
   trunk/Lib/weave/tests/test_ast_tools.py
   trunk/Lib/weave/tests/test_blitz_tools.py
   trunk/Lib/weave/tests/test_build_tools.py
   trunk/Lib/weave/tests/test_c_spec.py
   trunk/Lib/weave/tests/test_catalog.py
   trunk/Lib/weave/tests/test_ext_tools.py
   trunk/Lib/weave/tests/test_inline_tools.py
   trunk/Lib/weave/tests/test_scxx.py
   trunk/Lib/weave/tests/test_scxx_dict.py
   trunk/Lib/weave/tests/test_scxx_object.py
   trunk/Lib/weave/tests/test_scxx_sequence.py
   trunk/Lib/weave/tests/test_size_check.py
   trunk/Lib/weave/tests/test_slice_handler.py
   trunk/Lib/weave/tests/test_standard_array_spec.py
   trunk/Lib/weave/tests/test_wx_spec.py
Log:
removed use of deprecated ScipyTest in favor of NumpyTest


Modified: trunk/Lib/__init__.py
===================================================================
--- trunk/Lib/__init__.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/__init__.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -71,10 +71,10 @@
 
 def test(level=1, verbosity=1):
     """ Run Scipy tests suite with level and verbosity."""
-    from numpy.testing import ScipyTest
+    from numpy.testing import NumpyTest
     import scipy
     scipy.pkgload()
-    return ScipyTest(scipy).test(level, verbosity)
+    return NumpyTest(scipy).test(level, verbosity)
 
 __doc__ += """
 

Modified: trunk/Lib/fftpack/__init__.py
===================================================================
--- trunk/Lib/fftpack/__init__.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/fftpack/__init__.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -17,5 +17,5 @@
 del k, register_func
 
 
-from numpy.testing import ScipyTest
-test = ScipyTest().test
+from numpy.testing import NumpyTest
+test = NumpyTest().test

Modified: trunk/Lib/fftpack/tests/test_basic.py
===================================================================
--- trunk/Lib/fftpack/tests/test_basic.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/fftpack/tests/test_basic.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -90,7 +90,7 @@
             x1[0] = x[0]
     return direct_idft(x1).real
 
-class test_fft(ScipyTestCase):
+class test_fft(NumpyTestCase):
 
     def check_definition(self):
         x = [1,2,3,4+1j,1,2,3,4+2j]
@@ -162,7 +162,7 @@
             print ' (secs for %s calls)' % (repeat)
         sys.stdout.flush()
 
-class test_ifft(ScipyTestCase):
+class test_ifft(NumpyTestCase):
 
     def check_definition(self):
         x = [1,2,3,4+1j,1,2,3,4+2j]
@@ -237,7 +237,7 @@
             print ' (secs for %s calls)' % (repeat)
         sys.stdout.flush()
 
-class test_rfft(ScipyTestCase):
+class test_rfft(NumpyTestCase):
 
     def check_definition(self):
         x = [1,2,3,4,1,2,3,4]
@@ -292,7 +292,7 @@
             print ' (secs for %s calls)' % (repeat)
         sys.stdout.flush()
 
-class test_irfft(ScipyTestCase):
+class test_irfft(NumpyTestCase):
 
     def check_definition(self):
         x = [1,2,3,4,1,2,3,4]
@@ -368,7 +368,7 @@
 
         sys.stdout.flush()
 
-class test_fftn(ScipyTestCase):
+class test_fftn(NumpyTestCase):
 
     def check_definition(self):
         x = [[1,2,3],[4,5,6],[7,8,9]]
@@ -529,7 +529,7 @@
 
         sys.stdout.flush()
 
-class test_ifftn(ScipyTestCase):
+class test_ifftn(NumpyTestCase):
 
     def check_definition(self):
         x = [[1,2,3],[4,5,6],[7,8,9]]
@@ -547,4 +547,4 @@
             assert_array_almost_equal (fftn(ifftn(x)),x)
 
 if __name__ == "__main__":
-    ScipyTest().run()
+    NumpyTest().run()

Modified: trunk/Lib/fftpack/tests/test_helper.py
===================================================================
--- trunk/Lib/fftpack/tests/test_helper.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/fftpack/tests/test_helper.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -22,7 +22,7 @@
 def random(size):
     return rand(*size)
 
-class test_fftshift(ScipyTestCase):
+class test_fftshift(NumpyTestCase):
 
     def check_definition(self):
         x = [0,1,2,3,4,-4,-3,-2,-1]
@@ -39,7 +39,7 @@
             x = random((n,))
             assert_array_almost_equal(ifftshift(fftshift(x)),x)
 
-class test_fftfreq(ScipyTestCase):
+class test_fftfreq(NumpyTestCase):
 
     def check_definition(self):
         x = [0,1,2,3,4,-4,-3,-2,-1]
@@ -49,7 +49,7 @@
         assert_array_almost_equal(10*fftfreq(10),x)
         assert_array_almost_equal(10*pi*fftfreq(10,pi),x)
 
-class test_rfftfreq(ScipyTestCase):
+class test_rfftfreq(NumpyTestCase):
 
     def check_definition(self):
         x = [0,1,1,2,2,3,3,4,4]
@@ -60,4 +60,4 @@
         assert_array_almost_equal(10*pi*rfftfreq(10,pi),x)
 
 if __name__ == "__main__":
-    ScipyTest().run()
+    NumpyTest().run()

Modified: trunk/Lib/fftpack/tests/test_pseudo_diffs.py
===================================================================
--- trunk/Lib/fftpack/tests/test_pseudo_diffs.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/fftpack/tests/test_pseudo_diffs.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -77,7 +77,7 @@
     return ifft(fft(x)*exp(k*a)).real
 
 
-class test_diff(ScipyTestCase):
+class test_diff(NumpyTestCase):
 
     def check_definition(self):
         for n in [16,17,64,127,32]:
@@ -216,7 +216,7 @@
             print ' (secs for %s calls)' % (repeat)
 
 
-class test_tilbert(ScipyTestCase):
+class test_tilbert(NumpyTestCase):
 
     def check_definition(self):
         for h in [0.1,0.5,1,5.5,10]:
@@ -277,7 +277,7 @@
             sys.stdout.flush()
             print ' (secs for %s calls)' % (repeat)
 
-class test_itilbert(ScipyTestCase):
+class test_itilbert(NumpyTestCase):
 
     def check_definition(self):
         for h in [0.1,0.5,1,5.5,10]:
@@ -291,7 +291,7 @@
                 assert_array_almost_equal(itilbert(sin(2*x),h),
                                           direct_itilbert(sin(2*x),h))
 
-class test_hilbert(ScipyTestCase):
+class test_hilbert(NumpyTestCase):
 
     def check_definition(self):
         for n in [16,17,64,127]:
@@ -360,7 +360,7 @@
             sys.stdout.flush()
             print ' (secs for %s calls)' % (repeat)
 
-class test_ihilbert(ScipyTestCase):
+class test_ihilbert(NumpyTestCase):
 
     def check_definition(self):
         for n in [16,17,64,127]:
@@ -381,7 +381,7 @@
             y2 = itilbert(f,h=10)
             assert_array_almost_equal (y,y2)
 
-class test_shift(ScipyTestCase):
+class test_shift(NumpyTestCase):
 
     def check_definition(self):
         for n in [18,17,64,127,32,2048,256]:
@@ -430,4 +430,4 @@
             print ' (secs for %s calls)' % (repeat)
 
 if __name__ == "__main__":
-    ScipyTest('fftpack.pseudo_diffs').run()
+    NumpyTest('fftpack.pseudo_diffs').run()

Modified: trunk/Lib/integrate/__init__.py
===================================================================
--- trunk/Lib/integrate/__init__.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/integrate/__init__.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -12,5 +12,5 @@
 from ode import *
 
 __all__ = filter(lambda s:not s.startswith('_'),dir())
-from numpy.testing import ScipyTest
-test = ScipyTest().test
+from numpy.testing import NumpyTest
+test = NumpyTest().test

Modified: trunk/Lib/integrate/tests/test_integrate.py
===================================================================
--- trunk/Lib/integrate/tests/test_integrate.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/integrate/tests/test_integrate.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -14,7 +14,7 @@
 from scipy.integrate import odeint
 restore_path()
 
-class test_odeint(ScipyTestCase):
+class test_odeint(NumpyTestCase):
     """ Test odeint: free vibration of a simple oscillator
         m \ddot{u} + k u = 0, u(0) = u_0 \dot{u}(0) \dot{u}_0
 
@@ -51,4 +51,4 @@
         assert res < 1.0e-6
 
 if __name__ == "__main__":
-    ScipyTest().run()
+    NumpyTest().run()

Modified: trunk/Lib/integrate/tests/test_quadpack.py
===================================================================
--- trunk/Lib/integrate/tests/test_quadpack.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/integrate/tests/test_quadpack.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -10,7 +10,7 @@
     if errTol is not None:
         assert err < errTol, (err, errTol)
 
-class test_quad(ScipyTestCase):
+class test_quad(NumpyTestCase):
     def check_typical(self):
         # 1) Typical function with two extra arguments:
         def myfunc(x,n,z):       # Bessel function integrand
@@ -106,4 +106,4 @@
                     8/3.0 * (b**4.0 - a**4.0))
 
 if __name__ == "__main__":
-    ScipyTest().run()
+    NumpyTest().run()

Modified: trunk/Lib/integrate/tests/test_quadrature.py
===================================================================
--- trunk/Lib/integrate/tests/test_quadrature.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/integrate/tests/test_quadrature.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -7,7 +7,7 @@
 from scipy.integrate import quadrature, romberg, romb
 restore_path()
 
-class test_quadrature(ScipyTestCase):
+class test_quadrature(NumpyTestCase):
     def quad(self, x, a, b, args):
         raise NotImplementedError
 
@@ -31,4 +31,4 @@
         assert_equal(romb(numpy.arange(17)),128)
 
 if __name__ == "__main__":
-    ScipyTest().run()
+    NumpyTest().run()

Modified: trunk/Lib/interpolate/__init__.py
===================================================================
--- trunk/Lib/interpolate/__init__.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/interpolate/__init__.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -11,5 +11,5 @@
 from fitpack2 import *
 
 __all__ = filter(lambda s:not s.startswith('_'),dir())
-from numpy.testing import ScipyTest
-test = ScipyTest().test
+from numpy.testing import NumpyTest
+test = NumpyTest().test

Modified: trunk/Lib/interpolate/tests/test_fitpack.py
===================================================================
--- trunk/Lib/interpolate/tests/test_fitpack.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/interpolate/tests/test_fitpack.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -22,7 +22,7 @@
      RectBivariateSpline
 restore_path()
 
-class test_UnivariateSpline(ScipyTestCase):
+class test_UnivariateSpline(NumpyTestCase):
     def check_linear_constant(self):
         x = [1,2,3]
         y = [3,3,3]
@@ -41,7 +41,7 @@
         assert_almost_equal(lut.get_residual(),0.0)
         assert_array_almost_equal(lut([1,1.5,2]),[0,1,2])
 
-class test_LSQBivariateSpline(ScipyTestCase):
+class test_LSQBivariateSpline(NumpyTestCase):
     def check_linear_constant(self):
         x = [1,1,1,2,2,2,3,3,3]
         y = [1,2,3,1,2,3,1,2,3]
@@ -54,7 +54,7 @@
         #print lut.get_coeffs()
         #print lut.get_residual()
 
-class test_SmoothBivariateSpline(ScipyTestCase):
+class test_SmoothBivariateSpline(NumpyTestCase):
     def check_linear_constant(self):
         x = [1,1,1,2,2,2,3,3,3]
         y = [1,2,3,1,2,3,1,2,3]
@@ -75,7 +75,7 @@
         assert_almost_equal(lut.get_residual(),0.0)
         assert_array_almost_equal(lut([1,1.5,2],[1,1.5]),[[0,0],[1,1],[2,2]])
 
-class test_RectBivariateSpline(ScipyTestCase):
+class test_RectBivariateSpline(NumpyTestCase):
     def check_defaults(self):
         x = array([1,2,3,4,5])
         y = array([1,2,3,4,5])
@@ -84,4 +84,4 @@
         assert_array_almost_equal(lut(x,y),z)
 
 if __name__ == "__main__":
-    ScipyTest().run()
+    NumpyTest().run()

Modified: trunk/Lib/interpolate/tests/test_interpolate.py
===================================================================
--- trunk/Lib/interpolate/tests/test_interpolate.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/interpolate/tests/test_interpolate.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -7,7 +7,7 @@
 restore_path()
 
 
-class test_interp2d(ScipyTestCase):
+class test_interp2d(NumpyTestCase):
     def test_interp2d(self):
         y, x = mgrid[0:pi:20j, 0:pi:21j]
         z = sin(x+y)
@@ -18,7 +18,7 @@
         assert_almost_equal(I(u.ravel(), v.ravel()), sin(v+u), decimal=2)
 
 
-class test_interp1d(ScipyTestCase):
+class test_interp1d(NumpyTestCase):
 
     def setUp(self):
         self.x10 = np.arange(10.)
@@ -195,4 +195,4 @@
 
 
 if __name__ == "__main__":
-    ScipyTest().run()
+    NumpyTest().run()

Modified: trunk/Lib/io/__init__.py
===================================================================
--- trunk/Lib/io/__init__.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/io/__init__.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -16,5 +16,5 @@
 from mmio import mminfo,mmread,mmwrite
 
 __all__ = filter(lambda s:not s.startswith('_'),dir())
-from numpy.testing import ScipyTest
-test = ScipyTest().test
+from numpy.testing import NumpyTest
+test = NumpyTest().test

Modified: trunk/Lib/io/tests/test_array_import.py
===================================================================
--- trunk/Lib/io/tests/test_array_import.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/io/tests/test_array_import.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -16,7 +16,7 @@
 import numpy.oldnumeric as N
 import tempfile
 
-class test_numpyio(ScipyTestCase):
+class test_numpyio(NumpyTestCase):
     def check_basic(self):
         # Generate some data
         a = 255*rand(20)
@@ -34,7 +34,7 @@
         assert(N.product(a.astype(N.Int16) == b,axis=0))
         os.remove(fname)
 
-class test_read_array(ScipyTestCase):
+class test_read_array(NumpyTestCase):
     def check_complex(self):
         a = rand(13,4) + 1j*rand(13,4)
         fname = tempfile.mktemp('.dat')
@@ -61,4 +61,4 @@
         os.remove(fname)
 
 if __name__ == "__main__":
-    ScipyTest().run()
+    NumpyTest().run()

Modified: trunk/Lib/io/tests/test_mio.py
===================================================================
--- trunk/Lib/io/tests/test_mio.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/io/tests/test_mio.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -4,7 +4,7 @@
 from glob import glob
 from cStringIO import StringIO
 from tempfile import mkstemp
-from numpy.testing import set_package_path, restore_path, ScipyTestCase, ScipyTest
+from numpy.testing import set_package_path, restore_path, NumpyTestCase, NumpyTest
 from numpy.testing import assert_equal, assert_array_almost_equal
 from numpy import arange, array, eye, pi, cos, exp, sin, sqrt, ndarray,  \
      zeros, reshape, transpose, empty
@@ -23,7 +23,7 @@
 
 test_data_path = os.path.join(os.path.dirname(__file__), './data')
 
-class test_mio_array(ScipyTestCase):    
+class test_mio_array(NumpyTestCase):    
     def __init__(self, *args, **kwargs):
         super(test_mio_array, self).__init__(*args, **kwargs)
 
@@ -233,5 +233,5 @@
 
 
 if __name__ == "__main__":
-    ScipyTest().run()
+    NumpyTest().run()
 

Modified: trunk/Lib/io/tests/test_mmio.py
===================================================================
--- trunk/Lib/io/tests/test_mmio.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/io/tests/test_mmio.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -8,7 +8,7 @@
 from io.mmio import mminfo,mmread,mmwrite
 restore_path()
 
-class test_mmio_array(ScipyTestCase):
+class test_mmio_array(NumpyTestCase):
 
     def check_simple(self):
         a = [[1,2],[3,4]]
@@ -135,7 +135,7 @@
     5     5   1.200e+01
 '''
 
-class test_mmio_coordinate(ScipyTestCase):
+class test_mmio_coordinate(NumpyTestCase):
 
     def check_simple_todense(self):
         fn = mktemp()
@@ -152,4 +152,4 @@
         assert_array_almost_equal(a,b)
 
 if __name__ == "__main__":
-    ScipyTest().run()
+    NumpyTest().run()

Modified: trunk/Lib/io/tests/test_recaster.py
===================================================================
--- trunk/Lib/io/tests/test_recaster.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/io/tests/test_recaster.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -10,7 +10,7 @@
 except:
     pass
 
-class test_recaster(ScipyTestCase):
+class test_recaster(NumpyTestCase):
     
     def test_init(self):
         # Setting sctype_list

Modified: trunk/Lib/lib/__init__.py
===================================================================
--- trunk/Lib/lib/__init__.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/lib/__init__.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -1,5 +1,5 @@
 
 from info import __doc__, __all__
 
-from numpy.testing import ScipyTest
-test = ScipyTest().test
+from numpy.testing import NumpyTest
+test = NumpyTest().test

Modified: trunk/Lib/lib/blas/__init__.py
===================================================================
--- trunk/Lib/lib/blas/__init__.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/lib/blas/__init__.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -57,5 +57,5 @@
         funcs.append(func)
     return tuple(funcs)
 
-from numpy.testing import ScipyTest
-test = ScipyTest().test
+from numpy.testing import NumpyTest
+test = NumpyTest().test

Modified: trunk/Lib/lib/blas/tests/test_blas.py
===================================================================
--- trunk/Lib/lib/blas/tests/test_blas.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/lib/blas/tests/test_blas.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -24,7 +24,7 @@
 from blas import get_blas_funcs
 restore_path()
 
-class test_cblas1_simple(ScipyTestCase):
+class test_cblas1_simple(NumpyTestCase):
 
     def check_axpy(self):
         for p in 'sd':
@@ -36,7 +36,7 @@
             if f is None: continue
             assert_array_almost_equal(f([1,2j,3],[2,-1,3],a=5),[7,10j-1,18])
 
-class test_fblas1_simple(ScipyTestCase):
+class test_fblas1_simple(NumpyTestCase):
 
     def check_axpy(self):
         for p in 'sd':
@@ -122,7 +122,7 @@
             assert_equal(f([-5,4+3j,6]),1)
     #XXX: need tests for rot,rotm,rotg,rotmg
 
-class test_fblas2_simple(ScipyTestCase):
+class test_fblas2_simple(NumpyTestCase):
 
     def check_gemv(self):
         for p in 'sd':
@@ -170,7 +170,7 @@
                                            2j,
                                            3j],[3j,4j]),[[6,8],[12,16],[18,24]])
 
-class test_fblas3_simple(ScipyTestCase):
+class test_fblas3_simple(NumpyTestCase):
 
     def check_gemm(self):
         for p in 'sd':
@@ -195,7 +195,7 @@
             assert_array_almost_equal(f(1,[[1,2]],[[3],[4]]),[[11]])
             assert_array_almost_equal(f(1,[[1,2],[1,2]],[[3],[4]]),[[11],[11]])
 
-class test_blas(ScipyTestCase):
+class test_blas(NumpyTestCase):
 
     def check_blas(self):
         a = array([[1,1,1]])
@@ -226,4 +226,4 @@
 """
 
 if __name__ == "__main__":
-    ScipyTest().run()
+    NumpyTest().run()

Modified: trunk/Lib/lib/blas/tests/test_fblas.py
===================================================================
--- trunk/Lib/lib/blas/tests/test_fblas.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/lib/blas/tests/test_fblas.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -40,7 +40,7 @@
 ##################################################
 ### Test blas ?axpy
 
-class base_axpy(ScipyTestCase):
+class base_axpy(NumpyTestCase):
     def check_default_a(self):
         x = arange(3.,dtype=self.dtype)
         y = arange(3.,dtype=x.dtype)
@@ -114,7 +114,7 @@
 ##################################################
 ### Test blas ?scal
 
-class base_scal(ScipyTestCase):
+class base_scal(NumpyTestCase):
     def check_simple(self):
         x = arange(3.,dtype=self.dtype)
         real_x = x*3.
@@ -159,7 +159,7 @@
 ##################################################
 ### Test blas ?copy
 
-class base_copy(ScipyTestCase):
+class base_copy(NumpyTestCase):
     def check_simple(self):
         x = arange(3.,dtype=self.dtype)
         y = zeros(shape(x),x.dtype)
@@ -228,7 +228,7 @@
 ##################################################
 ### Test blas ?swap
 
-class base_swap(ScipyTestCase):
+class base_swap(NumpyTestCase):
     def check_simple(self):
         x = arange(3.,dtype=self.dtype)
         y = zeros(shape(x),x.dtype)
@@ -304,7 +304,7 @@
 ### Test blas ?gemv
 ### This will be a mess to test all cases.
 
-class base_gemv(ScipyTestCase):
+class base_gemv(NumpyTestCase):
     def get_data(self,x_stride=1,y_stride=1):
         mult = array(1, dtype = self.dtype)
         if self.dtype in [complex64, complex128]:
@@ -409,7 +409,7 @@
 ### Test blas ?ger
 ### This will be a mess to test all cases.
 
-class base_ger(ScipyTestCase):
+class base_ger(NumpyTestCase):
     def get_data(self,x_stride=1,y_stride=1):
         from numpy.random import normal
         alpha = array(1., dtype = self.dtype)
@@ -518,4 +518,4 @@
 """
 
 if __name__ == "__main__":
-    ScipyTest().run()
+    NumpyTest().run()

Modified: trunk/Lib/lib/lapack/__init__.py
===================================================================
--- trunk/Lib/lib/lapack/__init__.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/lib/lapack/__init__.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -89,5 +89,5 @@
 func_code = %(func_name)s.func_code
 '''
 
-from numpy.testing import ScipyTest
-test = ScipyTest().test
+from numpy.testing import NumpyTest
+test = NumpyTest().test

Modified: trunk/Lib/lib/lapack/tests/test_lapack.py
===================================================================
--- trunk/Lib/lib/lapack/tests/test_lapack.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/lib/lapack/tests/test_lapack.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -27,7 +27,7 @@
 
 #class _test_ev: pass
 
-class _test_lapack(ScipyTestCase,
+class _test_lapack(NumpyTestCase,
                    _test_ev,
                    _test_gev):
 
@@ -123,4 +123,4 @@
         decimal = 12
 
 if __name__ == "__main__":
-    ScipyTest().run()
+    NumpyTest().run()

Modified: trunk/Lib/linalg/__init__.py
===================================================================
--- trunk/Lib/linalg/__init__.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/linalg/__init__.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -28,5 +28,5 @@
 
 del k, register_func
 
-from numpy.testing import ScipyTest
-test = ScipyTest().test
+from numpy.testing import NumpyTest
+test = NumpyTest().test

Modified: trunk/Lib/linalg/tests/test_basic.py
===================================================================
--- trunk/Lib/linalg/tests/test_basic.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/linalg/tests/test_basic.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -39,7 +39,7 @@
     data = add.outer(data,data)
     return data
 
-class test_solve_banded(ScipyTestCase):
+class test_solve_banded(NumpyTestCase):
 
     def check_simple(self):
 
@@ -54,7 +54,7 @@
             x = solve_banded((l,u),ab,b)
             assert_array_almost_equal(numpy.dot(a,x),b)
 
-class test_solve(ScipyTestCase):
+class test_solve(NumpyTestCase):
 
     def check_20Feb04_bug(self):
         a = [[1,1],[1.0,0]] # ok
@@ -193,7 +193,7 @@
 
             print '   (secs for %s calls)' % (repeat)
 
-class test_inv(ScipyTestCase):
+class test_inv(NumpyTestCase):
 
     def check_simple(self):
         a = [[1,2],[3,4]]
@@ -265,7 +265,7 @@
             print '   (secs for %s calls)' % (repeat)
 
 
-class test_det(ScipyTestCase):
+class test_det(NumpyTestCase):
 
     def check_simple(self):
         a = [[1,2],[3,4]]
@@ -340,7 +340,7 @@
     b1 = dot(at, b)
     return solve(a1, b1)
 
-class test_lstsq(ScipyTestCase):
+class test_lstsq(NumpyTestCase):
     def check_random_overdet_large(self):
         #bug report: Nils Wagner
         n = 200
@@ -510,7 +510,7 @@
         y = hankel([1,2,3],[3,4,5])
         assert_array_equal(y,[[1,2,3],[2,3,4],[3,4,5]])
 
-class test_pinv(ScipyTestCase):
+class test_pinv(NumpyTestCase):
 
     def check_simple(self):
         a=array([[1,2,3],[4,5,6.],[7,8,10]])
@@ -538,4 +538,4 @@
         assert_array_almost_equal(a_pinv,a_pinv2)
 
 if __name__ == "__main__":
-    ScipyTest().run()
+    NumpyTest().run()

Modified: trunk/Lib/linalg/tests/test_blas.py
===================================================================
--- trunk/Lib/linalg/tests/test_blas.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/linalg/tests/test_blas.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -23,7 +23,7 @@
 from linalg import cblas
 restore_path()
 
-class test_cblas1_simple(ScipyTestCase):
+class test_cblas1_simple(NumpyTestCase):
 
     def check_axpy(self):
         for p in 'sd':
@@ -35,7 +35,7 @@
             if f is None: continue
             assert_array_almost_equal(f(5,[1,2j,3],[2,-1,3]),[7,10j-1,18])
 
-class test_fblas1_simple(ScipyTestCase):
+class test_fblas1_simple(NumpyTestCase):
 
     def check_axpy(self):
         for p in 'sd':
@@ -121,7 +121,7 @@
             assert_equal(f([-5,4+3j,6]),1)
     #XXX: need tests for rot,rotm,rotg,rotmg
 
-class test_fblas2_simple(ScipyTestCase):
+class test_fblas2_simple(NumpyTestCase):
 
     def check_gemv(self):
         for p in 'sd':
@@ -169,7 +169,7 @@
                                            2j,
                                            3j],[3j,4j]),[[6,8],[12,16],[18,24]])
 
-class test_fblas3_simple(ScipyTestCase):
+class test_fblas3_simple(NumpyTestCase):
 
     def check_gemm(self):
         for p in 'sd':
@@ -183,7 +183,7 @@
             assert_array_almost_equal(f(3j,[3-4j],[-4]),[[-48-36j]])
             assert_array_almost_equal(f(3j,[3-4j],[-4],3,[5j]),[-48-21j])
 
-class test_blas(ScipyTestCase):
+class test_blas(NumpyTestCase):
 
     def check_fblas(self):
         if hasattr(fblas,'empty_module'):
@@ -208,4 +208,4 @@
 """
 
 if __name__ == "__main__":
-    ScipyTest().run()
+    NumpyTest().run()

Modified: trunk/Lib/linalg/tests/test_decomp.py
===================================================================
--- trunk/Lib/linalg/tests/test_decomp.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/linalg/tests/test_decomp.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -32,7 +32,7 @@
 def random(size):
     return rand(*size)
 
-class test_eigvals(ScipyTestCase):
+class test_eigvals(NumpyTestCase):
 
     def check_simple(self):
         a = [[1,2,3],[1,2,3],[2,5,6]]
@@ -78,7 +78,7 @@
 
             print '   (secs for %s calls)' % (repeat)
 
-class test_eig(ScipyTestCase):
+class test_eig(NumpyTestCase):
 
     def check_simple(self):
         a = [[1,2,3],[1,2,3],[2,5,6]]
@@ -111,10 +111,10 @@
 
 
 
-class test_eig_banded(ScipyTestCase):
+class test_eig_banded(NumpyTestCase):
 
     def __init__(self, *args):
-        ScipyTestCase.__init__(self, *args)
+        NumpyTestCase.__init__(self, *args)
 
         self.create_bandmat()
 
@@ -396,7 +396,7 @@
 
 
 
-class test_lu(ScipyTestCase):
+class test_lu(NumpyTestCase):
 
     def check_simple(self):
         a = [[1,2,3],[1,2,3],[2,5,6]]
@@ -414,7 +414,7 @@
 
     #XXX: need more tests
 
-class test_lu_solve(ScipyTestCase):
+class test_lu_solve(NumpyTestCase):
     def check_lu(self):
         a = random((10,10))
         b = random((10,))
@@ -426,7 +426,7 @@
 
         assert_array_equal(x1,x2)
 
-class test_svd(ScipyTestCase):
+class test_svd(NumpyTestCase):
 
     def check_simple(self):
         a = [[1,2,3],[1,20,3],[2,5,6]]
@@ -499,7 +499,7 @@
                 for i in range(len(s)): sigma[i,i] = s[i]
                 assert_array_almost_equal(dot(dot(u,sigma),vh),a)
 
-class test_svdvals(ScipyTestCase):
+class test_svdvals(NumpyTestCase):
 
     def check_simple(self):
         a = [[1,2,3],[1,2,3],[2,5,6]]
@@ -537,12 +537,12 @@
         assert len(s)==2
         assert s[0]>=s[1]
 
-class test_diagsvd(ScipyTestCase):
+class test_diagsvd(NumpyTestCase):
 
     def check_simple(self):
         assert_array_almost_equal(diagsvd([1,0,0],3,3),[[1,0,0],[0,0,0],[0,0,0]])
 
-class test_cholesky(ScipyTestCase):
+class test_cholesky(NumpyTestCase):
 
     def check_simple(self):
         a = [[8,2,3],[2,9,3],[3,3,6]]
@@ -591,7 +591,7 @@
             assert_array_almost_equal(cholesky(a,lower=1),c)
 
 
-class test_qr(ScipyTestCase):
+class test_qr(NumpyTestCase):
 
     def check_simple(self):
         a = [[8,2,3],[2,9,3],[5,3,6]]
@@ -677,7 +677,7 @@
 transp = transpose
 any = sometrue
 
-class test_schur(ScipyTestCase):
+class test_schur(NumpyTestCase):
 
     def check_simple(self):
         a = [[8,12,3],[2,9,3],[10,3,6]]
@@ -689,7 +689,7 @@
         tc2,zc2 = rsf2csf(tc,zc)
         assert_array_almost_equal(dot(dot(zc2,tc2),transp(conj(zc2))),a)
 
-class test_hessenberg(ScipyTestCase):
+class test_hessenberg(NumpyTestCase):
 
     def check_simple(self):
         a = [[-149, -50,-154],
@@ -737,4 +737,4 @@
             assert_array_almost_equal(h1,h)
 
 if __name__ == "__main__":
-    ScipyTest().run()
+    NumpyTest().run()

Modified: trunk/Lib/linalg/tests/test_fblas.py
===================================================================
--- trunk/Lib/linalg/tests/test_fblas.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/linalg/tests/test_fblas.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -40,7 +40,7 @@
 ##################################################
 ### Test blas ?axpy
 
-class base_axpy(ScipyTestCase):
+class base_axpy(NumpyTestCase):
     def check_default_a(self):
         x = arange(3.,dtype=self.dtype)
         y = arange(3.,dtype=x.dtype)
@@ -114,7 +114,7 @@
 ##################################################
 ### Test blas ?scal
 
-class base_scal(ScipyTestCase):
+class base_scal(NumpyTestCase):
     def check_simple(self):
         x = arange(3.,dtype=self.dtype)
         real_x = x*3.
@@ -159,7 +159,7 @@
 ##################################################
 ### Test blas ?copy
 
-class base_copy(ScipyTestCase):
+class base_copy(NumpyTestCase):
     def check_simple(self):
         x = arange(3.,dtype=self.dtype)
         y = zeros(shape(x),x.dtype)
@@ -228,7 +228,7 @@
 ##################################################
 ### Test blas ?swap
 
-class base_swap(ScipyTestCase):
+class base_swap(NumpyTestCase):
     def check_simple(self):
         x = arange(3.,dtype=self.dtype)
         y = zeros(shape(x),x.dtype)
@@ -304,7 +304,7 @@
 ### Test blas ?gemv
 ### This will be a mess to test all cases.
 
-class base_gemv(ScipyTestCase):
+class base_gemv(NumpyTestCase):
     def get_data(self,x_stride=1,y_stride=1):
         mult = array(1, dtype = self.dtype)
         if self.dtype in [complex64, complex128]:
@@ -409,7 +409,7 @@
 ### Test blas ?ger
 ### This will be a mess to test all cases.
 
-class base_ger(ScipyTestCase):
+class base_ger(NumpyTestCase):
     def get_data(self,x_stride=1,y_stride=1):
         from numpy.random import normal
         alpha = array(1., dtype = self.dtype)
@@ -518,4 +518,4 @@
 """
 
 if __name__ == "__main__":
-    ScipyTest().run()
+    NumpyTest().run()

Modified: trunk/Lib/linalg/tests/test_lapack.py
===================================================================
--- trunk/Lib/linalg/tests/test_lapack.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/linalg/tests/test_lapack.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -20,7 +20,7 @@
 from linalg import clapack
 restore_path()
 
-class test_flapack_simple(ScipyTestCase):
+class test_flapack_simple(NumpyTestCase):
 
     def check_gebal(self):
         a = [[1,2,3],[4,5,6],[7,8,9]]
@@ -52,7 +52,7 @@
             ht,tau,info = f(a)
             assert not info,`info`
 
-class test_lapack(ScipyTestCase):
+class test_lapack(NumpyTestCase):
 
     def check_flapack(self):
         if hasattr(flapack,'empty_module'):
@@ -77,4 +77,4 @@
 """
 
 if __name__ == "__main__":
-    ScipyTest().run()
+    NumpyTest().run()

Modified: trunk/Lib/linalg/tests/test_matfuncs.py
===================================================================
--- trunk/Lib/linalg/tests/test_matfuncs.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/linalg/tests/test_matfuncs.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -25,7 +25,7 @@
 from linalg import signm,logm,funm, sqrtm, expm, expm2, expm3
 restore_path()
 
-class test_signm(ScipyTestCase):
+class test_signm(NumpyTestCase):
 
     def check_nils(self):
         a = array([[ 29.2, -24.2,  69.5,  49.8,   7. ],
@@ -67,7 +67,7 @@
         r = signm(a)
         #XXX: what would be the correct result?
 
-class test_logm(ScipyTestCase):
+class test_logm(NumpyTestCase):
 
     def check_nils(self):
         a = array([[ -2.,  25.,   0.,   0.,   0.,   0.,   0.],
@@ -81,7 +81,7 @@
         logm(m)
 
 
-class test_sqrtm(ScipyTestCase):
+class test_sqrtm(NumpyTestCase):
     def check_bad(self):
         # See http://www.maths.man.ac.uk/~nareports/narep336.ps.gz
         e = 2**-5
@@ -98,7 +98,7 @@
         esa = sqrtm(a)
         assert_array_almost_equal(dot(esa,esa),a)
 
-class test_expm(ScipyTestCase):
+class test_expm(NumpyTestCase):
     def check_zero(self):
         a = array([[0.,0],[0,0]])
         assert_array_almost_equal(expm(a),[[1,0],[0,1]])
@@ -106,4 +106,4 @@
         assert_array_almost_equal(expm3(a),[[1,0],[0,1]])
 
 if __name__ == "__main__":
-    ScipyTest().run()
+    NumpyTest().run()

Modified: trunk/Lib/linsolve/__init__.py
===================================================================
--- trunk/Lib/linsolve/__init__.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/linsolve/__init__.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -9,5 +9,5 @@
 from linsolve import *
 
 __all__ = filter(lambda s:not s.startswith('_'),dir())
-from numpy.testing import ScipyTest
-test = ScipyTest().test
+from numpy.testing import NumpyTest
+test = NumpyTest().test

Modified: trunk/Lib/linsolve/umfpack/__init__.py
===================================================================
--- trunk/Lib/linsolve/umfpack/__init__.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/linsolve/umfpack/__init__.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -3,5 +3,5 @@
 from umfpack import *
 
 __all__ = filter(lambda s:not s.startswith('_'),dir())
-from numpy.testing import ScipyTest
-test = ScipyTest().test
+from numpy.testing import NumpyTest
+test = NumpyTest().test

Modified: trunk/Lib/linsolve/umfpack/tests/test_umfpack.py
===================================================================
--- trunk/Lib/linsolve/umfpack/tests/test_umfpack.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/linsolve/umfpack/tests/test_umfpack.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -18,7 +18,7 @@
 
 restore_path()
 
-class test_solvers(ScipyTestCase):
+class test_solvers(NumpyTestCase):
     """Tests inverting a sparse linear system"""
     
     def check_solve_complex_without_umfpack(self):
@@ -72,7 +72,7 @@
 
 
         
-class test_factorization(ScipyTestCase):
+class test_factorization(NumpyTestCase):
     """Tests factorizing a sparse linear system"""
     
     def check_complex_lu(self):
@@ -132,4 +132,4 @@
         
         
 if __name__ == "__main__":
-    ScipyTest().run()
+    NumpyTest().run()

Modified: trunk/Lib/maxentropy/__init__.py
===================================================================
--- trunk/Lib/maxentropy/__init__.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/maxentropy/__init__.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -8,5 +8,5 @@
 from info import __doc__
 from maxentropy import *
 
-from numpy.testing import ScipyTest
-test = ScipyTest().test
+from numpy.testing import NumpyTest
+test = NumpyTest().test

Modified: trunk/Lib/maxentropy/tests/test_maxentropy.py
===================================================================
--- trunk/Lib/maxentropy/tests/test_maxentropy.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/maxentropy/tests/test_maxentropy.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -16,7 +16,7 @@
 import unittest
 
 
-class test_maxentropy(ScipyTestCase):
+class test_maxentropy(NumpyTestCase):
     """Test whether logsumexp() function correctly handles large
     inputs.
     """
@@ -41,4 +41,4 @@
 
 
 if __name__ == "__main__":
-    ScipyTest().run()
+    NumpyTest().run()

Modified: trunk/Lib/misc/__init__.py
===================================================================
--- trunk/Lib/misc/__init__.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/misc/__init__.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -21,5 +21,5 @@
 
 __all__ += common.__all__
 
-from numpy.testing import ScipyTest
-test = ScipyTest().test
+from numpy.testing import NumpyTest
+test = NumpyTest().test

Modified: trunk/Lib/misc/ppimport.py
===================================================================
--- trunk/Lib/misc/ppimport.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/misc/ppimport.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -242,8 +242,8 @@
         self.__dict__['_ppimport_p_frame'] = p_frame
 
         if location != 'sys.path':
-            from numpy.test.testing import ScipyTest
-            self.__dict__['test'] = ScipyTest(self).test
+            from numpy.test.testing import NumpyTest
+            self.__dict__['test'] = NumpyTest(self).test
 
         # install loader
         sys.modules[name] = self
@@ -283,8 +283,8 @@
         self.__dict__['_ppimport_module'] = module
 
         # XXX: Should we check the existence of module.test? Warn?
-        from numpy.test.testing import ScipyTest
-        module.test = ScipyTest(module).test
+        from numpy.test.testing import NumpyTest
+        module.test = NumpyTest(module).test
 
         return module
 

Modified: trunk/Lib/ndimage/__init__.py
===================================================================
--- trunk/Lib/ndimage/__init__.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/ndimage/__init__.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -36,6 +36,6 @@
 from morphology import *
 
 from info import __doc__
-from numpy.testing import ScipyTest
-test = ScipyTest().test
+from numpy.testing import NumpyTest
+test = NumpyTest().test
 

Modified: trunk/Lib/ndimage/tests/test_ndimage.py
===================================================================
--- trunk/Lib/ndimage/tests/test_ndimage.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/ndimage/tests/test_ndimage.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -62,7 +62,7 @@
     return math.sqrt(t)
 
 
-class test_ndimage(ScipyTestCase):
+class test_ndimage(NumpyTestCase):
 
     def setUp(self):
         # list of numarray data types
@@ -5523,4 +5523,4 @@
 
 if __name__ == "__main__":
     #unittest.main()
-    ScipyTest().run()
+    NumpyTest().run()

Modified: trunk/Lib/optimize/__init__.py
===================================================================
--- trunk/Lib/optimize/__init__.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/optimize/__init__.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -13,5 +13,5 @@
 from cobyla import fmin_cobyla
 
 __all__ = filter(lambda s:not s.startswith('_'),dir())
-from numpy.testing import ScipyTest
-test = ScipyTest().test
+from numpy.testing import NumpyTest
+test = NumpyTest().test

Modified: trunk/Lib/optimize/tests/test_cobyla.py
===================================================================
--- trunk/Lib/optimize/tests/test_cobyla.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/optimize/tests/test_cobyla.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -6,7 +6,7 @@
 restore_path()
 import math
 
-class test_cobyla(ScipyTestCase):
+class test_cobyla(NumpyTestCase):
     def check_simple(self, level=1):
 
         function = lambda x: x[0]**2 + abs(x[1])**3
@@ -20,4 +20,4 @@
         assert_almost_equal(x, [x0, x1], decimal=5)
 
 if __name__ == "__main__":
-    ScipyTest().run()
+    NumpyTest().run()

Modified: trunk/Lib/optimize/tests/test_optimize.py
===================================================================
--- trunk/Lib/optimize/tests/test_optimize.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/optimize/tests/test_optimize.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -11,7 +11,7 @@
 restore_path()
 
 
-class test_optimize(ScipyTestCase):
+class test_optimize(NumpyTestCase):
     """ Test case for a simple constrained entropy maximization problem
     (the machine translation example of Berger et al in
     Computational Linguistics, vol 22, num 1, pp 39--72, 1996.)
@@ -124,4 +124,4 @@
 
 
 if __name__ == "__main__":
-    ScipyTest().run()
+    NumpyTest().run()

Modified: trunk/Lib/optimize/tests/test_zeros.py
===================================================================
--- trunk/Lib/optimize/tests/test_zeros.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/optimize/tests/test_zeros.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -51,7 +51,7 @@
 functions = [f2,f3,f4,f5,f6]
 fstrings = ['f2','f3','f4','f5','f6']
 
-class test_basic(ScipyTestCase) :
+class test_basic(NumpyTestCase) :
     def run_test(self, method, name):
         a = .5
         b = sqrt(3)
@@ -93,4 +93,4 @@
             print '\n\n'
 
 if __name__ == '__main__' :
-    ScipyTest().run()
+    NumpyTest().run()

Modified: trunk/Lib/sandbox/arpack/tests/test_arpack.py
===================================================================
--- trunk/Lib/sandbox/arpack/tests/test_arpack.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/sandbox/arpack/tests/test_arpack.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -19,7 +19,7 @@
 import numpy 
 from scipy.linalg import eig,eigh,norm
 
-class test_eigen_nonsymmetric(ScipyTestCase):
+class test_eigen_nonsymmetric(NumpyTestCase):
 
     def get_a1(self,typ):
         mat=numpy.array([[-2., -8.,  1.,  2., -5.],
@@ -121,7 +121,7 @@
 
 
 
-class test_eigen_complex_nonsymmetric(ScipyTestCase):
+class test_eigen_complex_nonsymmetric(NumpyTestCase):
 
     def get_a1(self,typ):
         mat=numpy.array([[-2., -8.,  1.,  2., -5.],
@@ -218,7 +218,7 @@
 
 
     
-class test_eigen_symmetric(ScipyTestCase):
+class test_eigen_symmetric(NumpyTestCase):
 
     def get_a1(self,typ):
         mat_a1=numpy.array([[ 2.,  0.,  0., -1.,  0., -1.],
@@ -290,7 +290,7 @@
             self.end_eigenvalues(typ,k)
     
 
-class test_eigen_complex_symmetric(ScipyTestCase):
+class test_eigen_complex_symmetric(NumpyTestCase):
 
     def get_a1(self,typ):
         mat_a1=numpy.array([[ 2.,  0.,  0., -1.,  0., -1.],
@@ -352,4 +352,4 @@
 
 
 if __name__ == "__main__":
-    ScipyTest().run()
+    NumpyTest().run()

Modified: trunk/Lib/sandbox/arpack/tests/test_speigs.py
===================================================================
--- trunk/Lib/sandbox/arpack/tests/test_speigs.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/sandbox/arpack/tests/test_speigs.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -8,7 +8,7 @@
 
 import numpy as N
 
-class test_eigs(ScipyTestCase):
+class test_eigs(NumpyTestCase):
     def test(self):
         maxn=15                # Dimension of square matrix to be solved
         # Use a PDP^-1 factorisation to construct matrix with known
@@ -36,7 +36,7 @@
         assert_array_almost_equal(calc_vecs,  N.array(vecs)[:,0:nev], decimal=7)
 
 
-# class test_geneigs(ScipyTestCase):
+# class test_geneigs(NumpyTestCase):
 #     def test(self):
 #         import pickle
 #         import scipy.linsolve
@@ -50,5 +50,5 @@
 #          94.646308846854879, 95.30841709116271], decimal=11)
 
 if __name__ == "__main__":
-    ScipyTest().run()
+    NumpyTest().run()
     

Modified: trunk/Lib/sandbox/arraysetops/tests/test_arraysetops.py
===================================================================
--- trunk/Lib/sandbox/arraysetops/tests/test_arraysetops.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/sandbox/arraysetops/tests/test_arraysetops.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -24,7 +24,7 @@
 from scipy.arraysetops import *
 restore_path()
 
-class test_aso( ScipyTestCase ):
+class test_aso( NumpyTestCase ):
 
     def chech_all():
         test_unique1d()
@@ -37,4 +37,4 @@
         test_manyways()
 
 if __name__ == "__main__":
-    ScipyTest().run()
+    NumpyTest().run()

Modified: trunk/Lib/sandbox/cdavid/tests/test_autocorr.py
===================================================================
--- trunk/Lib/sandbox/cdavid/tests/test_autocorr.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/sandbox/cdavid/tests/test_autocorr.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -345,7 +345,7 @@
         assert_array_almost_equal(atest, aref, decimal = md)
 
 if __name__ == "__main__":
-    ScipyTest().run()
+    NumpyTest().run()
 
 #class test_autocorr_2d(NumpyTestCase):
 #    def check_double(self):

Modified: trunk/Lib/sandbox/cdavid/tests/test_lpc.py
===================================================================
--- trunk/Lib/sandbox/cdavid/tests/test_lpc.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/sandbox/cdavid/tests/test_lpc.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -184,4 +184,4 @@
         assert_array_almost_equal(k, kt)
 
 if __name__ == "__main__":
-    ScipyTest().run()
+    NumpyTest().run()

Modified: trunk/Lib/sandbox/exmplpackage/tests/test_foo.py
===================================================================
--- trunk/Lib/sandbox/exmplpackage/tests/test_foo.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/sandbox/exmplpackage/tests/test_foo.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -22,15 +22,15 @@
 from exmplpackage.foo import *
 del sys.path[0]
 
-class test_foo_bar(ScipyTestCase):
+class test_foo_bar(NumpyTestCase):
 
     def check_simple(self, level=1):
         assert exmplpackage_foo_bar()=='Hello from exmplpackage_foo_bar'
 
-class test_foo_gun(ScipyTestCase):
+class test_foo_gun(NumpyTestCase):
 
     def check_simple(self, level=1):
         assert foo_gun()=='Hello from foo_gun'
 
 if __name__ == "__main__":
-    ScipyTest().run()
+    NumpyTest().run()

Modified: trunk/Lib/sandbox/exmplpackage/yyy/tests/test_yyy.py
===================================================================
--- trunk/Lib/sandbox/exmplpackage/yyy/tests/test_yyy.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/sandbox/exmplpackage/yyy/tests/test_yyy.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -7,10 +7,10 @@
 from yyy import fun
 del sys.path[0]
 
-class test_fun(ScipyTestCase):
+class test_fun(NumpyTestCase):
     def check_simple(self, level=1):
         assert fun()=='Hello from yyy.fun'
     #...
 
 if __name__ == "__main__":
-    ScipyTest().run()
+    NumpyTest().run()

Modified: trunk/Lib/sandbox/models/tests/test_formula.py
===================================================================
--- trunk/Lib/sandbox/models/tests/test_formula.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/sandbox/models/tests/test_formula.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -6,7 +6,7 @@
 import numpy as N
 import numpy.random as R
 import numpy.linalg as L
-from numpy.testing import assert_almost_equal, ScipyTestCase
+from numpy.testing import assert_almost_equal, NumpyTestCase
 import scipy
 
 from scipy.sandbox.models import utils, formula, contrast
@@ -47,7 +47,7 @@
         f = intercept * t1
         self.assertEqual(str(f), str(formula.formula(t1)))
 
-class test_formula(ScipyTestCase):
+class test_formula(NumpyTestCase):
 
     def setUp(self):
         self.X = R.standard_normal((40,10))

Modified: trunk/Lib/sandbox/montecarlo/tests/test_dictsampler.py
===================================================================
--- trunk/Lib/sandbox/montecarlo/tests/test_dictsampler.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/sandbox/montecarlo/tests/test_dictsampler.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -21,7 +21,7 @@
 import unittest
 
 
-class test_dictsampler(ScipyTestCase):
+class test_dictsampler(NumpyTestCase):
     def check_simple(self):
         """
         # Sample from this discrete distribution:
@@ -76,4 +76,4 @@
 
 
 if __name__ == "__main__":
-    ScipyTest().run()
+    NumpyTest().run()

Modified: trunk/Lib/sandbox/montecarlo/tests/test_intsampler.py
===================================================================
--- trunk/Lib/sandbox/montecarlo/tests/test_intsampler.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/sandbox/montecarlo/tests/test_intsampler.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -30,7 +30,7 @@
 import unittest
 
 
-class test_intsampler(ScipyTestCase):
+class test_intsampler(NumpyTestCase):
     def check_simple(self):
         # Sample from a Poisson distribution, P(lambda = 10.0)
         lam = 10.0
@@ -71,4 +71,4 @@
 
 
 if __name__ == "__main__":
-    ScipyTest().run()
+    NumpyTest().run()

Modified: trunk/Lib/sandbox/spline/__init__.py
===================================================================
--- trunk/Lib/sandbox/spline/__init__.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/sandbox/spline/__init__.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -10,5 +10,5 @@
 from spline import *
 
 __all__ = filter(lambda s:not s.startswith('_'),dir())
-from numpy.testing import ScipyTest
-test = ScipyTest().test
+from numpy.testing import NumpyTest
+test = NumpyTest().test

Modified: trunk/Lib/sandbox/spline/tests/test_fitpack.py
===================================================================
--- trunk/Lib/sandbox/spline/tests/test_fitpack.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/sandbox/spline/tests/test_fitpack.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -22,7 +22,7 @@
      RectBivariateSpline
 restore_path()
 
-class test_UnivariateSpline(ScipyTestCase):
+class test_UnivariateSpline(NumpyTestCase):
     def check_linear_constant(self):
         x = [1,2,3]
         y = [3,3,3]
@@ -41,7 +41,7 @@
         assert_almost_equal(lut.get_residual(),0.0)
         assert_array_almost_equal(lut([1,1.5,2]),[0,1,2])
 
-class test_LSQBivariateSpline(ScipyTestCase):
+class test_LSQBivariateSpline(NumpyTestCase):
     def check_linear_constant(self):
         x = [1,1,1,2,2,2,3,3,3]
         y = [1,2,3,1,2,3,1,2,3]
@@ -54,7 +54,7 @@
         #print lut.get_coeffs()
         #print lut.get_residual()
 
-class test_SmoothBivariateSpline(ScipyTestCase):
+class test_SmoothBivariateSpline(NumpyTestCase):
     def check_linear_constant(self):
         x = [1,1,1,2,2,2,3,3,3]
         y = [1,2,3,1,2,3,1,2,3]
@@ -75,7 +75,7 @@
         assert_almost_equal(lut.get_residual(),0.0)
         assert_array_almost_equal(lut([1,1.5,2],[1,1.5]),[[0,0],[1,1],[2,2]])
 
-class test_RectBivariateSpline(ScipyTestCase):
+class test_RectBivariateSpline(NumpyTestCase):
     def check_defaults(self):
         x = array([1,2,3,4,5])
         y = array([1,2,3,4,5])
@@ -84,4 +84,4 @@
         assert_array_almost_equal(lut(x,y),z)
 
 if __name__ == "__main__":
-    ScipyTest().run()
+    NumpyTest().run()

Modified: trunk/Lib/sandbox/spline/tests/test_interpolate.py
===================================================================
--- trunk/Lib/sandbox/spline/tests/test_interpolate.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/sandbox/spline/tests/test_interpolate.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -7,7 +7,7 @@
 restore_path()
 
 
-class test_interp2d(ScipyTestCase):
+class test_interp2d(NumpyTestCase):
     def test_interp2d(self):
         y, x = mgrid[0:pi:20j, 0:pi:21j]
         z = sin(x+y)
@@ -18,7 +18,7 @@
         assert_almost_equal(I(u.ravel(), v.ravel()), sin(v+u), decimal=2)
 
 
-class test_interp1d(ScipyTestCase):
+class test_interp1d(NumpyTestCase):
 
     def setUp(self):
         self.x10 = np.arange(10.)
@@ -195,4 +195,4 @@
 
 
 if __name__ == "__main__":
-    ScipyTest().run()
+    NumpyTest().run()

Modified: trunk/Lib/signal/__init__.py
===================================================================
--- trunk/Lib/signal/__init__.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/signal/__init__.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -13,5 +13,5 @@
 from wavelets import *
 
 __all__ = filter(lambda s:not s.startswith('_'),dir())
-from numpy.testing import ScipyTest
-test = ScipyTest().test
+from numpy.testing import NumpyTest
+test = NumpyTest().test

Modified: trunk/Lib/signal/tests/test_signaltools.py
===================================================================
--- trunk/Lib/signal/tests/test_signaltools.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/signal/tests/test_signaltools.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -7,27 +7,27 @@
 
 from numpy import array, arange
 
-class test_convolve(ScipyTestCase):
+class test_convolve(NumpyTestCase):
     def check_basic(self):
         a = [3,4,5,6,5,4]
         b = [1,2,3]
         c = signal.convolve(a,b)
         assert_array_equal(c,array([3,10,22,28,32,32,23,12]))
 
-class test_medfilt(ScipyTestCase):
+class test_medfilt(NumpyTestCase):
     def check_basic(self):
         f = [[3,4,5],[2,3,4],[1,2,5]]
         d = signal.medfilt(f)
         assert_array_equal(d, [[0,3,0],[2,3,3],[0,2,0]])
 
-class test_wiener(ScipyTestCase):
+class test_wiener(NumpyTestCase):
     def check_basic(self):
         g = array([[5,6,4,3],[3,5,6,2],[2,3,5,6],[1,6,9,7]],'d')
         correct = array([[2.16374269,3.2222222222, 2.8888888889, 1.6666666667],[2.666666667, 4.33333333333, 4.44444444444, 2.8888888888],[2.222222222, 4.4444444444, 5.4444444444, 4.801066874837],[1.33333333333, 3.92735042735, 6.0712560386, 5.0404040404]])
         h = signal.wiener(g)
         assert_array_almost_equal(h,correct,decimal=6)
 
-class test_cspline1d_eval(ScipyTestCase):
+class test_cspline1d_eval(NumpyTestCase):
     def check_basic(self):
         y=array([1,2,3,4,3,2,1,2,3.0])
         x=arange(len(y))
@@ -42,4 +42,4 @@
 
 
 if __name__ == "__main__":
-    ScipyTest().run()
+    NumpyTest().run()

Modified: trunk/Lib/sparse/__init__.py
===================================================================
--- trunk/Lib/sparse/__init__.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/sparse/__init__.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -5,5 +5,5 @@
 from sparse import *
 
 __all__ = filter(lambda s:not s.startswith('_'),dir())
-from numpy.testing import ScipyTest
-test = ScipyTest().test
+from numpy.testing import NumpyTest
+test = NumpyTest().test

Modified: trunk/Lib/sparse/tests/test_sparse.py
===================================================================
--- trunk/Lib/sparse/tests/test_sparse.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/sparse/tests/test_sparse.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -461,7 +461,7 @@
 
 
 
-class test_csr(_test_cs, _test_horiz_slicing, _test_arith, ScipyTestCase):
+class test_csr(_test_cs, _test_horiz_slicing, _test_arith, NumpyTestCase):
     spmatrix = csr_matrix
 
     def check_constructor1(self):
@@ -528,7 +528,7 @@
             for ic in range( asp.shape[1] ):
                 assert_equal( asp[ir, ic], bsp[ir, ic] )
                 
-class test_csc(_test_cs, _test_vert_slicing, _test_arith, ScipyTestCase):
+class test_csc(_test_cs, _test_vert_slicing, _test_arith, NumpyTestCase):
     spmatrix = csc_matrix
 
     def check_constructor1(self):
@@ -587,7 +587,7 @@
             for ic in range( asp.shape[1] ):
                 assert_equal( asp[ir, ic], bsp[ir, ic] )
 
-class test_dok(_test_cs, ScipyTestCase):
+class test_dok(_test_cs, NumpyTestCase):
     spmatrix = dok_matrix
 
     def check_mult(self):
@@ -698,7 +698,7 @@
         assert caught == 6
 
 
-class test_lil(_test_cs, _test_horiz_slicing, ScipyTestCase):
+class test_lil(_test_cs, _test_horiz_slicing, NumpyTestCase):
     spmatrix = lil_matrix
     def check_mult(self):
         A = matrix(zeros((10,10)))
@@ -741,7 +741,7 @@
         assert_array_equal(C.A, D.A)
 
 
-class test_construct_utils(ScipyTestCase):
+class test_construct_utils(NumpyTestCase):
     def check_identity(self):
         a = spidentity(3)
         b = array([[1, 0, 0], [0, 1, 0], [0, 0, 1]], dtype='d')
@@ -763,7 +763,7 @@
         b = array([[1, 0, 0], [0, 1, 0], [0, 0, 1]], dtype='d')
         assert_array_equal(a.toarray(), b)
 
-class test_coo(ScipyTestCase):
+class test_coo(NumpyTestCase):
     def check_constructor1(self):
         row  = numpy.array([2, 3, 1, 3, 0, 1, 3, 0, 2, 1, 2])
         col  = numpy.array([0, 1, 0, 0, 1, 1, 2, 2, 2, 2, 1])
@@ -817,4 +817,4 @@
 
 
 if __name__ == "__main__":
-    ScipyTest().run()
+    NumpyTest().run()

Modified: trunk/Lib/special/__init__.py
===================================================================
--- trunk/Lib/special/__init__.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/special/__init__.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -18,5 +18,5 @@
 register_func('i0',i0)
 del register_func
 
-from numpy.testing import ScipyTest
-test = ScipyTest().test
+from numpy.testing import NumpyTest
+test = NumpyTest().test

Modified: trunk/Lib/special/tests/test_basic.py
===================================================================
--- trunk/Lib/special/tests/test_basic.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/special/tests/test_basic.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -41,7 +41,7 @@
 restore_path()
 
 
-class test_cephes(ScipyTestCase):
+class test_cephes(NumpyTestCase):
     def check_airy(self):
         cephes.airy(0)
     def check_airye(self):
@@ -455,7 +455,7 @@
     def check_wofz(self):
         cephes.wofz(0)
 
-class test_airy(ScipyTestCase):
+class test_airy(NumpyTestCase):
 
     def check_airy(self):
         #This tests the airy function to ensure 8 place accuracy in computation
@@ -467,7 +467,7 @@
         x = airy(-.36)
         assert_array_almost_equal(x,array([0.44508477,-0.23186773,0.44939534,0.48105354]),8)
 
-class test_airye(ScipyTestCase):
+class test_airye(NumpyTestCase):
 
     def check_airye(self):
         a = airye(0.01)
@@ -479,7 +479,7 @@
             b1[n] = b[n]*exp(-abs(real(2.0/3.0*0.01*sqrt(0.01))))
         assert_array_almost_equal(a,b1,6)
 
-class test_arange(ScipyTestCase):
+class test_arange(NumpyTestCase):
 
     def check_arange(self):
         numstring = arange(0,2.21,.1)
@@ -498,7 +498,7 @@
         assert_array_equal(numstringc,array([3.3,7.3,11.3,15.3,
                                              19.3,23.3]))
 
-class test_ai_zeros(ScipyTestCase):
+class test_ai_zeros(NumpyTestCase):
 
     def check_ai_zeros(self):
         ai = ai_zeros(1)
@@ -507,7 +507,7 @@
                                      array([ 0.5357]),
                                      array([ 0.7012])),4)
 
-class test_array(ScipyTestCase):
+class test_array(NumpyTestCase):
 
     def check_array(self):
         x = array([1,2,3,4])
@@ -517,7 +517,7 @@
         a = arange(1,5,1)
         assert_array_equal(a,x)
 
-class test_assoc_laguerre(ScipyTestCase):
+class test_assoc_laguerre(NumpyTestCase):
 
     def check_assoc_laguerre(self):
         a1 = genlaguerre(11,1)
@@ -526,36 +526,36 @@
         a2 = assoc_laguerre(1,11,1)
         assert_array_almost_equal(a2,a1(1),8)
 
-class test_besselpoly(ScipyTestCase):
+class test_besselpoly(NumpyTestCase):
 
     def check_besselpoly(self):
         pass
 
-class test_bei(ScipyTestCase):
+class test_bei(NumpyTestCase):
 
     def check_bei(self):
         mbei = bei(2)
         assert_almost_equal(mbei, 0.9722916273066613,5)#this may not be exact
 
-class test_beip(ScipyTestCase):
+class test_beip(NumpyTestCase):
 
     def check_beip(self):
         mbeip = beip(2)
         assert_almost_equal(mbeip,0.91701361338403631,5)#this may not be exact
 
-class test_ber(ScipyTestCase):
+class test_ber(NumpyTestCase):
 
     def check_ber(self):
         mber = ber(2)
         assert_almost_equal(mber,0.75173418271380821,5)#this may not be exact
 
-class test_berp(ScipyTestCase):
+class test_berp(NumpyTestCase):
 
     def check_berp(self):
         mberp = berp(2)
         assert_almost_equal(mberp,-0.49306712470943909,5)#this may not be exact
 
-class test_bei_zeros(ScipyTestCase):
+class test_bei_zeros(NumpyTestCase):
 
     def check_bei_zeros(self):
         bi = bi_zeros(5)
@@ -584,7 +584,7 @@
                                                0.929983638568022]),11)
 
 
-class test_beip_zeros(ScipyTestCase):
+class test_beip_zeros(NumpyTestCase):
 
     def check_beip_zeros(self):
         bip = beip_zeros(5)
@@ -593,7 +593,7 @@
                                                12.742147523633703,
                                                17.193431752512542,
                                                21.641143941167325]),4)
-class test_ber_zeros(ScipyTestCase):
+class test_ber_zeros(NumpyTestCase):
 
     def check_ber_zeros(self):
         ber = ber_zeros(5)
@@ -603,7 +603,7 @@
                                              16.11356,
                                              20.55463]),4)
 
-class test_bernoulli(ScipyTestCase):
+class test_bernoulli(NumpyTestCase):
 
     def check_bernoulli(self):
         brn = bernoulli(5)
@@ -614,7 +614,7 @@
                                              -0.0333,
                                              0.0000]),4)
 
-class test_berp_zeros(ScipyTestCase):
+class test_berp_zeros(NumpyTestCase):
 
     def check_berp_zeros(self):
         brp = berp_zeros(5)
@@ -623,34 +623,34 @@
                                              14.96844,
                                              19.41758,
                                              23.86430]),4)
-class test_beta(ScipyTestCase):
+class test_beta(NumpyTestCase):
 
     def check_beta(self):
         bet = beta(2,4)
         betg = (gamma(2)*gamma(4))/gamma(6)
         assert_almost_equal(bet,betg,8)
 
-class test_betaln(ScipyTestCase):
+class test_betaln(NumpyTestCase):
 
     def check_betaln(self):
         betln = betaln(2,4)
         bet = log(abs(beta(2,4)))
         assert_almost_equal(betln,bet,8)
 
-class test_betainc(ScipyTestCase):
+class test_betainc(NumpyTestCase):
 
     def check_betainc(self):
         btinc = betainc(1,1,.2)
         assert_almost_equal(btinc,0.2,8)
 
-class test_betaincinv(ScipyTestCase):
+class test_betaincinv(NumpyTestCase):
 
     def check_betaincinv(self):
         y = betaincinv(2,4,.5)
         comp = betainc(2,4,y)
         assert_almost_equal(comp,.5,5)
 
-class test_bi_zeros(ScipyTestCase):
+class test_bi_zeros(NumpyTestCase):
 
     def check_bi_zeros(self):
         bi = bi_zeros(2)
@@ -660,7 +660,7 @@
         array([ 0.60195789 , -0.76031014]))
         assert_array_almost_equal(bi,bia,4)
 
-class test_chebyc(ScipyTestCase):
+class test_chebyc(NumpyTestCase):
 
     def check_chebyc(self):
         C0 = chebyc(0)
@@ -677,7 +677,7 @@
         assert_array_almost_equal(C4.c,[1,0,-4,0,2],13)
         assert_array_almost_equal(C5.c,[1,0,-5,0,5,0],13)
 
-class test_chebys(ScipyTestCase):
+class test_chebys(NumpyTestCase):
 
     def check_chebys(self):
         S0 = chebys(0)
@@ -693,7 +693,7 @@
         assert_array_almost_equal(S4.c,[1,0,-3,0,1],13)
         assert_array_almost_equal(S5.c,[1,0,-4,0,3,0],13)
 
-class test_chebyt(ScipyTestCase):
+class test_chebyt(NumpyTestCase):
 
     def check_chebyt(self):
         T0 = chebyt(0)
@@ -709,7 +709,7 @@
         assert_array_almost_equal(T4.c,[8,0,-8,0,1],13)
         assert_array_almost_equal(T5.c,[16,0,-20,0,5,0],13)
 
-class test_chebyu(ScipyTestCase):
+class test_chebyu(NumpyTestCase):
 
     def check_chebyu(self):
         U0 = chebyu(0)
@@ -725,14 +725,14 @@
         assert_array_almost_equal(U4.c,[16,0,-12,0,1],13)
         assert_array_almost_equal(U5.c,[32,0,-32,0,6,0],13)
 
-class test_choose(ScipyTestCase):
+class test_choose(NumpyTestCase):
 
     def check_choose(self):
         carray = [1,3,2,4,6,5]
         chose = choose([1,3,5],carray)
         assert_array_equal(chose,array([3,4,5]))
 
-class test_cbrt(ScipyTestCase):
+class test_cbrt(NumpyTestCase):
 
     def check_cbrt(self):
         cb = cbrt(27)
@@ -744,7 +744,7 @@
         cbrl1 = 27.9**(1.0/3.0)
         assert_almost_equal(cb1,cbrl1,8)
 
-class test_cosdg(ScipyTestCase):
+class test_cosdg(NumpyTestCase):
 
     def check_cosdg(self):
         cdg = cosdg(90)
@@ -756,14 +756,14 @@
         cdgmrl = cos(pi/6.0)
         assert_almost_equal(cdgm,cdgmrl,8)
 
-class test_cosm1(ScipyTestCase):
+class test_cosm1(NumpyTestCase):
 
     def check_cosm1(self):
         cs = (cosm1(0),cosm1(.3),cosm1(pi/10))
         csrl = (cos(0)-1,cos(.3)-1,cos(pi/10)-1)
         assert_array_almost_equal(cs,csrl,8)
 
-class test_cotdg(ScipyTestCase):
+class test_cotdg(NumpyTestCase):
 
     def check_cotdg(self):
         ct = cotdg(30)
@@ -790,20 +790,20 @@
         assert_almost_equal(cotdg(-315), 1.0, 14)
         assert_almost_equal(cotdg(765), 1.0, 14)
 
-class test_ellipj(ScipyTestCase):
+class test_ellipj(NumpyTestCase):
 
     def check_ellipj(self):
         el = ellipj(0.2,0)
         rel = [sin(0.2),cos(0.2),1.0,0.20]
         assert_array_almost_equal(el,rel,13)
 
-class test_ellipk(ScipyTestCase):
+class test_ellipk(NumpyTestCase):
 
     def check_ellipk(self):
         elk = ellipk(.2)
         assert_almost_equal(elk,1.659623598610528,11)
 
-class test_ellipkinc(ScipyTestCase):
+class test_ellipkinc(NumpyTestCase):
 
     def check_ellipkinc(self):
         elkinc = ellipkinc(pi/2,.2)
@@ -817,13 +817,13 @@
         # From pg. 614 of A & S
 
 
-class test_ellipe(ScipyTestCase):
+class test_ellipe(NumpyTestCase):
 
     def check_ellipe(self):
         ele = ellipe(.2)
         assert_almost_equal(ele,1.4890350580958529,8)
 
-class test_ellipeinc(ScipyTestCase):
+class test_ellipeinc(NumpyTestCase):
 
     def check_ellipeinc(self):
         eleinc = ellipeinc(pi/2,.2)
@@ -836,13 +836,13 @@
         assert_almost_equal(eleinc, 0.58823065, 8)
 
 
-class test_erf(ScipyTestCase):
+class test_erf(NumpyTestCase):
 
     def check_erf(self):
         er = erf(.25)
         assert_almost_equal(er,0.2763263902,8)
 
-class test_erf_zeros(ScipyTestCase):
+class test_erf_zeros(NumpyTestCase):
 
     def check_erf_zeros(self):
         erz = erf_zeros(5)
@@ -853,19 +853,19 @@
                      3.76900557+4.06069723j])
         assert_array_almost_equal(erz,erzr,4)
 
-class test_erfcinv(ScipyTestCase):
+class test_erfcinv(NumpyTestCase):
 
     def check_erfcinv(self):
         i = erfcinv(1)
         assert_equal(i,0)
 
-class test_erfinv(ScipyTestCase):
+class test_erfinv(NumpyTestCase):
 
     def check_erfinv(self):
         i = erfinv(0)
         assert_equal(i,0)
 
-class test_errprint(ScipyTestCase):
+class test_errprint(NumpyTestCase):
 
     def check_errprint(self):
         a = errprint()
@@ -876,7 +876,7 @@
         assert_equal(d,b) #makes sure state was returned
         #assert_equal(d,1-a)
 
-class test_euler(ScipyTestCase):
+class test_euler(NumpyTestCase):
 
     def check_euler(self):
         eu0 = euler(0)
@@ -899,7 +899,7 @@
         errmax = max(err)
         assert_almost_equal(errmax, 0.0, 14)
 
-class test_exp2(ScipyTestCase):
+class test_exp2(NumpyTestCase):
 
     def check_exp2(self):
         ex = exp2(2)
@@ -911,7 +911,7 @@
         exmrl = 2**(2.5)
         assert_almost_equal(exm,exmrl,8)
 
-class test_exp10(ScipyTestCase):
+class test_exp10(NumpyTestCase):
 
     def check_exp10(self):
         ex = exp10(2)
@@ -923,7 +923,7 @@
         exmrl = 10**(2.5)
         assert_almost_equal(exm,exmrl,8)
 
-class test_expm1(ScipyTestCase):
+class test_expm1(NumpyTestCase):
 
     def check_expm1(self):
         ex = (expm1(2),expm1(3),expm1(4))
@@ -935,13 +935,13 @@
         exrl1 = (exp(2)-1,exp(2.1)-1,exp(2.2)-1)
         assert_array_almost_equal(ex1,exrl1,8)
 
-class test_fresnel(ScipyTestCase):
+class test_fresnel(NumpyTestCase):
 
     def check_fresnel(self):
         frs = array(fresnel(.5))
         assert_array_almost_equal(frs,array([0.064732432859999287, 0.49234422587144644]),8)
 
-class test_fresnel_zeros(ScipyTestCase):
+class test_fresnel_zeros(NumpyTestCase):
 
     # values from pg 329  Table 7.11 of A & S
     #  slightly corrected in 4th decimal place
@@ -975,48 +975,48 @@
         assert_array_almost_equal(frs,szo,12)
 
 
-class test_gamma(ScipyTestCase):
+class test_gamma(NumpyTestCase):
 
     def check_gamma(self):
 
         gam = gamma(5)
         assert_equal(gam,24.0)
 
-class test_gammaln(ScipyTestCase):
+class test_gammaln(NumpyTestCase):
 
     def check_gammaln(self):
         gamln = gammaln(3)
         lngam = log(gamma(3))
         assert_almost_equal(gamln,lngam,8)
 
-class test_gammainc(ScipyTestCase):
+class test_gammainc(NumpyTestCase):
 
     def check_gammainc(self):
         gama = gammainc(.5,.5)
         assert_almost_equal(gama,.7,1)
 
-class test_gammaincc(ScipyTestCase):
+class test_gammaincc(NumpyTestCase):
 
     def check_gammaincc(self):
         gicc = gammaincc(.5,.5)
         greal = 1 - gammainc(.5,.5)
         assert_almost_equal(gicc,greal,8)
 
-class test_gammainccinv(ScipyTestCase):
+class test_gammainccinv(NumpyTestCase):
 
     def check_gammainccinv(self):
         gccinv = gammainccinv(.5,.5)
         gcinv = gammaincinv(.5,.5)
         assert_almost_equal(gccinv,gcinv,8)
 
-class test_gammaincinv(ScipyTestCase):
+class test_gammaincinv(NumpyTestCase):
 
     def check_gammaincinv(self):
         y = gammaincinv(.4,.4)
         x = gammainc(.4,y)
         assert_almost_equal(x,0.4,1)
 
-class test_hankel1(ScipyTestCase):
+class test_hankel1(NumpyTestCase):
     def check_negv(self):
         assert_almost_equal(hankel1(-3,2), -hankel1(3,2), 14)
 
@@ -1025,7 +1025,7 @@
         hankrl = (jv(1,.1)+yv(1,.1)*1j)
         assert_almost_equal(hank1,hankrl,8)
 
-class test_hankel1e(ScipyTestCase):
+class test_hankel1e(NumpyTestCase):
     def check_negv(self):
         assert_almost_equal(hankel1e(-3,2), -hankel1e(3,2), 14)
 
@@ -1034,7 +1034,7 @@
         hankrle = hankel1(1,.1)*exp(-.1j)
         assert_almost_equal(hank1e,hankrle,8)
 
-class test_hankel2(ScipyTestCase):
+class test_hankel2(NumpyTestCase):
     def check_negv(self):
         assert_almost_equal(hankel2(-3,2), -hankel2(3,2), 14)
 
@@ -1043,7 +1043,7 @@
         hankrl2 = (jv(1,.1)-yv(1,.1)*1j)
         assert_almost_equal(hank2,hankrl2,8)
 
-class test_hankel2e(ScipyTestCase):
+class test_hankel2e(NumpyTestCase):
     def check_negv(self):
         assert_almost_equal(hankel2e(-3,2), -hankel2e(3,2), 14)
 
@@ -1052,7 +1052,7 @@
         hankrl2e = hankel2e(1,.1)
         assert_almost_equal(hank2e,hankrl2e,8)
 
-class test_hermite(ScipyTestCase):
+class test_hermite(NumpyTestCase):
 
     def check_hermite(self):
         H0 = hermite(0)
@@ -1093,7 +1093,7 @@
 
 _gam = cephes.gamma
 
-class test_gegenbauer(ScipyTestCase):
+class test_gegenbauer(NumpyTestCase):
 
     def check_gegenbauer(self):
         a = 5*rand()-0.5
@@ -1116,7 +1116,7 @@
                                                0,15*poch(a,3),0])/15.0,11)
 
 
-class test_h1vp(ScipyTestCase):
+class test_h1vp(NumpyTestCase):
 
     def check_h1vp(self):
 
@@ -1124,36 +1124,36 @@
         h1real = (jvp(1,.1)+yvp(1,.1)*1j)
         assert_almost_equal(h1,h1real,8)
 
-class test_h2vp(ScipyTestCase):
+class test_h2vp(NumpyTestCase):
 
     def check_h2vp(self):
         h2 = h2vp(1,.1)
         h2real = (jvp(1,.1)-yvp(1,.1)*1j)
         assert_almost_equal(h2,h2real,8)
 
-class test_hyp0f1(ScipyTestCase):
+class test_hyp0f1(NumpyTestCase):
 
     def check_hyp0f1(self):
         pass
 
-class test_hyp1f1(ScipyTestCase):
+class test_hyp1f1(NumpyTestCase):
 
     def check_hyp1f1(self):
 
         hyp1 = hyp1f1(.1,.1,.3)
         assert_almost_equal(hyp1, 1.3498588075760032,7)
 
-class test_hyp1f2(ScipyTestCase):
+class test_hyp1f2(NumpyTestCase):
 
     def check_hyp1f2(self):
         pass
 
-class test_hyp2f0(ScipyTestCase):
+class test_hyp2f0(NumpyTestCase):
 
     def check_hyp2f0(self):
         pass
 
-class test_hyp2f1(ScipyTestCase):
+class test_hyp2f1(NumpyTestCase):
     def check_hyp2f1(self):
         # a collection of special cases taken from AMS 55
         values = [[0.5, 1, 1.5, 0.2**2, 0.5/0.2*log((1+0.2)/(1-0.2))],
@@ -1174,12 +1174,12 @@
             cv = hyp2f1(a, b, c, x)
             assert_almost_equal(cv, v, 8, err_msg='test #%d' % i)
 
-class test_hyp3f0(ScipyTestCase):
+class test_hyp3f0(NumpyTestCase):
 
     def check_hyp3f0(self):
         pass
 
-class test_hyperu(ScipyTestCase):
+class test_hyperu(NumpyTestCase):
 
     def check_hyperu(self):
         val1 = hyperu(1,0.1,100)
@@ -1194,7 +1194,7 @@
                                /(gamma(a)*gamma(2-b)))
         assert_array_almost_equal(hypu,hprl,12)
 
-class test_i0(ScipyTestCase):
+class test_i0(NumpyTestCase):
     def check_i0(self):
         values = [[0.0, 1.0],
                   [1e-10, 1.0],
@@ -1209,14 +1209,14 @@
             cv = i0(x) * exp(-x)
             assert_almost_equal(cv, v, 8, err_msg='test #%d' % i)
 
-class test_i0e(ScipyTestCase):
+class test_i0e(NumpyTestCase):
 
     def check_i0e(self):
         oize = i0e(.1)
         oizer = ive(0,.1)
         assert_almost_equal(oize,oizer,8)
 
-class test_i1(ScipyTestCase):
+class test_i1(NumpyTestCase):
 
     def check_i1(self):
         values = [[0.0, 0.0],
@@ -1231,38 +1231,38 @@
             cv = i1(x) * exp(-x)
             assert_almost_equal(cv, v, 8, err_msg='test #%d' % i)
 
-class test_i1e(ScipyTestCase):
+class test_i1e(NumpyTestCase):
 
     def check_i1e(self):
         oi1e = i1e(.1)
         oi1er = ive(1,.1)
         assert_almost_equal(oi1e,oi1er,8)
 
-class test_iti0k0(ScipyTestCase):
+class test_iti0k0(NumpyTestCase):
 
     def check_iti0k0(self):
         iti0 = array(iti0k0(5))
         assert_array_almost_equal(iti0,array([31.848667776169801, 1.5673873907283657]),5)
 
-class test_it2i0k0(ScipyTestCase):
+class test_it2i0k0(NumpyTestCase):
 
     def check_it2i0k0(self):
         it2k = it2i0k0(.1)
         assert_array_almost_equal(it2k,array([0.0012503906973464409, 3.3309450354686687]),6)
 
-class test_itj0y0(ScipyTestCase):
+class test_itj0y0(NumpyTestCase):
 
     def check_itj0y0(self):
         it0 = array(itj0y0(.2))
         assert_array_almost_equal(it0,array([0.19933433254006822, -0.34570883800412566]),8)
 
-class test_it2j0y0(ScipyTestCase):
+class test_it2j0y0(NumpyTestCase):
 
     def check_it2j0y0(self):
         it2 = array(it2j0y0(.2))
         assert_array_almost_equal(it2,array([0.0049937546274601858, -0.43423067011231614]),8)
 
-class test_iv(ScipyTestCase):
+class test_iv(NumpyTestCase):
     def check_negv(self):
         assert_equal(iv(3,2), iv(-3,2))
 
@@ -1270,7 +1270,7 @@
         iv1 = iv(0,.1)*exp(-.1)
         assert_almost_equal(iv1,0.90710092578230106,10)
 
-class test_ive(ScipyTestCase):
+class test_ive(NumpyTestCase):
     def check_negv(self):
         assert_equal(ive(3,2), ive(-3,2))
 
@@ -1279,7 +1279,7 @@
         iv1 = iv(0,.1)*exp(-.1)
         assert_almost_equal(ive1,iv1,10)
 
-class test_ivp(ScipyTestCase):
+class test_ivp(NumpyTestCase):
     def check_ivp0(self):
         assert_almost_equal(iv(1,2), ivp(0,2), 10)
 
@@ -1288,21 +1288,21 @@
         x = ivp(1,2)
         assert_almost_equal(x,y,10)
 
-class test_j0(ScipyTestCase):
+class test_j0(NumpyTestCase):
 
     def check_j0(self):
         oz = j0(.1)
         ozr = jn(0,.1)
         assert_almost_equal(oz,ozr,8)
 
-class test_j1(ScipyTestCase):
+class test_j1(NumpyTestCase):
 
     def check_j1(self):
         o1 = j1(.1)
         o1r = jn(1,.1)
         assert_almost_equal(o1,o1r,8)
 
-class test_jacobi(ScipyTestCase):
+class test_jacobi(NumpyTestCase):
 
     def check_jacobi(self):
         a = 5*rand() - 1
@@ -1323,13 +1323,13 @@
         assert_array_almost_equal(P3.c,array(p3c)/48.0,13)
 
 
-class test_jn(ScipyTestCase):
+class test_jn(NumpyTestCase):
 
     def check_jn(self):
         jnnr = jn(1,.2)
         assert_almost_equal(jnnr,0.099500832639235995,8)
 
-class test_jv(ScipyTestCase):
+class test_jv(NumpyTestCase):
     def check_negv(self):
         assert_almost_equal(jv(-3,2), -jv(3,2), 14)
 
@@ -1344,7 +1344,7 @@
             yc = jv(v, x)
             assert_almost_equal(yc, y, 8, err_msg='test #%d' % i)
 
-class test_jve(ScipyTestCase):
+class test_jve(NumpyTestCase):
     def check_negv(self):
         assert_almost_equal(jve(-3,2), -jve(3,2), 14)
 
@@ -1356,7 +1356,7 @@
         jvexpr = jv(1,z)*exp(-abs(z.imag))
         assert_almost_equal(jvexp1,jvexpr,8)
 
-class test_jn_zeros(ScipyTestCase):
+class test_jn_zeros(NumpyTestCase):
 
     def check_jn_zeros(self):
         jn0 = jn_zeros(0,5)
@@ -1372,7 +1372,7 @@
                                               13.32369,
                                               16.47063]),4)
 
-class test_jnjnp_zeros(ScipyTestCase):
+class test_jnjnp_zeros(NumpyTestCase):
 
     def check_jnjnp_zeros(self):
         pass
@@ -1381,7 +1381,7 @@
         #I don't think specfun jdzo is working properly the outputs do not seem to correlate
         #to the inputs
 
-class test_jnp_zeros(ScipyTestCase):
+class test_jnp_zeros(NumpyTestCase):
 
     def check_jnp_zeros(self):
         jnp = jnp_zeros(1,5)
@@ -1391,7 +1391,7 @@
                                                 11.70600,
                                                 14.86359]),4)
 
-class test_jnyn_zeros(ScipyTestCase):
+class test_jnyn_zeros(NumpyTestCase):
 
     def check_jnyn_zeros(self):
         jnz = jnyn_zeros(1,5)
@@ -1416,48 +1416,48 @@
                                                 13.28576,
                                                 16.44006])),4)
 
-class test_jvp(ScipyTestCase):
+class test_jvp(NumpyTestCase):
 
     def check_jvp(self):
         jvprim = jvp(2,2)
         jv0 = (jv(1,2)-jv(3,2))/2
         assert_almost_equal(jvprim,jv0,10)
 
-class test_k0(ScipyTestCase):
+class test_k0(NumpyTestCase):
 
     def check_k0(self):
         ozk = k0(.1)
         ozkr = kv(0,.1)
         assert_almost_equal(ozk,ozkr,8)
 
-class test_k0e(ScipyTestCase):
+class test_k0e(NumpyTestCase):
 
     def check_k0e(self):
         ozke = k0e(.1)
         ozker = kve(0,.1)
         assert_almost_equal(ozke,ozker,8)
 
-class test_k1(ScipyTestCase):
+class test_k1(NumpyTestCase):
 
     def check_k1(self):
         o1k = k1(.1)
         o1kr = kv(1,.1)
         assert_almost_equal(o1k,o1kr,8)
 
-class test_k1e(ScipyTestCase):
+class test_k1e(NumpyTestCase):
 
     def check_k1e(self):
         o1ke = k1e(.1)
         o1ker = kve(1,.1)
         assert_almost_equal(o1ke,o1ker,8)
 
-class test_kei(ScipyTestCase):
+class test_kei(NumpyTestCase):
 
     def check_kei(self):
         mkei = kei(2)
         assert_almost_equal(mkei,-0.20240006776470432,5)
 
-class test_kelvin(ScipyTestCase):
+class test_kelvin(NumpyTestCase):
 
     def check_kelvin(self):
         mkelv = kelvin(2)
@@ -1466,25 +1466,25 @@
                                          berp(2)+beip(2)*1j,
                                          kerp(2)+keip(2)*1j),8)
 
-class test_keip(ScipyTestCase):
+class test_keip(NumpyTestCase):
 
     def  check_keip(self):
         mkeip = keip(2)
         assert_almost_equal(mkeip,0.21980790991960536,5)
 
-class test_ker(ScipyTestCase):
+class test_ker(NumpyTestCase):
 
     def check_ker(self):
         mker = ker(2)
         assert_almost_equal(mker,-0.041664513991509472,5)
 
-class test_kerp(ScipyTestCase):
+class test_kerp(NumpyTestCase):
 
     def check_kerp(self):
         mkerp = kerp(2)
         assert_almost_equal(mkerp,-0.10660096588105264,5)
 
-class test_kei_zeros(ScipyTestCase):
+class test_kei_zeros(NumpyTestCase):
 
     def check_kei_zeros(self):
         kei = kei_zeros(5)
@@ -1494,7 +1494,7 @@
                                               17.22314,
                                               21.66464]),4)
 
-class test_keip_zeros(ScipyTestCase):
+class test_keip_zeros(NumpyTestCase):
 
     def check_keip_zeros(self):
         keip = keip_zeros(5)
@@ -1506,7 +1506,7 @@
 
 
 
-class test_kelvin_zeros(ScipyTestCase):
+class test_kelvin_zeros(NumpyTestCase):
 
     # numbers come from 9.9 of A&S pg. 381
     def check_kelvin_zeros(self):
@@ -1555,7 +1555,7 @@
                                                 18.30717,
                                                 22.75379]),4)
 
-class test_ker_zeros(ScipyTestCase):
+class test_ker_zeros(NumpyTestCase):
 
     def check_ker_zeros(self):
         ker = ker_zeros(5)
@@ -1565,7 +1565,7 @@
                                                15.00269,
                                                19.44381]),4)
 
-class test_kerp_zeros(ScipyTestCase):
+class test_kerp_zeros(NumpyTestCase):
 
     def check_kerp_zeros(self):
         kerp = kerp_zeros(5)
@@ -1575,13 +1575,13 @@
                                                 16.08312,
                                                 20.53068]),4)
 
-class test_kn(ScipyTestCase):
+class test_kn(NumpyTestCase):
 
     def check_kn(self):
         kn1 = kn(0,.2)
         assert_almost_equal(kn1,1.7527038555281462,8)
 
-class test_kv(ScipyTestCase):
+class test_kv(NumpyTestCase):
     def check_negv(self):
         assert_equal(kv(3.0, 2.2), kv(-3.0, 2.2))
 
@@ -1596,7 +1596,7 @@
         assert_almost_equal(kv2, 49.51242928773287, 10)
 
 
-class test_kve(ScipyTestCase):
+class test_kve(NumpyTestCase):
     def check_negv(self):
         assert_equal(kve(3.0, 2.2), kve(-3.0, 2.2))
 
@@ -1609,7 +1609,7 @@
         kv2 = kv(0,z)*exp(z)
         assert_almost_equal(kve2,kv2,8)
 
-class test_kvp(ScipyTestCase):
+class test_kvp(NumpyTestCase):
     def check_kvp_v0n1(self):
         z = 2.2
         assert_almost_equal(-kv(1,z), kvp(0,z, n=1), 10)
@@ -1628,7 +1628,7 @@
         x = kvp(v, z, n=2)
         assert_almost_equal(xc, x, 10)
 
-class test_laguerre(ScipyTestCase):
+class test_laguerre(NumpyTestCase):
 
     def check_laguerre(self):
         lag0 = laguerre(0)
@@ -1657,7 +1657,7 @@
 
 
 # Base polynomials come from Abrahmowitz and Stegan
-class test_legendre(ScipyTestCase):
+class test_legendre(NumpyTestCase):
 
     def check_legendre(self):
         leg0 = legendre(0)
@@ -1674,7 +1674,7 @@
         assert_almost_equal(leg5.c,array([63,0,-70,0,15,0])/8.0)
 
 
-class test_lmbda(ScipyTestCase):
+class test_lmbda(NumpyTestCase):
 
     def check_lmbda(self):
         lam = lmbda(1,.1)
@@ -1682,7 +1682,7 @@
                 array([jvp(0,.1), -2*jv(1,.1)/.01 + 2*jvp(1,.1)/.1]))
         assert_array_almost_equal(lam,lamr,8)
 
-class test_log1p(ScipyTestCase):
+class test_log1p(NumpyTestCase):
 
     def check_log1p(self):
         l1p = (log1p(10),log1p(11),log1p(12))
@@ -1694,7 +1694,7 @@
         l1pmrl = (log(2),log(2.1),log(2.2))
         assert_array_almost_equal(l1pm,l1pmrl,8)
 
-class test_lpmn(ScipyTestCase):
+class test_lpmn(NumpyTestCase):
 
     def check_lpmn(self):
 
@@ -1706,7 +1706,7 @@
                                                       1.00000 ,
                                                       1.50000]])),4)
 
-class test_lpn(ScipyTestCase):
+class test_lpn(NumpyTestCase):
 
     def check_lpn(self):
         lpnf = lpn(2,.5)
@@ -1717,13 +1717,13 @@
                                                       1.00000 ,
                                                       1.50000])),4)
 
-class test_lpmv(ScipyTestCase):
+class test_lpmv(NumpyTestCase):
 
     def check_lpmv(self):
         lp = lpmv(0,2,.5)
         assert_almost_equal(lp,-0.125,3)
 
-class test_lqmn(ScipyTestCase):
+class test_lqmn(NumpyTestCase):
 
     def check_lqmn(self):
         lqmnf = lqmn(0,2,.5)
@@ -1735,41 +1735,41 @@
 
 
 
-class test_lqn(ScipyTestCase):
+class test_lqn(NumpyTestCase):
 
     def check_lqn(self):
         lqf = lqn(2,.5)
         assert_array_almost_equal(lqf,(array([ 0.5493, -0.7253, -0.8187]),
                                        array([ 1.3333,  1.216 , -0.8427])),4)
 
-class test_mathieu_a(ScipyTestCase):
+class test_mathieu_a(NumpyTestCase):
 
     def check_mathieu_a(self):
         pass
 
-class test_mathieu_even_coef(ScipyTestCase):
+class test_mathieu_even_coef(NumpyTestCase):
 
     def check_mathieu_even_coef(self):
         mc =  mathieu_even_coef(2,5)
         #Q not defined broken and cannot figure out proper reporting order
 
-class test_mathieu_odd_coef(ScipyTestCase):
+class test_mathieu_odd_coef(NumpyTestCase):
 
     def check_mathieu_odd_coef(self):
         pass
             #same problem as above
 
-class test_modfresnelp(ScipyTestCase):
+class test_modfresnelp(NumpyTestCase):
 
     def check_modfresnelp(self):
         pass
 
-class test_modfresnelm(ScipyTestCase):
+class test_modfresnelm(NumpyTestCase):
 
     def check_modfresnelm(self):
         pass
 
-class test_obl_cv_seq(ScipyTestCase):
+class test_obl_cv_seq(NumpyTestCase):
 
     def check_obl_cv_seq(self):
         obl = obl_cv_seq(0,3,1)
@@ -1778,7 +1778,7 @@
                                               5.486800,
                                               11.492120]),5)
 
-class test_pbdn_seq(ScipyTestCase):
+class test_pbdn_seq(NumpyTestCase):
 
     def check_pbdn_seq(self):
         pb = pbdn_seq(1,.1)
@@ -1787,25 +1787,25 @@
                                       array([-0.0499,
                                              0.9925])),4)
 
-class test_pbdv(ScipyTestCase):
+class test_pbdv(NumpyTestCase):
 
     def check_pbdv(self):
         pbv = pbdv(1,.2)
         derrl = 1/2*(.2)*pbdv(1,.2)[0] - pbdv(0,.2)[0]
 
-class _test_pbdv_seq(ScipyTestCase):
+class _test_pbdv_seq(NumpyTestCase):
 
     def check_pbdv_seq(self):
         pbn = pbdn_seq(1,.1)
         pbv = pbdv_seq(1,.1)
         assert_array_almost_equal(pbv,(real(pbn[0]),real(pbn[1])),4)
 
-class test_pbvv_seq(ScipyTestCase):
+class test_pbvv_seq(NumpyTestCase):
 
     def check_pbvv_seq(self):
         pass
 
-class test_polygamma(ScipyTestCase):
+class test_polygamma(NumpyTestCase):
 
     # from Table 6.2 (pg. 271) of A&S
     def check_polygamma(self):
@@ -1814,7 +1814,7 @@
         assert_almost_equal(poly2,-2.4041138063,10)
         assert_almost_equal(poly3,6.4939394023,10)
 
-class test_pro_cv_seq(ScipyTestCase):
+class test_pro_cv_seq(NumpyTestCase):
 
     def check_pro_cv_seq(self):
         prol = pro_cv_seq(0,3,1)
@@ -1823,13 +1823,13 @@
                                                6.533471,
                                                12.514462]),5)
 
-class test_psi(ScipyTestCase):
+class test_psi(NumpyTestCase):
 
     def check_psi(self):
         ps = psi(1)
         assert_almost_equal(ps,-0.57721566490153287,8)
 
-class test_radian(ScipyTestCase):
+class test_radian(NumpyTestCase):
 
     def check_radian(self):
         rad = radian(90,0,0)
@@ -1839,7 +1839,7 @@
         rad1 = radian(90,1,60)
         assert_almost_equal(rad1,pi/2+0.0005816135199345904,5)
 
-class test_reshape(ScipyTestCase):
+class test_reshape(NumpyTestCase):
 
     def check_reshape(self):
         a = (array([1,2,3]),array([4,5,6]))
@@ -1851,28 +1851,28 @@
                                     [3, 4],
                                     [5, 6]]))
 
-class test_rgamma(ScipyTestCase):
+class test_rgamma(NumpyTestCase):
 
     def check_rgamma(self):
         rgam = rgamma(8)
         rlgam = 1/gamma(8)
         assert_almost_equal(rgam,rlgam,8)
 
-class test_riccati_jn(ScipyTestCase):
+class test_riccati_jn(NumpyTestCase):
 
     def check_riccati_jn(self):
         jnrl = (sph_jn(1,.2)[0]*.2,sph_jn(1,.2)[0]+sph_jn(1,.2)[1]*.2)
         ricjn = riccati_jn(1,.2)
         assert_array_almost_equal(ricjn,jnrl,8)
 
-class test_riccati_yn(ScipyTestCase):
+class test_riccati_yn(NumpyTestCase):
 
     def check_riccati_yn(self):
         ynrl = (sph_yn(1,.2)[0]*.2,sph_yn(1,.2)[0]+sph_yn(1,.2)[1]*.2)
         ricyn = riccati_yn(1,.2)
         assert_array_almost_equal(ricyn,ynrl,8)
 
-class test_round(ScipyTestCase):
+class test_round(NumpyTestCase):
 
     def check_round(self):
         rnd = map(int,(round(10.1),round(10.4),round(10.5),round(10.6)))
@@ -1885,7 +1885,7 @@
         rndrl = (10,10,10,11)
         assert_array_equal(rnd,rndrl)
 
-class _test_sh_legendre(ScipyTestCase):
+class _test_sh_legendre(NumpyTestCase):
 
     def check_sh_legendre(self):
         # P*_n(x) = P_n(2x-1)
@@ -1909,7 +1909,7 @@
         assert_array_almost_equal(Ps4.c,pse4.c,12)
         assert_array_almost_equal(Ps5.c,pse5.c,12)
 
-class _test_sh_chebyt(ScipyTestCase):
+class _test_sh_chebyt(NumpyTestCase):
 
     def check_sh_chebyt(self):
         # T*_n(x) = T_n(2x-1)
@@ -1934,7 +1934,7 @@
         assert_array_almost_equal(Ts5.c,tse5.c,12)
 
 
-class _test_sh_chebyu(ScipyTestCase):
+class _test_sh_chebyu(NumpyTestCase):
 
     def check_sh_chebyu(self):
         # U*_n(x) = U_n(2x-1)
@@ -1958,7 +1958,7 @@
         assert_array_almost_equal(Us4.c,use4.c,12)
         assert_array_almost_equal(Us5.c,use5.c,11)
 
-class _test_sh_jacobi(ScipyTestCase):
+class _test_sh_jacobi(NumpyTestCase):
 
     def check_sh_jacobi(self):
         # G^(p,q)_n(x) = n! gamma(n+p)/gamma(2*n+p) * P^(p-q,q-1)_n(2*x-1)
@@ -1988,7 +1988,7 @@
         assert_array_almost_equal(G5.c,ge5.c,13)
 
 
-class test_sinc(ScipyTestCase):
+class test_sinc(NumpyTestCase):
 
     def check_sinc(self):
         c = arange(-2,2,.1)
@@ -2000,7 +2000,7 @@
         x = 0.0
         assert_equal(sinc(x),1.0)
 
-class test_sindg(ScipyTestCase):
+class test_sindg(NumpyTestCase):
 
     def check_sindg(self):
         sn = sindg(90)
@@ -2014,13 +2014,13 @@
         snmrl1 = sin(pi/4.0)
         assert_almost_equal(snm1,snmrl1,8)
 
-class test_sph_harm(ScipyTestCase):
+class test_sph_harm(NumpyTestCase):
 
     def check_sph_harm(self):
         pass
 
 
-class test_sph_in(ScipyTestCase):
+class test_sph_in(NumpyTestCase):
 
     def check_sph_in(self):
         i1n = sph_in(1,.2)
@@ -2030,14 +2030,14 @@
                                                 0.066933714568029540839]),12)
         assert_array_almost_equal(i1n[1],[inp0,inp1],12)
 
-class test_sph_inkn(ScipyTestCase):
+class test_sph_inkn(NumpyTestCase):
 
     def check_sph_inkn(self):
         spikn = r_[sph_in(1,.2)+sph_kn(1,.2)]
         inkn = r_[sph_inkn(1,.2)]
         assert_array_almost_equal(inkn,spikn,10)
 
-class test_sph_jn(ScipyTestCase):
+class test_sph_jn(NumpyTestCase):
 
     def check_sph_jn(self):
         s1 = sph_jn(2,.2)
@@ -2049,14 +2049,14 @@
                                       0.0026590560795273856680],12)
         assert_array_almost_equal(s1[1],[s10,s11,s12],12)
 
-class test_sph_jnyn(ScipyTestCase):
+class test_sph_jnyn(NumpyTestCase):
 
     def check_sph_jnyn(self):
         jnyn = r_[sph_jn(1,.2) + sph_yn(1,.2)]  # tuple addition
         jnyn1 = r_[sph_jnyn(1,.2)]
         assert_array_almost_equal(jnyn1,jnyn,9)
 
-class test_sph_kn(ScipyTestCase):
+class test_sph_kn(NumpyTestCase):
 
     def check_sph_kn(self):
         kn = sph_kn(2,.2)
@@ -2068,7 +2068,7 @@
                                          585.15696310385559829],12)
         assert_array_almost_equal(kn[1],[kn0,kn1,kn2],9)
 
-class test_sph_yn(ScipyTestCase):
+class test_sph_yn(NumpyTestCase):
 
     def check_sph_yn(self):
         sy1 = sph_yn(2,.2)[0][2]
@@ -2079,14 +2079,14 @@
         sy3 = sph_yn(1,.2)[1][1]
         assert_almost_equal(sy3,sphpy,4) #compare correct derivative val. (correct =-system val).
 
-class test_take(ScipyTestCase):
+class test_take(NumpyTestCase):
 
     def check_take(self):
         a = array([0,1,2,3,4,5,6,7,8])
         tka = take(a,(0,4,5,8),axis=0)
         assert_array_equal(tka,array([0,4,5,8]))
 
-class test_tandg(ScipyTestCase):
+class test_tandg(NumpyTestCase):
 
     def check_tandg(self):
         tn = tandg(30)
@@ -2114,21 +2114,21 @@
         assert_almost_equal(tandg(315), -1.0, 14)
         assert_almost_equal(tandg(-315), 1.0, 14)
 
-class test_y0(ScipyTestCase):
+class test_y0(NumpyTestCase):
 
     def check_y0(self):
         oz = y0(.1)
         ozr = yn(0,.1)
         assert_almost_equal(oz,ozr,8)
 
-class test_y1(ScipyTestCase):
+class test_y1(NumpyTestCase):
 
     def check_y1(self):
         o1 = y1(.1)
         o1r = yn(1,.1)
         assert_almost_equal(o1,o1r,8)
 
-class test_y0_zeros(ScipyTestCase):
+class test_y0_zeros(NumpyTestCase):
 
     def check_y0_zeros(self):
         yo,ypo = y0_zeros(2)
@@ -2139,37 +2139,37 @@
         assert_array_almost_equal(abs(yv(1,all)-allval),0.0,11)
 
 
-class test_y1_zeros(ScipyTestCase):
+class test_y1_zeros(NumpyTestCase):
 
     def check_y1_zeros(self):
         y1 = y1_zeros(1)
         assert_array_almost_equal(y1,(array([2.19714]),array([0.52079])),5)
 
-class test_y1p_zeros(ScipyTestCase):
+class test_y1p_zeros(NumpyTestCase):
 
     def check_y1p_zeros(self):
         y1p = y1p_zeros(1,complex=1)
         assert_array_almost_equal(y1p,(array([ 0.5768+0.904j]), array([-0.7635+0.5892j])),3)
 
-class test_yn_zeros(ScipyTestCase):
+class test_yn_zeros(NumpyTestCase):
 
     def check_yn_zeros(self):
         an = yn_zeros(4,2)
         assert_array_almost_equal(an,array([ 5.64515,  9.36162]),5)
 
-class test_ynp_zeros(ScipyTestCase):
+class test_ynp_zeros(NumpyTestCase):
 
     def check_ynp_zeros(self):
         ao = ynp_zeros(0,2)
         assert_array_almost_equal(ao,array([ 2.19714133, 5.42968104]),6)
 
-class test_yn(ScipyTestCase):
+class test_yn(NumpyTestCase):
 
     def check_yn(self):
         yn2n = yn(1,.2)
         assert_almost_equal(yn2n,-3.3238249881118471,8)
 
-class test_yv(ScipyTestCase):
+class test_yv(NumpyTestCase):
     def check_negv(self):
         assert_almost_equal(yv(-3,2), -yv(3,2), 14)
 
@@ -2177,7 +2177,7 @@
         yv2 = yv(1,.2)
         assert_almost_equal(yv2,-3.3238249881118471,8)
 
-class test_yve(ScipyTestCase):
+class test_yve(NumpyTestCase):
     def check_negv(self):
         assert_almost_equal(yve(-3,2), -yve(3,2), 14)
 
@@ -2188,14 +2188,14 @@
         yve22 = yve(1,.2+1j)
         assert_almost_equal(yve22,yve2r,8)
 
-class test_yvp(ScipyTestCase):
+class test_yvp(NumpyTestCase):
 
     def check_yvp(self):
         yvpr = (yv(1,.2) - yv(3,.2))/2.0
         yvp1 = yvp(2,.2)
         assert_array_almost_equal(yvp1,yvpr,10)
 
-class test_zeros(ScipyTestCase):
+class test_zeros(NumpyTestCase):
 
     def check_zeros(self):
         b = zeros((1,11))
@@ -2205,4 +2205,4 @@
                                     [0, 0]]))
 
 if __name__ == "__main__":
-    ScipyTest().run()
+    NumpyTest().run()

Modified: trunk/Lib/stats/__init__.py
===================================================================
--- trunk/Lib/stats/__init__.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/stats/__init__.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -11,5 +11,5 @@
 from kde import gaussian_kde
 
 __all__ = filter(lambda s:not s.startswith('_'),dir())
-from numpy.testing import ScipyTest
-test = ScipyTest().test
+from numpy.testing import NumpyTest
+test = NumpyTest().test

Modified: trunk/Lib/stats/tests/test_distributions.py
===================================================================
--- trunk/Lib/stats/tests/test_distributions.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/stats/tests/test_distributions.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -59,7 +59,7 @@
     else:
         args = str(tuple(1.0+rand(nargs)))
     exstr = r"""
-class test_%s(ScipyTestCase):
+class test_%s(NumpyTestCase):
     def check_cdf(self):
         D,pval = stats.kstest('%s','',args=%s,N=30)
         if (pval < %f):
@@ -71,7 +71,7 @@
     exec exstr
 
 
-class test_randint(ScipyTestCase):
+class test_randint(NumpyTestCase):
     def check_rvs(self):
         vals = stats.randint.rvs(5,30,size=100)
         assert(numpy.all(vals < 30) & numpy.all(vals >= 5))
@@ -97,7 +97,7 @@
         vals = stats.randint.cdf(x,5,30)
         assert_array_almost_equal(vals, out, decimal=12)
 
-class test_binom(ScipyTestCase):
+class test_binom(NumpyTestCase):
     def check_rvs(self):
         vals = stats.binom.rvs(10, 0.75, size=(2, 50))
         assert(numpy.all(vals >= 0) & numpy.all(vals <= 10))
@@ -108,7 +108,7 @@
         assert(val.dtype.char in typecodes['AllInteger'])
 
 
-class test_bernoulli(ScipyTestCase):
+class test_bernoulli(NumpyTestCase):
     def check_rvs(self):
         vals = stats.bernoulli.rvs(0.75, size=(2, 50))
         assert(numpy.all(vals >= 0) & numpy.all(vals <= 1))
@@ -118,7 +118,7 @@
         assert(isinstance(val, numpy.ndarray))
         assert(val.dtype.char in typecodes['AllInteger'])
 
-class test_nbinom(ScipyTestCase):
+class test_nbinom(NumpyTestCase):
     def check_rvs(self):
         vals = stats.nbinom.rvs(10, 0.75, size=(2, 50))
         assert(numpy.all(vals >= 0))
@@ -128,7 +128,7 @@
         assert(isinstance(val, numpy.ndarray))
         assert(val.dtype.char in typecodes['AllInteger'])
 
-class test_geom(ScipyTestCase):
+class test_geom(NumpyTestCase):
     def check_rvs(self):
         vals = stats.geom.rvs(0.75, size=(2, 50))
         assert(numpy.all(vals >= 0))
@@ -138,7 +138,7 @@
         assert(isinstance(val, numpy.ndarray))
         assert(val.dtype.char in typecodes['AllInteger'])
 
-class test_hypergeom(ScipyTestCase):
+class test_hypergeom(NumpyTestCase):
     def check_rvs(self):
         vals = stats.hypergeom.rvs(20, 10, 3, size=(2, 50))
         assert(numpy.all(vals >= 0) &
@@ -149,7 +149,7 @@
         assert(isinstance(val, numpy.ndarray))
         assert(val.dtype.char in typecodes['AllInteger'])
 
-class test_logser(ScipyTestCase):
+class test_logser(NumpyTestCase):
     def check_rvs(self):
         vals = stats.logser.rvs(0.75, size=(2, 50))
         assert(numpy.all(vals >= 1))
@@ -159,7 +159,7 @@
         assert(isinstance(val, numpy.ndarray))
         assert(val.dtype.char in typecodes['AllInteger'])
 
-class test_poisson(ScipyTestCase):
+class test_poisson(NumpyTestCase):
     def check_rvs(self):
         vals = stats.poisson.rvs(0.5, size=(2, 50))
         assert(numpy.all(vals >= 0))
@@ -169,7 +169,7 @@
         assert(isinstance(val, numpy.ndarray))
         assert(val.dtype.char in typecodes['AllInteger'])
 
-class test_zipf(ScipyTestCase):
+class test_zipf(NumpyTestCase):
     def check_rvs(self):
         vals = stats.zipf.rvs(1.5, size=(2, 50))
         assert(numpy.all(vals >= 1))
@@ -179,7 +179,7 @@
         assert(isinstance(val, numpy.ndarray))
         assert(val.dtype.char in typecodes['AllInteger'])
 
-class test_dlaplace(ScipyTestCase):
+class test_dlaplace(NumpyTestCase):
     def check_rvs(self):
         vals = stats.dlaplace.rvs(1.5 , size=(2, 50))
         assert(numpy.shape(vals) == (2, 50))
@@ -189,4 +189,4 @@
         assert(val.dtype.char in typecodes['AllInteger'])
 
 if __name__ == "__main__":
-    ScipyTest('stats.distributions').run()
+    NumpyTest('stats.distributions').run()

Modified: trunk/Lib/stats/tests/test_morestats.py
===================================================================
--- trunk/Lib/stats/tests/test_morestats.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/stats/tests/test_morestats.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -22,7 +22,7 @@
 g9 = [1.002, 0.998, 0.996, 0.995, 0.996, 1.004, 1.004, 0.998, 0.999, 0.991]
 g10= [0.991, 0.995, 0.984, 0.994, 0.997, 0.997, 0.991, 0.998, 1.004, 0.997]
 
-class test_shapiro(ScipyTestCase):
+class test_shapiro(NumpyTestCase):
     def check_basic(self):
         x1 = [0.11,7.87,4.61,10.14,7.95,3.14,0.46,
               4.43,0.21,4.75,0.71,1.52,3.24,
@@ -37,7 +37,7 @@
         assert_almost_equal(w,0.9590270,6)
         assert_almost_equal(pw,0.52460,3)
 
-class test_anderson(ScipyTestCase):
+class test_anderson(NumpyTestCase):
     def check_normal(self):
         x1 = scipy.stats.expon.rvs(size=50)
         x2 = scipy.stats.norm.rvs(size=50)
@@ -58,7 +58,7 @@
         A,crit,sig = scipy.stats.anderson(x2,'expon')
         assert_array_less(crit[:-1], A)
 
-class test_ansari(ScipyTestCase):
+class test_ansari(NumpyTestCase):
     def check_small(self):
         x = [1,2,3,3,4]
         y = [3,2,6,1,6,1,4,1]
@@ -80,7 +80,7 @@
         assert_almost_equal(W,10.0,11)
         assert_almost_equal(pval,0.533333333333333333,7)
 
-class test_bartlett(ScipyTestCase):
+class test_bartlett(NumpyTestCase):
     def check_data(self):
         args = []
         for k in range(1,11):
@@ -89,7 +89,7 @@
         assert_almost_equal(T,20.78587342806484,7)
         assert_almost_equal(pval,0.0136358632781,7)
 
-class test_levene(ScipyTestCase):
+class test_levene(NumpyTestCase):
     def check_data(self):
         args = []
         for k in range(1,11):
@@ -98,7 +98,7 @@
         assert_almost_equal(W,1.7059176930008939,7)
         assert_almost_equal(pval,0.0990829755522,7)
 
-class test_binom_test(ScipyTestCase):
+class test_binom_test(NumpyTestCase):
     def check_data(self):
         pval = stats.binom_test(100,250)
         assert_almost_equal(pval,0.0018833009350757682,11)
@@ -107,7 +107,7 @@
         pval = stats.binom_test([682,243],p=3.0/4)
         assert_almost_equal(pval,0.38249155957481695,11)
 
-class test_find_repeats(ScipyTestCase):
+class test_find_repeats(NumpyTestCase):
     def check_basic(self):
         a = [1,2,3,4,1,2,3,4,1,2,5]
         res,nums = scipy.stats.find_repeats(a)
@@ -115,4 +115,4 @@
         assert_array_equal(nums,[3,3,2,2])
 
 if __name__ == "__main__":
-    ScipyTest().run()
+    NumpyTest().run()

Modified: trunk/Lib/stats/tests/test_stats.py
===================================================================
--- trunk/Lib/stats/tests/test_stats.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/stats/tests/test_stats.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -48,7 +48,7 @@
 X8 = X7 * X
 X9 = X8 * X
 
-class test_round(ScipyTestCase):
+class test_round(NumpyTestCase):
     """ W.II. ROUND
 
         You should get the numbers 1 to 9.  Many language compilers,
@@ -98,7 +98,7 @@
         y=(int(round((3-numpy.exp(numpy.log(numpy.sqrt(2.0)*numpy.sqrt(2.0)))))))
         assert_equal(y,1)
 
-class test_basicstats(ScipyTestCase):
+class test_basicstats(NumpyTestCase):
     """ W.II.C. Compute basic statistic on all the variables.
 
         The means should be the fifth value of all the variables (case FIVE).
@@ -184,7 +184,7 @@
         y = scipy.stats.std(ROUND)
         assert_approx_equal(y, 2.738612788)
 
-class test_corr(ScipyTestCase):
+class test_corr(NumpyTestCase):
     """ W.II.D. Compute a correlation matrix on all the variables.
 
         All the correlations, except for ZERO and MISS, shoud be exactly 1.
@@ -371,7 +371,7 @@
 ### I need to figure out how to do this one.
 
 
-class test_regression(ScipyTestCase):
+class test_regression(NumpyTestCase):
     def check_linregressBIGX(self):
         """ W.II.F.  Regress BIG on X.
 
@@ -436,7 +436,7 @@
 ##################################################
 ### Test for sum
 
-class test_gmean(ScipyTestCase):
+class test_gmean(NumpyTestCase):
 
     def check_1D_list(self):
         a = (1,2,3,4)
@@ -475,7 +475,7 @@
         desired = array((v,v,v))
         assert_array_almost_equal(desired,actual,decimal=14)
 
-class test_hmean(ScipyTestCase):
+class test_hmean(NumpyTestCase):
     def check_1D_list(self):
         a = (1,2,3,4)
         actual= stats.hmean(a)
@@ -515,7 +515,7 @@
         assert_array_almost_equal(desired1,actual1,decimal=14)
 
 
-class test_mean(ScipyTestCase):
+class test_mean(NumpyTestCase):
     def check_basic(self):
         a = [3,4,5,10,-3,-5,6]
         af = [3.,4,5,10,-3,-5,-6]
@@ -552,7 +552,7 @@
             A += val
         assert_almost_equal(stats.mean(a,axis=None),A/(5*3.0*5))
 
-class test_median(ScipyTestCase):
+class test_median(NumpyTestCase):
     def check_basic(self):
         a1 = [3,4,5,10,-3,-5,6]
         a2 = [3,-6,-2,8,7,4,2,1]
@@ -561,7 +561,7 @@
         assert_equal(stats.median(a2),2.5)
         assert_equal(stats.median(a3),3.5)
 
-class test_percentile(ScipyTestCase):
+class test_percentile(NumpyTestCase):
     def setUp(self):
         self.a1 = [3,4,5,10,-3,-5,6]
         self.a2 = [3,-6,-2,8,7,4,2,1]
@@ -578,7 +578,7 @@
         assert_equal(stats.scoreatpercentile(x, 100), 3.5)
         assert_equal(stats.scoreatpercentile(x, 50), 1.75)
         
-class test_std(ScipyTestCase):
+class test_std(NumpyTestCase):
     def check_basic(self):
         a = [3,4,5,10,-3,-5,6]
         b = [3,4,5,10,-3,-5,-6]
@@ -597,21 +597,21 @@
         assert_array_almost_equal(stats.std(a,axis=1),b2,11)
 
 
-class test_cmedian(ScipyTestCase):
+class test_cmedian(NumpyTestCase):
     def check_basic(self):
         data = [1,2,3,1,5,3,6,4,3,2,4,3,5,2.0]
         assert_almost_equal(stats.cmedian(data,5),3.2916666666666665)
         assert_almost_equal(stats.cmedian(data,3),3.083333333333333)
         assert_almost_equal(stats.cmedian(data),3.0020020020020022)
 
-class test_median(ScipyTestCase):
+class test_median(NumpyTestCase):
     def check_basic(self):
         data1 = [1,3,5,2,3,1,19,-10,2,4.0]
         data2 = [3,5,1,10,23,-10,3,-2,6,8,15]
         assert_almost_equal(stats.median(data1),2.5)
         assert_almost_equal(stats.median(data2),5)
 
-class test_mode(ScipyTestCase):
+class test_mode(NumpyTestCase):
     def check_basic(self):
         data1 = [3,5,1,10,23,3,2,6,8,6,10,6]
         vals = stats.mode(data1)
@@ -619,7 +619,7 @@
         assert_almost_equal(vals[1][0],3)
 
 
-class test_variability(ScipyTestCase):
+class test_variability(NumpyTestCase):
     """  Comparison numbers are found using R v.1.5.1
          note that length(testcase) = 4
     """
@@ -699,7 +699,7 @@
 
 
 
-class test_moments(ScipyTestCase):
+class test_moments(NumpyTestCase):
     """
         Comparison numbers are found using R v.1.5.1
         note that length(testcase) = 4
@@ -759,7 +759,7 @@
         y = scipy.stats.kurtosis(self.testcase,0,0)
         assert_approx_equal(y,1.64)
 
-class test_threshold(ScipyTestCase):
+class test_threshold(NumpyTestCase):
     def check_basic(self):
         a = [-1,2,3,4,5,-1,-2]
         assert_array_equal(stats.threshold(a),a)
@@ -771,4 +771,4 @@
                            [0,2,3,4,0,0,0])
         
 if __name__ == "__main__":
-    ScipyTest().run()
+    NumpyTest().run()

Modified: trunk/Lib/weave/__init__.py
===================================================================
--- trunk/Lib/weave/__init__.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/weave/__init__.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -18,5 +18,5 @@
 except:
     pass
 
-from numpy.testing import ScipyTest
-test = ScipyTest().test
+from numpy.testing import NumpyTest
+test = NumpyTest().test

Modified: trunk/Lib/weave/tests/test_ast_tools.py
===================================================================
--- trunk/Lib/weave/tests/test_ast_tools.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/weave/tests/test_ast_tools.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -8,7 +8,7 @@
 from weave_test_utils import *
 restore_path()
 
-class test_harvest_variables(ScipyTestCase):
+class test_harvest_variables(NumpyTestCase):
     """ Not much testing going on here, but
         at least it is a flame test.
     """
@@ -28,4 +28,4 @@
         self.generic_test(expr,desired)
 
 if __name__ == "__main__":
-    ScipyTest().run()
+    NumpyTest().run()

Modified: trunk/Lib/weave/tests/test_blitz_tools.py
===================================================================
--- trunk/Lib/weave/tests/test_blitz_tools.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/weave/tests/test_blitz_tools.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -14,7 +14,7 @@
 restore_path()
 
 
-class test_ast_to_blitz_expr(ScipyTestCase):
+class test_ast_to_blitz_expr(NumpyTestCase):
 
     def generic_test(self,expr,desired):
         import parser
@@ -57,7 +57,7 @@
                   '-hy(_all,blitz::Range(1,_end),blitz::Range(_beg,Nhy(2)-1-1)));'
         self.generic_test(expr,desired)
 
-class test_blitz(ScipyTestCase):
+class test_blitz(NumpyTestCase):
     """* These are long running tests...
 
          I'd like to benchmark these things somehow.
@@ -174,4 +174,4 @@
         self.generic_2d(expr,complex128)
 
 if __name__ == "__main__":
-    ScipyTest().run()
+    NumpyTest().run()

Modified: trunk/Lib/weave/tests/test_build_tools.py
===================================================================
--- trunk/Lib/weave/tests/test_build_tools.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/weave/tests/test_build_tools.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -12,7 +12,7 @@
 def is_writable(val):
     return os.access(val,os.W_OK)
 
-class test_configure_build_dir(ScipyTestCase):
+class test_configure_build_dir(NumpyTestCase):
     def check_default(self):
         " default behavior is to return current directory "
         d = build_tools.configure_build_dir()
@@ -46,7 +46,7 @@
         assert(d == tempfile.gettempdir())
         assert(is_writable(d))
 
-class test_configure_sys_argv(ScipyTestCase):
+class test_configure_sys_argv(NumpyTestCase):
     def check_simple(self):
         build_dir = 'build_dir'
         temp_dir = 'temp_dir'
@@ -63,4 +63,4 @@
         assert(pre_argv == sys.argv[:])
 
 if __name__ == "__main__":
-    ScipyTest().run()
+    NumpyTest().run()

Modified: trunk/Lib/weave/tests/test_c_spec.py
===================================================================
--- trunk/Lib/weave/tests/test_c_spec.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/weave/tests/test_c_spec.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -48,7 +48,7 @@
 # Scalar conversion test classes
 #   int, float, complex
 #----------------------------------------------------------------------------
-class test_int_converter(ScipyTestCase):
+class test_int_converter(NumpyTestCase):
     compiler = ''
     def check_type_match_string(self,level=5):
         s = c_spec.int_converter()
@@ -103,7 +103,7 @@
 
         assert( c == 3)
 
-class test_float_converter(ScipyTestCase):
+class test_float_converter(NumpyTestCase):
     compiler = ''
     def check_type_match_string(self,level=5):
         s = c_spec.float_converter()
@@ -158,7 +158,7 @@
         c = test(b)
         assert( c == 3.)
 
-class test_complex_converter(ScipyTestCase):
+class test_complex_converter(NumpyTestCase):
     compiler = ''
     def check_type_match_string(self,level=5):
         s = c_spec.complex_converter()
@@ -216,7 +216,7 @@
 # File conversion tests
 #----------------------------------------------------------------------------
 
-class test_file_converter(ScipyTestCase):
+class test_file_converter(NumpyTestCase):
     compiler = ''
     def check_py_to_file(self,level=5):
         import tempfile
@@ -250,14 +250,14 @@
 # Instance conversion tests
 #----------------------------------------------------------------------------
 
-class test_instance_converter(ScipyTestCase):
+class test_instance_converter(NumpyTestCase):
     pass
 
 #----------------------------------------------------------------------------
 # Callable object conversion tests
 #----------------------------------------------------------------------------
 
-class test_callable_converter(ScipyTestCase):
+class test_callable_converter(NumpyTestCase):
     compiler=''
     def check_call_function(self,level=5):
         import string
@@ -277,7 +277,7 @@
         desired = func(search_str,sub_str)
         assert(desired == actual)
 
-class test_sequence_converter(ScipyTestCase):
+class test_sequence_converter(NumpyTestCase):
     compiler = ''
     def check_convert_to_dict(self,level=5):
         d = {}
@@ -292,7 +292,7 @@
         t = ()
         inline_tools.inline("",['t'],compiler=self.compiler,force=1)
 
-class test_string_converter(ScipyTestCase):
+class test_string_converter(NumpyTestCase):
     compiler = ''
     def check_type_match_string(self,level=5):
         s = c_spec.string_converter()
@@ -347,7 +347,7 @@
         c = test(b)
         assert( c == 'hello')
 
-class test_list_converter(ScipyTestCase):
+class test_list_converter(NumpyTestCase):
     compiler = ''
     def check_type_match_bad(self,level=5):
         s = c_spec.list_converter()
@@ -458,7 +458,7 @@
         print 'python:', t2 - t1
         assert( sum1 == sum2 and sum1 == sum3)
 
-class test_tuple_converter(ScipyTestCase):
+class test_tuple_converter(NumpyTestCase):
     compiler = ''
     def check_type_match_bad(self,level=5):
         s = c_spec.tuple_converter()
@@ -511,7 +511,7 @@
         assert( c == ('hello',None))
 
 
-class test_dict_converter(ScipyTestCase):
+class test_dict_converter(NumpyTestCase):
     def check_type_match_bad(self,level=5):
         s = c_spec.dict_converter()
         objs = [[],(),'',1,1.,1+1j]
@@ -674,4 +674,4 @@
         if _n[:9]=='test_gcc_': exec 'del '+_n
 
 if __name__ == "__main__":
-    ScipyTest('weave.c_spec').run()
+    NumpyTest('weave.c_spec').run()

Modified: trunk/Lib/weave/tests/test_catalog.py
===================================================================
--- trunk/Lib/weave/tests/test_catalog.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/weave/tests/test_catalog.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -11,7 +11,7 @@
 restore_path()
 
 
-class test_default_dir(ScipyTestCase):
+class test_default_dir(NumpyTestCase):
     def check_is_writable(self):
         path = catalog.default_dir()
         name = os.path.join(path,'dummy_catalog')
@@ -22,10 +22,10 @@
             test_file.close()
             os.remove(name)
 
-class test_os_dependent_catalog_name(ScipyTestCase):
+class test_os_dependent_catalog_name(NumpyTestCase):
     pass
 
-class test_catalog_path(ScipyTestCase):
+class test_catalog_path(NumpyTestCase):
     def check_default(self):
         in_path = catalog.default_dir()
         path = catalog.catalog_path(in_path)
@@ -64,7 +64,7 @@
         path = catalog.catalog_path(in_path)
         assert (path is None)
 
-class test_get_catalog(ScipyTestCase):
+class test_get_catalog(NumpyTestCase):
     """ This only tests whether new catalogs are created correctly.
         And whether non-existent return None correctly with read mode.
         Putting catalogs in the right place is all tested with
@@ -98,7 +98,7 @@
         self.remove_dir(pardir)
         assert(cat is not None)
 
-class test_catalog(ScipyTestCase):
+class test_catalog(NumpyTestCase):
 
     def clear_environ(self):
         if os.environ.has_key('PYTHONCOMPILED'):
@@ -331,4 +331,4 @@
 
 
 if __name__ == '__main__':
-    ScipyTest('weave.catalog').run()
+    NumpyTest('weave.catalog').run()

Modified: trunk/Lib/weave/tests/test_ext_tools.py
===================================================================
--- trunk/Lib/weave/tests/test_ext_tools.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/weave/tests/test_ext_tools.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -17,7 +17,7 @@
 build_dir = empty_temp_dir()
 print 'building extensions here:', build_dir
 
-class test_ext_module(ScipyTestCase):
+class test_ext_module(NumpyTestCase):
     #should really do some testing of where modules end up
     def check_simple(self,level=5):
         """ Simplest possible module """
@@ -94,7 +94,7 @@
         c,d = ext_return_tuple.test(a)
         assert(c==a and d == a+1)
 
-class test_ext_function(ScipyTestCase):
+class test_ext_function(NumpyTestCase):
     #should really do some testing of where modules end up
     def check_simple(self,level=5):
         """ Simplest possible function """
@@ -107,7 +107,7 @@
         import simple_ext_function
         simple_ext_function.test()
 
-class test_assign_variable_types(ScipyTestCase):
+class test_assign_variable_types(NumpyTestCase):
     def check_assign_variable_types(self):
         try:
             from numpy.numerix import arange, Float32, Float64
@@ -135,4 +135,4 @@
         print_assert_equal(expr,actual,desired)
 
 if __name__ == "__main__":
-    ScipyTest().run()
+    NumpyTest().run()

Modified: trunk/Lib/weave/tests/test_inline_tools.py
===================================================================
--- trunk/Lib/weave/tests/test_inline_tools.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/weave/tests/test_inline_tools.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -9,7 +9,7 @@
 from test_scxx import *
 restore_path()
 
-class test_inline(ScipyTestCase):
+class test_inline(NumpyTestCase):
     """ These are long running tests...
 
          I'd like to benchmark these things somehow.
@@ -43,4 +43,4 @@
             pass
 
 if __name__ == "__main__":
-    ScipyTest().run()
+    NumpyTest().run()

Modified: trunk/Lib/weave/tests/test_scxx.py
===================================================================
--- trunk/Lib/weave/tests/test_scxx.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/weave/tests/test_scxx.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -12,4 +12,4 @@
 restore_path()
 
 if __name__ == "__main__":
-    ScipyTest().run()
+    NumpyTest().run()

Modified: trunk/Lib/weave/tests/test_scxx_dict.py
===================================================================
--- trunk/Lib/weave/tests/test_scxx_dict.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/weave/tests/test_scxx_dict.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -9,7 +9,7 @@
 restore_path()
 
 
-class test_dict_construct(ScipyTestCase):
+class test_dict_construct(NumpyTestCase):
     #------------------------------------------------------------------------
     # Check that construction from basic types is allowed and have correct
     # reference counts
@@ -25,7 +25,7 @@
         assert res == {}
 
 
-class test_dict_has_key(ScipyTestCase):
+class test_dict_has_key(NumpyTestCase):
     def check_obj(self,level=5):
         class foo:
             pass
@@ -89,7 +89,7 @@
         res = inline_tools.inline(code,['a'])
         assert not res
 
-class test_dict_get_item_op(ScipyTestCase):
+class test_dict_get_item_op(NumpyTestCase):
 
     def generic_get(self,code,args=['a']):
         a = {}
@@ -132,7 +132,7 @@
         except KeyError:
             pass
 
-class test_dict_set_operator(ScipyTestCase):
+class test_dict_set_operator(NumpyTestCase):
     def generic_new(self,key,val):
         # test that value is set correctly and that reference counts
         # on dict, key, and val are being handled correctly.
@@ -199,7 +199,7 @@
         key,val = foo(),12345
         self.generic_overwrite(key,val)
 
-class test_dict_del(ScipyTestCase):
+class test_dict_del(NumpyTestCase):
     def generic(self,key):
         # test that value is set correctly and that reference counts
         # on dict, key, are being handled correctly. after deletion,
@@ -233,7 +233,7 @@
         key = foo()
         self.generic(key)
 
-class test_dict_others(ScipyTestCase):
+class test_dict_others(NumpyTestCase):
     def check_clear(self,level=5):
         a = {}
         a["hello"] = 1
@@ -262,4 +262,4 @@
         assert a == b
 
 if __name__ == "__main__":
-    ScipyTest().run()
+    NumpyTest().run()

Modified: trunk/Lib/weave/tests/test_scxx_object.py
===================================================================
--- trunk/Lib/weave/tests/test_scxx_object.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/weave/tests/test_scxx_object.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -8,7 +8,7 @@
 from weave import inline_tools
 restore_path()
 
-class test_object_construct(ScipyTestCase):
+class test_object_construct(NumpyTestCase):
     #------------------------------------------------------------------------
     # Check that construction from basic types is allowed and have correct
     # reference counts
@@ -66,7 +66,7 @@
         assert sys.getrefcount(res) == 2
         assert res == "hello"
 
-class test_object_print(ScipyTestCase):
+class test_object_print(NumpyTestCase):
     #------------------------------------------------------------------------
     # Check the object print protocol.
     #------------------------------------------------------------------------
@@ -101,7 +101,7 @@
 ##            pass
 
 
-class test_object_cast(ScipyTestCase):
+class test_object_cast(NumpyTestCase):
     def check_int_cast(self,level=5):
         code = """
                py::object val = 1;
@@ -147,7 +147,7 @@
     def __str__(self):
         return "b"
 
-class test_object_hasattr(ScipyTestCase):
+class test_object_hasattr(NumpyTestCase):
     def check_string(self,level=5):
         a = foo()
         a.b = 12345
@@ -203,7 +203,7 @@
         res = inline_tools.inline(code,['a'])
         assert res
 
-class test_object_attr(ScipyTestCase):
+class test_object_attr(NumpyTestCase):
 
     def generic_attr(self,code,args=['a']):
         a = foo()
@@ -261,7 +261,7 @@
         assert res == "bar results"
         assert first == second
 
-class test_object_set_attr(ScipyTestCase):
+class test_object_set_attr(NumpyTestCase):
 
     def generic_existing(self, code, desired):
         args = ['a']
@@ -325,7 +325,7 @@
                """
         self.generic_existing(code,"hello")
 
-class test_object_del(ScipyTestCase):
+class test_object_del(NumpyTestCase):
     def generic(self, code):
         args = ['a']
         a = foo()
@@ -348,7 +348,7 @@
                """
         self.generic(code)
 
-class test_object_cmp(ScipyTestCase):
+class test_object_cmp(NumpyTestCase):
     def check_equal(self,level=5):
         a,b = 1,1
         res = inline_tools.inline('return_val = (a == b);',['a','b'])
@@ -411,7 +411,7 @@
         res = inline_tools.inline(code,['a'])
         assert res == (a == "hello")
 
-class test_object_repr(ScipyTestCase):
+class test_object_repr(NumpyTestCase):
     def check_repr(self,level=5):
         class foo:
             def __str__(self):
@@ -427,7 +427,7 @@
         assert first == second
         assert res == "repr return"
 
-class test_object_str(ScipyTestCase):
+class test_object_str(NumpyTestCase):
     def check_str(self,level=5):
         class foo:
             def __str__(self):
@@ -444,7 +444,7 @@
         print res
         assert res == "str return"
 
-class test_object_unicode(ScipyTestCase):
+class test_object_unicode(NumpyTestCase):
     # This ain't going to win awards for test of the year...
     def check_unicode(self,level=5):
         class foo:
@@ -461,7 +461,7 @@
         assert first == second
         assert res == "unicode"
 
-class test_object_is_callable(ScipyTestCase):
+class test_object_is_callable(NumpyTestCase):
     def check_true(self,level=5):
         class foo:
             def __call__(self):
@@ -476,7 +476,7 @@
         res = inline_tools.inline('return_val = a.is_callable();',['a'])
         assert not res
 
-class test_object_call(ScipyTestCase):
+class test_object_call(NumpyTestCase):
     def check_noargs(self,level=5):
         def foo():
             return (1,2,3)
@@ -532,7 +532,7 @@
         # first should == second, but the weird refcount error
         assert second == third
 
-class test_object_mcall(ScipyTestCase):
+class test_object_mcall(NumpyTestCase):
     def check_noargs(self,level=5):
         a = foo()
         res = inline_tools.inline('return_val = a.mcall("bar");',['a'])
@@ -626,7 +626,7 @@
         # first should == second, but the weird refcount error
         assert second == third
 
-class test_object_hash(ScipyTestCase):
+class test_object_hash(NumpyTestCase):
     def check_hash(self,level=5):
         class foo:
             def __hash__(self):
@@ -636,7 +636,7 @@
         print 'hash:', res
         assert res == 123
 
-class test_object_is_true(ScipyTestCase):
+class test_object_is_true(NumpyTestCase):
     def check_true(self,level=5):
         class foo:
             pass
@@ -648,7 +648,7 @@
         res = inline_tools.inline('return_val = a.is_true();',['a'])
         assert res == 0
 
-class test_object_is_true(ScipyTestCase):
+class test_object_is_true(NumpyTestCase):
     def check_false(self,level=5):
         class foo:
             pass
@@ -660,7 +660,7 @@
         res = inline_tools.inline('return_val = a.not();',['a'])
         assert res == 1
 
-class test_object_type(ScipyTestCase):
+class test_object_type(NumpyTestCase):
     def check_type(self,level=5):
         class foo:
             pass
@@ -668,7 +668,7 @@
         res = inline_tools.inline('return_val = a.type();',['a'])
         assert res == type(a)
 
-class test_object_size(ScipyTestCase):
+class test_object_size(NumpyTestCase):
     def check_size(self,level=5):
         class foo:
             def __len__(self):
@@ -692,7 +692,7 @@
         assert res == len(a)
 
 from UserList import UserList
-class test_object_set_item_op_index(ScipyTestCase):
+class test_object_set_item_op_index(NumpyTestCase):
     def check_list_refcount(self,level=5):
         a = UserList([1,2,3])
         # temporary refcount fix until I understand why it incs by one.
@@ -727,7 +727,7 @@
         assert a[1] == 1+1j
 
 from UserDict import UserDict
-class test_object_set_item_op_key(ScipyTestCase):
+class test_object_set_item_op_key(NumpyTestCase):
     def check_key_refcount(self,level=5):
         a = UserDict()
         code =  """
@@ -818,4 +818,4 @@
         assert a['first'] == a['second']
 
 if __name__ == "__main__":
-    ScipyTest().run()
+    NumpyTest().run()

Modified: trunk/Lib/weave/tests/test_scxx_sequence.py
===================================================================
--- trunk/Lib/weave/tests/test_scxx_sequence.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/weave/tests/test_scxx_sequence.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -20,7 +20,7 @@
 
 from UserList import UserList
 
-class _test_sequence_base(ScipyTestCase):
+class _test_sequence_base(NumpyTestCase):
     seq_type = None
 
     def check_conversion(self,level=5):
@@ -435,4 +435,4 @@
         assert b == desired
 
 if __name__ == "__main__":
-    ScipyTest().run()
+    NumpyTest().run()

Modified: trunk/Lib/weave/tests/test_size_check.py
===================================================================
--- trunk/Lib/weave/tests/test_size_check.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/weave/tests/test_size_check.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -11,7 +11,7 @@
 empty = array(())
 
 
-class test_make_same_length(ScipyTestCase):
+class test_make_same_length(NumpyTestCase):
 
     def generic_test(self,x,y,desired):
         actual = size_check.make_same_length(x,y)
@@ -39,7 +39,7 @@
         desired = array((1,2,3)),array((1,1,2))
         self.generic_test(x,y,desired)
 
-class test_binary_op_size(ScipyTestCase):
+class test_binary_op_size(NumpyTestCase):
     def generic_test(self,x,y,desired):
         actual = size_check.binary_op_size(x,y)
         desired = desired
@@ -115,7 +115,7 @@
     def desired_type(self,val):
         return size_check.dummy_array(array(val),1)
 
-class test_dummy_array_indexing(ScipyTestCase):
+class test_dummy_array_indexing(NumpyTestCase):
     def generic_test(self,ary,expr,desired):
         a = size_check.dummy_array(ary)
         actual = eval(expr).shape
@@ -269,7 +269,7 @@
             except IndexError:
                 pass
 
-class test_reduction(ScipyTestCase):
+class test_reduction(NumpyTestCase):
     def check_1d_0(self):
         a = ones((5,))
         actual = size_check.reduction(a,0)
@@ -303,7 +303,7 @@
         except ValueError:
             pass
 
-class test_expressions(ScipyTestCase):
+class test_expressions(NumpyTestCase):
     def generic_test(self,expr,desired,**kw):
         import parser
         ast_list = parser.expr(expr).tolist()
@@ -372,4 +372,4 @@
 
 
 if __name__ == "__main__":
-    ScipyTest('weave.size_check').run()
+    NumpyTest('weave.size_check').run()

Modified: trunk/Lib/weave/tests/test_slice_handler.py
===================================================================
--- trunk/Lib/weave/tests/test_slice_handler.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/weave/tests/test_slice_handler.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -22,7 +22,7 @@
         pprint.pprint(desired,msg)
         raise AssertionError, msg.getvalue()
 
-class test_build_slice_atom(ScipyTestCase):
+class test_build_slice_atom(NumpyTestCase):
     def generic_test(self,slice_vars,desired):
         pos = slice_vars['pos']
         ast_list = slice_handler.build_slice_atom(slice_vars,pos)
@@ -34,7 +34,7 @@
         desired = 'slice(1,2-1)'
         self.generic_test(slice_vars,desired)
 
-class test_slice(ScipyTestCase):
+class test_slice(NumpyTestCase):
 
     def generic_test(self,suite_string,desired):
         import parser
@@ -135,7 +135,7 @@
     out = string.replace(out,"\n","")
     return out
 
-class test_transform_slices(ScipyTestCase):
+class test_transform_slices(NumpyTestCase):
     def generic_test(self,suite_string,desired):
         import parser
         ast_list = parser.suite(suite_string).tolist()
@@ -164,4 +164,4 @@
 
 
 if __name__ == "__main__":
-    ScipyTest('weave.slice_handler').run()
+    NumpyTest('weave.slice_handler').run()

Modified: trunk/Lib/weave/tests/test_standard_array_spec.py
===================================================================
--- trunk/Lib/weave/tests/test_standard_array_spec.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/weave/tests/test_standard_array_spec.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -28,7 +28,7 @@
         pprint.pprint(desired,msg)
         raise AssertionError, msg.getvalue()
 
-class test_array_converter(ScipyTestCase):
+class test_array_converter(NumpyTestCase):
     def check_type_match_string(self):
         s = standard_array_spec.array_converter()
         assert( not s.type_match('string') )
@@ -40,4 +40,4 @@
         assert(s.type_match(arange(4)))
 
 if __name__ == "__main__":
-    ScipyTest().run()
+    NumpyTest().run()

Modified: trunk/Lib/weave/tests/test_wx_spec.py
===================================================================
--- trunk/Lib/weave/tests/test_wx_spec.py	2007-01-11 01:03:26 UTC (rev 2528)
+++ trunk/Lib/weave/tests/test_wx_spec.py	2007-01-11 04:22:41 UTC (rev 2529)
@@ -16,7 +16,7 @@
 import wxPython
 import wxPython.wx
 
-class test_wx_converter(ScipyTestCase):
+class test_wx_converter(NumpyTestCase):
     def check_type_match_string(self,level=5):
         s = wx_spec.wx_converter()
         assert(not s.type_match('string') )
@@ -91,4 +91,4 @@
         assert( c == 'hello')
 
 if __name__ == "__main__":
-    ScipyTest().run()
+    NumpyTest().run()



More information about the Scipy-svn mailing list