[Numpy-svn] r4151 - in trunk/numpy: core/tests distutils/tests distutils/tests/f2py_ext/tests distutils/tests/f2py_f90_ext/tests distutils/tests/gen_ext/tests distutils/tests/pyrex_ext/tests distutils/tests/swig_ext/tests f2py/lib/parser f2py/lib/tests fft/tests lib/tests random/tests tests

numpy-svn@scip... numpy-svn@scip...
Tue Oct 2 02:56:48 CDT 2007


Author: stefan
Date: 2007-10-02 02:54:11 -0500 (Tue, 02 Oct 2007)
New Revision: 4151

Modified:
   trunk/numpy/core/tests/test_defmatrix.py
   trunk/numpy/core/tests/test_errstate.py
   trunk/numpy/core/tests/test_ma.py
   trunk/numpy/core/tests/test_multiarray.py
   trunk/numpy/core/tests/test_numeric.py
   trunk/numpy/core/tests/test_numerictypes.py
   trunk/numpy/core/tests/test_records.py
   trunk/numpy/core/tests/test_regression.py
   trunk/numpy/core/tests/test_scalarmath.py
   trunk/numpy/core/tests/test_umath.py
   trunk/numpy/distutils/tests/f2py_ext/tests/test_fib2.py
   trunk/numpy/distutils/tests/f2py_f90_ext/tests/test_foo.py
   trunk/numpy/distutils/tests/gen_ext/tests/test_fib3.py
   trunk/numpy/distutils/tests/pyrex_ext/tests/test_primes.py
   trunk/numpy/distutils/tests/swig_ext/tests/test_example.py
   trunk/numpy/distutils/tests/swig_ext/tests/test_example2.py
   trunk/numpy/distutils/tests/test_fcompiler_gnu.py
   trunk/numpy/distutils/tests/test_misc_util.py
   trunk/numpy/f2py/lib/parser/test_Fortran2003.py
   trunk/numpy/f2py/lib/parser/test_parser.py
   trunk/numpy/f2py/lib/tests/test_derived_scalar.py
   trunk/numpy/f2py/lib/tests/test_module_module.py
   trunk/numpy/f2py/lib/tests/test_module_scalar.py
   trunk/numpy/f2py/lib/tests/test_scalar_function_in.py
   trunk/numpy/f2py/lib/tests/test_scalar_in_out.py
   trunk/numpy/fft/tests/test_fftpack.py
   trunk/numpy/fft/tests/test_helper.py
   trunk/numpy/lib/tests/test_arraysetops.py
   trunk/numpy/lib/tests/test_function_base.py
   trunk/numpy/lib/tests/test_getlimits.py
   trunk/numpy/lib/tests/test_index_tricks.py
   trunk/numpy/lib/tests/test_polynomial.py
   trunk/numpy/lib/tests/test_shape_base.py
   trunk/numpy/lib/tests/test_twodim_base.py
   trunk/numpy/lib/tests/test_type_check.py
   trunk/numpy/lib/tests/test_ufunclike.py
   trunk/numpy/random/tests/test_random.py
   trunk/numpy/tests/test_ctypeslib.py
Log:
Rename test classes to CapWords.


Modified: trunk/numpy/core/tests/test_defmatrix.py
===================================================================
--- trunk/numpy/core/tests/test_defmatrix.py	2007-10-02 07:32:06 UTC (rev 4150)
+++ trunk/numpy/core/tests/test_defmatrix.py	2007-10-02 07:54:11 UTC (rev 4151)
@@ -4,7 +4,7 @@
 from numpy.core import *
 restore_path()
 
-class test_ctor(NumpyTestCase):
+class TestCtor(NumpyTestCase):
     def check_basic(self):
         A = array([[1,2],[3,4]])
         mA = matrix(A)
@@ -23,7 +23,7 @@
         mvec = matrix(vec)
         assert mvec.shape == (1,5)
 
-class test_properties(NumpyTestCase):
+class TestProperties(NumpyTestCase):
     def check_sum(self):
         """Test whether matrix.sum(axis=1) preserves orientation.
         Fails in NumPy <= 0.9.6.2127.
@@ -91,7 +91,7 @@
         assert A.sum() == matrix(2)
         assert A.mean() == matrix(0.5)
 
-class test_casting(NumpyTestCase):
+class TestCasting(NumpyTestCase):
     def check_basic(self):
         A = arange(100).reshape(10,10)
         mA = matrix(A)
@@ -109,7 +109,7 @@
         assert mC.dtype.type == complex128
         assert all(mA != mB)
 
-class test_algebra(NumpyTestCase):
+class TestAlgebra(NumpyTestCase):
     def check_basic(self):
         import numpy.linalg as linalg
 
@@ -132,7 +132,7 @@
         assert allclose((mA + mA).A, (A + A))
         assert allclose((3*mA).A, (3*A))
 
-class test_matrix_return(NumpyTestCase):
+class TestMatrixReturn(NumpyTestCase):
     def check_instance_methods(self):
         a = matrix([1.0], dtype='f8')
         methodargs = {
@@ -171,7 +171,7 @@
         assert type(c) is matrix
         assert type(d) is matrix
 
-class test_indexing(NumpyTestCase):
+class TestIndexing(NumpyTestCase):
     def check_basic(self):
         x = asmatrix(zeros((3,2),float))
         y = zeros((3,1),float)

Modified: trunk/numpy/core/tests/test_errstate.py
===================================================================
--- trunk/numpy/core/tests/test_errstate.py	2007-10-02 07:32:06 UTC (rev 4150)
+++ trunk/numpy/core/tests/test_errstate.py	2007-10-02 07:54:11 UTC (rev 4151)
@@ -14,7 +14,7 @@
 
 
 
-class test_errstate(NumpyTestCase):
+class TestErrstate(NumpyTestCase):
 
 
     def test_invalid(self):

Modified: trunk/numpy/core/tests/test_ma.py
===================================================================
--- trunk/numpy/core/tests/test_ma.py	2007-10-02 07:32:06 UTC (rev 4150)
+++ trunk/numpy/core/tests/test_ma.py	2007-10-02 07:54:11 UTC (rev 4151)
@@ -13,7 +13,7 @@
 %s"""% (msg, str(v), str(w))
     return result
 
-class test_ma(NumpyTestCase):
+class TestMa(NumpyTestCase):
     def __init__(self, *args, **kwds):
         NumpyTestCase.__init__(self, *args, **kwds)
         self.setUp()
@@ -647,7 +647,7 @@
         self.failUnlessEqual(b[0].shape, ())
         self.failUnlessEqual(b[1].shape, ())
 
-class test_ufuncs(NumpyTestCase):
+class TestUfuncs(NumpyTestCase):
     def setUp(self):
         self.d = (array([1.0, 0, -1, pi/2]*2, mask=[0,1]+[0]*6),
                   array([1.0, 0, -1, pi/2]*2, mask=[1,0]+[0]*6),)
@@ -714,7 +714,7 @@
             self.failUnless(eq(nonzero(x), [0]))
 
 
-class test_array_methods(NumpyTestCase):
+class TestArrayMethods(NumpyTestCase):
 
     def setUp(self):
         x = numpy.array([ 8.375,  7.545,  8.828,  8.5  ,  1.757,  5.928,

Modified: trunk/numpy/core/tests/test_multiarray.py
===================================================================
--- trunk/numpy/core/tests/test_multiarray.py	2007-10-02 07:32:06 UTC (rev 4150)
+++ trunk/numpy/core/tests/test_multiarray.py	2007-10-02 07:54:11 UTC (rev 4151)
@@ -3,7 +3,7 @@
 from numpy import random
 import numpy as N
 
-class test_flags(NumpyTestCase):
+class TestFlags(NumpyTestCase):
     def setUp(self):
         self.a = arange(10)
 
@@ -27,7 +27,7 @@
         assert_equal(self.a.flags.updateifcopy, False)
 
 
-class test_attributes(NumpyTestCase):
+class TestAttributes(NumpyTestCase):
     def setUp(self):
         self.one = arange(10)
         self.two = arange(20).reshape(4,5)
@@ -104,14 +104,14 @@
         x.fill(x[0])
         assert_equal(x['f1'][1], x['f1'][0])
 
-class test_dtypedescr(NumpyTestCase):
+class TestDtypedescr(NumpyTestCase):
     def check_construction(self):
         d1 = dtype('i4')
         assert_equal(d1, dtype(int32))
         d2 = dtype('f8')
         assert_equal(d2, dtype(float64))
 
-class test_fromstring(NumpyTestCase):
+class TestFromstring(NumpyTestCase):
     def check_binary(self):
         a = fromstring('\x00\x00\x80?\x00\x00\x00@\x00\x00@@\x00\x00\x80@',dtype='<f4')
         assert_array_equal(a, array([1,2,3,4]))
@@ -140,7 +140,7 @@
         assert_array_equal(a, [1.,2.,3.,4.])
         assert_array_equal(a,b)
 
-class test_zero_rank(NumpyTestCase):
+class TestZeroRank(NumpyTestCase):
     def setUp(self):
         self.d = array(0), array('x', object)
 
@@ -216,14 +216,14 @@
         x = array(2)
         self.failUnlessRaises(ValueError, add, x, [1], x)
 
-class test_creation(NumpyTestCase):
+class TestCreation(NumpyTestCase):
     def check_from_attribute(self):
         class x(object):
             def __array__(self, dtype=None):
                 pass
         self.failUnlessRaises(ValueError, array, x())
 
-class test_bool(NumpyTestCase):
+class TestBool(NumpyTestCase):
     def check_test_interning(self):
         a0 = bool_(0)
         b0 = bool_(False)
@@ -235,7 +235,7 @@
         self.failUnless(array(True)[()] is a1)
 
 
-class test_methods(NumpyTestCase):
+class TestMethods(NumpyTestCase):
     def check_test_round(self):
         assert_equal(array([1.2,1.5]).round(), [1,2])
         assert_equal(array(1.5).round(), 2)
@@ -249,13 +249,13 @@
         self.failUnlessRaises(ValueError, lambda: a.transpose(0,0))
         self.failUnlessRaises(ValueError, lambda: a.transpose(0,1,2))
 
-class test_subscripting(NumpyTestCase):
+class TestSubscripting(NumpyTestCase):
     def check_test_zero_rank(self):
         x = array([1,2,3])
         self.failUnless(isinstance(x[0], int))
         self.failUnless(type(x[0, ...]) is ndarray)
 
-class test_pickling(NumpyTestCase):
+class TestPickling(NumpyTestCase):
     def check_both(self):
         import pickle
         carray = array([[2,9],[7,0],[3,8]])
@@ -302,7 +302,7 @@
         p = loads(s)
         assert_equal(a, p)
 
-class test_fancy_indexing(NumpyTestCase):
+class TestFancyIndexing(NumpyTestCase):
     def check_list(self):
         x = ones((1,1))
         x[:,[0]] = 2.0
@@ -320,7 +320,7 @@
         x[:,:,(0,)] = 2.0
         assert_array_equal(x, array([[[2.0]]]))
 
-class test_string_compare(NumpyTestCase):
+class TestStringCompare(NumpyTestCase):
     def check_string(self):
         g1 = array(["This","is","example"])
         g2 = array(["This","was","example"])
@@ -353,7 +353,7 @@
         assert_array_equal(g1 > g2,  [g1[i] > g2[i] for i in [0,1,2]])
 
 
-class test_argmax(NumpyTestCase):
+class TestArgmax(NumpyTestCase):
     def check_all(self):
         a = random.normal(0,1,(4,5,6,7,8))
         for i in xrange(a.ndim):
@@ -363,13 +363,13 @@
             axes.remove(i)
             assert all(amax == aargmax.choose(*a.transpose(i,*axes)))
 
-class test_newaxis(NumpyTestCase):
+class TestNewaxis(NumpyTestCase):
     def check_basic(self):
         sk = array([0,-0.1,0.1])
         res = 250*sk[:,newaxis]
         assert_almost_equal(res.ravel(),250*sk)
 
-class test_clip(NumpyTestCase):
+class TestClip(NumpyTestCase):
     def _check_range(self,x,cmin,cmax):
         assert N.all(x >= cmin)
         assert N.all(x <= cmax)

Modified: trunk/numpy/core/tests/test_numeric.py
===================================================================
--- trunk/numpy/core/tests/test_numeric.py	2007-10-02 07:32:06 UTC (rev 4150)
+++ trunk/numpy/core/tests/test_numeric.py	2007-10-02 07:54:11 UTC (rev 4151)
@@ -31,7 +31,7 @@
         return "Vec("+repr(self.array.tolist())+")"
     __str__=__repr__
 
-class test_dot(NumpyTestCase):
+class TestDot(NumpyTestCase):
     def setUp(self):
         self.A = rand(10,8)
         self.b1 = rand(8,1)
@@ -141,7 +141,7 @@
         assert_equal(zeros[1].array, zeros_test[1].array)
 
 
-class test_bool_scalar(NumpyTestCase):
+class TestBoolScalar(NumpyTestCase):
     def test_logical(self):
         f = False_
         t = True_
@@ -174,7 +174,7 @@
         self.failUnless((f ^ f) is f)
 
 
-class test_seterr(NumpyTestCase):
+class TestSeterr(NumpyTestCase):
     def test_set(self):
         err = seterr()
         old = seterr(divide='warn')
@@ -198,7 +198,7 @@
         array([1.]) / array([0.])
 
 
-class test_fromiter(NumpyTestCase):
+class TestFromiter(NumpyTestCase):
 
     def makegen(self):
         for x in xrange(24):
@@ -232,7 +232,7 @@
         self.failUnless(alltrue(a == expected,axis=0))
         self.failUnless(alltrue(a20 == expected[:20],axis=0))
 
-class test_index(NumpyTestCase):
+class TestIndex(NumpyTestCase):
     def test_boolean(self):
         a = rand(3,5,8)
         V = rand(5,8)
@@ -241,7 +241,7 @@
         V[g1,g2] = -V[g1,g2]
         assert (array([a[0][V>0],a[1][V>0],a[2][V>0]]) == a[:,V>0]).all()
 
-class test_binary_repr(NumpyTestCase):
+class TestBinaryRepr(NumpyTestCase):
     def test_zero(self):
         assert_equal(binary_repr(0),'0')
 
@@ -260,7 +260,7 @@
     assert x.dtype.isnative == y.dtype.isnative
 
 
-class test_clip(NumpyTestCase):
+class TestClip(NumpyTestCase):
     def setUp(self):
         self.nr = 5
         self.nc = 3

Modified: trunk/numpy/core/tests/test_numerictypes.py
===================================================================
--- trunk/numpy/core/tests/test_numerictypes.py	2007-10-02 07:32:06 UTC (rev 4150)
+++ trunk/numpy/core/tests/test_numerictypes.py	2007-10-02 07:54:11 UTC (rev 4151)
@@ -331,7 +331,7 @@
     multiple_rows = True
     _buffer = NbufferT
 
-class test_empty_field(NumpyTestCase):
+class TestEmptyField(NumpyTestCase):
     def check_assign(self):
         a = numpy.arange(10, dtype=numpy.float32)
         a.dtype = [("int",   "<0i4"),("float", "<2f4")]

Modified: trunk/numpy/core/tests/test_records.py
===================================================================
--- trunk/numpy/core/tests/test_records.py	2007-10-02 07:32:06 UTC (rev 4150)
+++ trunk/numpy/core/tests/test_records.py	2007-10-02 07:54:11 UTC (rev 4151)
@@ -6,7 +6,7 @@
 from numpy.core import *
 restore_path()
 
-class test_fromrecords(NumpyTestCase):
+class TestFromrecords(NumpyTestCase):
     def check_fromrecords(self):
         r = rec.fromrecords([[456,'dbe',1.2],[2,'de',1.3]],names='col1,col2,col3')
         assert_equal(r[0].item(),(456, 'dbe', 1.2))
@@ -85,7 +85,7 @@
         assert_array_equal(ra['field'], [[5,5,5]])
         assert callable(ra.field)
 
-class test_record(NumpyTestCase):
+class TestRecord(NumpyTestCase):
     def setUp(self):
         self.data = rec.fromrecords([(1,2,3),(4,5,6)],
                             dtype=[("col1", "<i4"),

Modified: trunk/numpy/core/tests/test_regression.py
===================================================================
--- trunk/numpy/core/tests/test_regression.py	2007-10-02 07:32:06 UTC (rev 4150)
+++ trunk/numpy/core/tests/test_regression.py	2007-10-02 07:54:11 UTC (rev 4151)
@@ -22,7 +22,7 @@
 
     assert(sys.getrefcount(i) >= rc)
 
-class test_regression(NumpyTestCase):
+class TestRegression(NumpyTestCase):
     def check_invalid_round(self,level=rlevel):
         """Ticket #3"""
         v = 4.7599999999999998

Modified: trunk/numpy/core/tests/test_scalarmath.py
===================================================================
--- trunk/numpy/core/tests/test_scalarmath.py	2007-10-02 07:32:06 UTC (rev 4150)
+++ trunk/numpy/core/tests/test_scalarmath.py	2007-10-02 07:54:11 UTC (rev 4151)
@@ -12,7 +12,7 @@
 
 # This compares scalarmath against ufuncs.
 
-class test_types(NumpyTestCase):
+class TestTypes(NumpyTestCase):
     def check_types(self, level=1):
         for atype in types:
             a = atype(1)
@@ -38,7 +38,7 @@
             b = atype([1,2,3])
             assert_equal(a,b)
 
-class test_power(NumpyTestCase):
+class TestPower(NumpyTestCase):
     def check_small_types(self):
         for t in [N.int8, N.int16]:
             a = t(3)
@@ -51,7 +51,7 @@
             b = a ** 4
             assert b == 6765201, "error with %r: got %r" % (t,b)
 
-class test_conversion(NumpyTestCase):
+class TestConversion(NumpyTestCase):
     def test_int_from_long(self):
         l = [1e6, 1e12, 1e18, -1e6, -1e12, -1e18]
         li = [10**6, 10**12, 10**18, -10**6, -10**12, -10**18]

Modified: trunk/numpy/core/tests/test_umath.py
===================================================================
--- trunk/numpy/core/tests/test_umath.py	2007-10-02 07:32:06 UTC (rev 4150)
+++ trunk/numpy/core/tests/test_umath.py	2007-10-02 07:54:11 UTC (rev 4151)
@@ -5,7 +5,7 @@
 from numpy import zeros, ndarray, array, choose
 restore_path()
 
-class test_division(NumpyTestCase):
+class TestDivision(NumpyTestCase):
     def check_division_int(self):
         # int division should return the floor of the result, a la Python
         x = array([5, 10, 90, 100, -5, -10, -90, -100, -120])
@@ -13,7 +13,7 @@
         assert_equal(x // 100, [0, 0, 0, 1, -1, -1, -1, -1, -2])
         assert_equal(x % 100, [5, 10, 90, 0, 95, 90, 10, 0, 80])
 
-class test_power(NumpyTestCase):
+class TestPower(NumpyTestCase):
     def check_power_float(self):
         x = array([1., 2., 3.])
         assert_equal(x**0, [1., 1., 1.])
@@ -38,30 +38,30 @@
         assert_almost_equal(x**14, [-76443+16124j, 23161315+58317492j,
                                     5583548873 +  2465133864j])
 
-class test_log1p(NumpyTestCase):
+class TestLog1p(NumpyTestCase):
     def check_log1p(self):
         assert_almost_equal(ncu.log1p(0.2), ncu.log(1.2))
         assert_almost_equal(ncu.log1p(1e-6), ncu.log(1+1e-6))
 
-class test_expm1(NumpyTestCase):
+class TestExpm1(NumpyTestCase):
     def check_expm1(self):
         assert_almost_equal(ncu.expm1(0.2), ncu.exp(0.2)-1)
         assert_almost_equal(ncu.expm1(1e-6), ncu.exp(1e-6)-1)
 
-class test_maximum(NumpyTestCase):
+class TestMaximum(NumpyTestCase):
     def check_reduce_complex(self):
         assert_equal(maximum.reduce([1,2j]),1)
         assert_equal(maximum.reduce([1+3j,2j]),1+3j)
 
-class test_minimum(NumpyTestCase):
+class TestMinimum(NumpyTestCase):
     def check_reduce_complex(self):
         assert_equal(minimum.reduce([1,2j]),2j)
 
-class test_floating_point(NumpyTestCase):
+class TestFloatingPoint(NumpyTestCase):
     def check_floating_point(self):
         assert_equal(ncu.FLOATING_POINT_SUPPORT, 1)
 
-class test_special_methods(NumpyTestCase):
+class TestSpecialMethods(NumpyTestCase):
     def test_wrap(self):
         class with_wrap(object):
             def __array__(self):
@@ -163,7 +163,7 @@
         assert_equal(maximum(a, B()), 0)
         assert_equal(maximum(a, C()), 0)
 
-class test_choose(NumpyTestCase):
+class TestChoose(NumpyTestCase):
     def test_mixed(self):
         c = array([True,True])
         a = array([True,True])
@@ -183,7 +183,7 @@
             assert_almost_equal(fun(self.x),cr.real)
             assert_almost_equal(0, cr.imag)
 
-class test_choose(NumpyTestCase):
+class TestChoose(NumpyTestCase):
     def test_attributes(self):
         add = ncu.add
         assert_equal(add.__name__, 'add')

Modified: trunk/numpy/distutils/tests/f2py_ext/tests/test_fib2.py
===================================================================
--- trunk/numpy/distutils/tests/f2py_ext/tests/test_fib2.py	2007-10-02 07:32:06 UTC (rev 4150)
+++ trunk/numpy/distutils/tests/f2py_ext/tests/test_fib2.py	2007-10-02 07:54:11 UTC (rev 4151)
@@ -4,7 +4,7 @@
 from f2py_ext import fib2
 del sys.path[0]
 
-class test_fib2(NumpyTestCase):
+class TestFib2(NumpyTestCase):
 
     def check_fib(self):
         assert_array_equal(fib2.fib(6),[0,1,1,2,3,5])

Modified: trunk/numpy/distutils/tests/f2py_f90_ext/tests/test_foo.py
===================================================================
--- trunk/numpy/distutils/tests/f2py_f90_ext/tests/test_foo.py	2007-10-02 07:32:06 UTC (rev 4150)
+++ trunk/numpy/distutils/tests/f2py_f90_ext/tests/test_foo.py	2007-10-02 07:54:11 UTC (rev 4151)
@@ -4,7 +4,7 @@
 from f2py_f90_ext import foo
 del sys.path[0]
 
-class test_foo(NumpyTestCase):
+class TestFoo(NumpyTestCase):
 
     def check_foo_free(self):
         assert_equal(foo.foo_free.bar13(),13)

Modified: trunk/numpy/distutils/tests/gen_ext/tests/test_fib3.py
===================================================================
--- trunk/numpy/distutils/tests/gen_ext/tests/test_fib3.py	2007-10-02 07:32:06 UTC (rev 4150)
+++ trunk/numpy/distutils/tests/gen_ext/tests/test_fib3.py	2007-10-02 07:54:11 UTC (rev 4151)
@@ -4,7 +4,7 @@
 from gen_ext import fib3
 del sys.path[0]
 
-class test_fib3(NumpyTestCase):
+class TestFib3(NumpyTestCase):
 
     def check_fib(self):
         assert_array_equal(fib3.fib(6),[0,1,1,2,3,5])

Modified: trunk/numpy/distutils/tests/pyrex_ext/tests/test_primes.py
===================================================================
--- trunk/numpy/distutils/tests/pyrex_ext/tests/test_primes.py	2007-10-02 07:32:06 UTC (rev 4150)
+++ trunk/numpy/distutils/tests/pyrex_ext/tests/test_primes.py	2007-10-02 07:54:11 UTC (rev 4151)
@@ -5,7 +5,7 @@
 from pyrex_ext.primes import primes
 restore_path()
 
-class test_primes(NumpyTestCase):
+class TestPrimes(NumpyTestCase):
     def check_simple(self, level=1):
         l = primes(10)
         assert_equal(l, [2, 3, 5, 7, 11, 13, 17, 19, 23, 29])

Modified: trunk/numpy/distutils/tests/swig_ext/tests/test_example.py
===================================================================
--- trunk/numpy/distutils/tests/swig_ext/tests/test_example.py	2007-10-02 07:32:06 UTC (rev 4150)
+++ trunk/numpy/distutils/tests/swig_ext/tests/test_example.py	2007-10-02 07:54:11 UTC (rev 4151)
@@ -4,7 +4,7 @@
 from swig_ext import example
 restore_path()
 
-class test_example(NumpyTestCase):
+class TestExample(NumpyTestCase):
 
     def check_fact(self):
         assert_equal(example.fact(10),3628800)

Modified: trunk/numpy/distutils/tests/swig_ext/tests/test_example2.py
===================================================================
--- trunk/numpy/distutils/tests/swig_ext/tests/test_example2.py	2007-10-02 07:32:06 UTC (rev 4150)
+++ trunk/numpy/distutils/tests/swig_ext/tests/test_example2.py	2007-10-02 07:54:11 UTC (rev 4151)
@@ -4,7 +4,7 @@
 from swig_ext import example2
 restore_path()
 
-class test_example2(NumpyTestCase):
+class TestExample2(NumpyTestCase):
 
     def check_zoo(self):
         z = example2.Zoo()

Modified: trunk/numpy/distutils/tests/test_fcompiler_gnu.py
===================================================================
--- trunk/numpy/distutils/tests/test_fcompiler_gnu.py	2007-10-02 07:32:06 UTC (rev 4150)
+++ trunk/numpy/distutils/tests/test_fcompiler_gnu.py	2007-10-02 07:54:11 UTC (rev 4151)
@@ -21,7 +21,7 @@
     ('GNU Fortran (GCC) 4.3.0 20070316 (experimental)', '4.3.0'),
 ]
 
-class test_g77_versions(NumpyTestCase):
+class TestG77Versions(NumpyTestCase):
     def test_g77_version(self):
         fc = numpy.distutils.fcompiler.new_fcompiler(compiler='gnu')
         for vs, version in g77_version_strings:
@@ -34,7 +34,7 @@
             v = fc.version_match(vs)
             assert v is None, (vs, v)
 
-class test_gortran_versions(NumpyTestCase):
+class TestGortranVersions(NumpyTestCase):
     def test_gfortran_version(self):
         fc = numpy.distutils.fcompiler.new_fcompiler(compiler='gnu95')
         for vs, version in gfortran_version_strings:

Modified: trunk/numpy/distutils/tests/test_misc_util.py
===================================================================
--- trunk/numpy/distutils/tests/test_misc_util.py	2007-10-02 07:32:06 UTC (rev 4150)
+++ trunk/numpy/distutils/tests/test_misc_util.py	2007-10-02 07:54:11 UTC (rev 4151)
@@ -8,7 +8,7 @@
 
 ajoin = lambda *paths: join(*((sep,)+paths))
 
-class test_appendpath(NumpyTestCase):
+class TestAppendpath(NumpyTestCase):
 
     def check_1(self):
         assert_equal(appendpath('prefix','name'),join('prefix','name'))
@@ -32,7 +32,7 @@
         assert_equal(appendpath('/prefix/sub/sub2','/prefix/sub/sup/name'),
                      ajoin('prefix','sub','sub2','sup','name'))
 
-class test_minrelpath(NumpyTestCase):
+class TestMinrelpath(NumpyTestCase):
 
     def check_1(self):
         import os
@@ -47,7 +47,7 @@
         assert_equal(minrelpath(n('.././..')),n('../..'))
         assert_equal(minrelpath(n('aa/bb/.././../dd')),n('dd'))
 
-class test_gpaths(NumpyTestCase):
+class TestGpaths(NumpyTestCase):
 
     def check_gpaths(self):
         local_path = minrelpath(os.path.join(os.path.dirname(__file__),'..'))

Modified: trunk/numpy/f2py/lib/parser/test_Fortran2003.py
===================================================================
--- trunk/numpy/f2py/lib/parser/test_Fortran2003.py	2007-10-02 07:32:06 UTC (rev 4150)
+++ trunk/numpy/f2py/lib/parser/test_Fortran2003.py	2007-10-02 07:54:11 UTC (rev 4151)
@@ -7,7 +7,7 @@
 ############################### SECTION  2 ####################################
 ###############################################################################
 
-class test_Program(NumpyTestCase): # R201
+class TestProgram(NumpyTestCase): # R201
 
     def check_simple(self):
         reader = get_reader('''\
@@ -21,7 +21,7 @@
         assert isinstance(a, cls),`a`
         assert_equal(str(a), 'SUBROUTINE foo\nEND SUBROUTINE foo\nSUBROUTINE bar\nEND SUBROUTINE bar')
 
-class test_Specification_Part(NumpyTestCase): # R204
+class TestSpecificationPart(NumpyTestCase): # R204
 
     def check_simple(self):
         from api import get_reader
@@ -37,7 +37,7 @@
 ############################### SECTION  3 ####################################
 ###############################################################################
 
-class test_Name(NumpyTestCase): # R304
+class TestName(NumpyTestCase): # R304
 
     def check_name(self):
         a = Name('a')
@@ -55,7 +55,7 @@
 ############################### SECTION  4 ####################################
 ###############################################################################
 
-class test_Type_Param_Value(NumpyTestCase): # 402
+class TestTypeParamValue(NumpyTestCase): # 402
 
     def check_type_param_value(self):
         cls = Type_Param_Value
@@ -72,7 +72,7 @@
         assert isinstance(a,Level_2_Expr),`a`
         assert_equal(str(a),'1 + 2')
 
-class test_Intrinsic_Type_Spec(NumpyTestCase): # R403
+class TestIntrinsicTypeSpec(NumpyTestCase): # R403
 
     def check_intrinsic_type_spec(self):
         cls = Intrinsic_Type_Spec
@@ -109,7 +109,7 @@
         assert isinstance(a,cls),`a`
         assert_equal(str(a),'DOUBLE PRECISION')
 
-class test_Kind_Selector(NumpyTestCase): # R404
+class TestKindSelector(NumpyTestCase): # R404
 
     def check_kind_selector(self):
         cls = Kind_Selector
@@ -126,7 +126,7 @@
         assert isinstance(a,cls),`a`
         assert_equal(str(a),'*1')
 
-class test_Signed_Int_Literal_Constant(NumpyTestCase): # R405
+class TestSignedIntLiteralConstant(NumpyTestCase): # R405
 
     def check_int_literal_constant(self):
         cls = Signed_Int_Literal_Constant
@@ -152,7 +152,7 @@
         assert isinstance(a,cls),`a`
         assert_equal(str(a),'+1976354279568241_8')
 
-class test_Int_Literal_Constant(NumpyTestCase): # R406
+class TestIntLiteralConstant(NumpyTestCase): # R406
 
     def check_int_literal_constant(self):
         cls = Int_Literal_Constant
@@ -178,7 +178,7 @@
         assert isinstance(a,cls),`a`
         assert_equal(str(a),'1976354279568241_8')
 
-class test_Binary_Constant(NumpyTestCase): # R412
+class TestBinaryConstant(NumpyTestCase): # R412
 
     def check_boz_literal_constant(self):
         cls = Boz_Literal_Constant
@@ -188,7 +188,7 @@
         assert_equal(str(a),'B"01"')
         assert_equal(repr(a),"%s('B\"01\"')" % (bcls.__name__))
 
-class test_Octal_Constant(NumpyTestCase): # R413
+class TestOctalConstant(NumpyTestCase): # R413
 
     def check_boz_literal_constant(self):
         cls = Boz_Literal_Constant
@@ -198,7 +198,7 @@
         assert_equal(str(a),'O"017"')
         assert_equal(repr(a),"%s('O\"017\"')" % (ocls.__name__))
 
-class test_Hex_Constant(NumpyTestCase): # R414
+class TestHexConstant(NumpyTestCase): # R414
 
     def check_boz_literal_constant(self):
         cls = Boz_Literal_Constant
@@ -208,7 +208,7 @@
         assert_equal(str(a),'Z"01A"')
         assert_equal(repr(a),"%s('Z\"01A\"')" % (zcls.__name__))
 
-class test_Signed_Real_Literal_Constant(NumpyTestCase): # R416
+class TestSignedRealLiteralConstant(NumpyTestCase): # R416
 
     def check_signed_real_literal_constant(self):
         cls = Signed_Real_Literal_Constant
@@ -265,7 +265,7 @@
         assert isinstance(a,cls),`a`
         assert_equal(str(a),'-10.9E-17_quad')
 
-class test_Real_Literal_Constant(NumpyTestCase): # R417
+class TestRealLiteralConstant(NumpyTestCase): # R417
 
     def check_real_literal_constant(self):
         cls = Real_Literal_Constant
@@ -326,7 +326,7 @@
         assert isinstance(a,cls),`a`
         assert_equal(str(a),'0.0D+0')
 
-class test_Char_Selector(NumpyTestCase): # R424
+class TestCharSelector(NumpyTestCase): # R424
 
     def check_char_selector(self):
         cls = Char_Selector
@@ -352,7 +352,7 @@
         assert isinstance(a,cls),`a`
         assert_equal(str(a),'(LEN = 2, KIND = 8)')
 
-class test_Complex_Literal_Constant(NumpyTestCase): # R421
+class TestComplexLiteralConstant(NumpyTestCase): # R421
 
     def check_complex_literal_constant(self):
         cls = Complex_Literal_Constant
@@ -374,7 +374,7 @@
         assert_equal(str(a),'(0., PI)')
 
 
-class test_Type_Name(NumpyTestCase): # C424
+class TestTypeName(NumpyTestCase): # C424
 
     def check_simple(self):
         cls = Type_Name
@@ -386,7 +386,7 @@
         self.assertRaises(NoMatchError,cls,'integer')
         self.assertRaises(NoMatchError,cls,'doubleprecision')
 
-class test_Length_Selector(NumpyTestCase): # R425
+class TestLengthSelector(NumpyTestCase): # R425
 
     def check_length_selector(self):
         cls = Length_Selector
@@ -399,7 +399,7 @@
         assert isinstance(a,cls),`a`
         assert_equal(str(a),'*2')
 
-class test_Char_Length(NumpyTestCase): # R426
+class TestCharLength(NumpyTestCase): # R426
 
     def check_char_length(self):
         cls = Char_Length
@@ -420,7 +420,7 @@
         assert isinstance(a,cls),`a`
         assert_equal(str(a),'(:)')
 
-class test_Char_Literal_Constant(NumpyTestCase): # R427
+class TestCharLiteralConstant(NumpyTestCase): # R427
 
     def check_char_literal_constant(self):
         cls = Char_Literal_Constant
@@ -454,7 +454,7 @@
         assert isinstance(a,cls),`a`
         assert_equal(str(a),'"hey ha(ada)\t"')
 
-class test_Logical_Literal_Constant(NumpyTestCase): # R428
+class TestLogicalLiteralConstant(NumpyTestCase): # R428
 
     def check_logical_literal_constant(self):
         cls = Logical_Literal_Constant
@@ -475,7 +475,7 @@
         assert isinstance(a,cls),`a`
         assert_equal(str(a),'.TRUE._HA')
 
-class test_Derived_Type_Stmt(NumpyTestCase): # R430
+class TestDerivedTypeStmt(NumpyTestCase): # R430
 
     def check_simple(self):
         cls = Derived_Type_Stmt
@@ -492,7 +492,7 @@
         assert isinstance(a, cls),`a`
         assert_equal(str(a),'TYPE, PRIVATE, ABSTRACT :: a(b, c)')
 
-class test_Type_Name(NumpyTestCase): # C423
+class TestTypeName(NumpyTestCase): # C423
 
     def check_simple(self):
         cls = Type_Name
@@ -501,7 +501,7 @@
         assert_equal(str(a),'a')
         assert_equal(repr(a),"Type_Name('a')")
 
-class test_Type_Attr_Spec(NumpyTestCase): # R431
+class TestTypeAttrSpec(NumpyTestCase): # R431
 
     def check_simple(self):
         cls = Type_Attr_Spec
@@ -523,7 +523,7 @@
         assert_equal(str(a),'PRIVATE')
 
 
-class test_End_Type_Stmt(NumpyTestCase): # R433
+class TestEndTypeStmt(NumpyTestCase): # R433
 
     def check_simple(self):
         cls = End_Type_Stmt
@@ -536,7 +536,7 @@
         assert isinstance(a, cls),`a`
         assert_equal(str(a),'END TYPE a')
 
-class test_Sequence_Stmt(NumpyTestCase): # R434
+class TestSequenceStmt(NumpyTestCase): # R434
 
     def check_simple(self):
         cls = Sequence_Stmt
@@ -545,7 +545,7 @@
         assert_equal(str(a),'SEQUENCE')
         assert_equal(repr(a),"Sequence_Stmt('SEQUENCE')")
 
-class test_Type_Param_Def_Stmt(NumpyTestCase): # R435
+class TestTypeParamDefStmt(NumpyTestCase): # R435
 
     def check_simple(self):
         cls = Type_Param_Def_Stmt
@@ -558,7 +558,7 @@
         assert isinstance(a, cls),`a`
         assert_equal(str(a),'INTEGER*2, LEN :: a = 3, b = 2 + c')
 
-class test_Type_Param_Decl(NumpyTestCase): # R436
+class TestTypeParamDecl(NumpyTestCase): # R436
 
     def check_simple(self):
         cls = Type_Param_Decl
@@ -571,7 +571,7 @@
         assert isinstance(a, Name),`a`
         assert_equal(str(a),'a')
 
-class test_Type_Param_Attr_Spec(NumpyTestCase): # R437
+class TestTypeParamAttrSpec(NumpyTestCase): # R437
 
     def check_simple(self):
         cls = Type_Param_Attr_Spec
@@ -584,7 +584,7 @@
         assert isinstance(a, cls),`a`
         assert_equal(str(a),'LEN')
 
-class test_Component_Attr_Spec(NumpyTestCase): # R441
+class TestComponentAttrSpec(NumpyTestCase): # R441
 
     def check_simple(self):
         cls = Component_Attr_Spec
@@ -605,7 +605,7 @@
         assert isinstance(a, Access_Spec),`a`
         assert_equal(str(a),'PRIVATE')
 
-class test_Component_Decl(NumpyTestCase): # R442
+class TestComponentDecl(NumpyTestCase): # R442
 
     def check_simple(self):
         cls = Component_Decl
@@ -626,7 +626,7 @@
         assert isinstance(a, cls),`a`
         assert_equal(str(a),'a(1) => NULL')
 
-class test_Final_Binding(NumpyTestCase): # R454
+class TestFinalBinding(NumpyTestCase): # R454
 
     def check_simple(self):
         cls = Final_Binding
@@ -639,7 +639,7 @@
         assert isinstance(a,cls),`a`
         assert_equal(str(a),'FINAL :: a')
 
-class test_Derived_Type_Spec(NumpyTestCase): # R455
+class TestDerivedTypeSpec(NumpyTestCase): # R455
 
     def check_simple(self):
         cls = Derived_Type_Spec
@@ -660,7 +660,7 @@
         assert isinstance(a,cls),`a`
         assert_equal(str(a),'a()')
 
-class test_Type_Param_Spec(NumpyTestCase): # R456
+class TestTypeParamSpec(NumpyTestCase): # R456
 
     def check_type_param_spec(self):
         cls = Type_Param_Spec
@@ -677,7 +677,7 @@
         assert isinstance(a,cls),`a`
         assert_equal(str(a),'k = :')
 
-class test_Type_Param_Spec_List(NumpyTestCase): # R456-list
+class TestTypeParamSpecList(NumpyTestCase): # R456-list
 
     def check_type_param_spec_list(self):
         cls = Type_Param_Spec_List
@@ -694,7 +694,7 @@
         assert isinstance(a,cls),`a`
         assert_equal(str(a),'k = a, c, g = 1')
 
-class test_Structure_Constructor_2(NumpyTestCase): # R457.b
+class TestStructureConstructor2(NumpyTestCase): # R457.b
 
     def check_simple(self):
         cls = Structure_Constructor_2
@@ -707,7 +707,7 @@
         assert isinstance(a,Name),`a`
         assert_equal(str(a),'a')
 
-class test_Structure_Constructor(NumpyTestCase): # R457
+class TestStructureConstructor(NumpyTestCase): # R457
 
     def check_structure_constructor(self):
         cls = Structure_Constructor
@@ -729,7 +729,7 @@
         assert isinstance(a,Name),`a`
         assert_equal(str(a),'a')
 
-class test_Component_Spec(NumpyTestCase): # R458
+class TestComponentSpec(NumpyTestCase): # R458
 
     def check_simple(self):
         cls = Component_Spec
@@ -750,7 +750,7 @@
         assert isinstance(a, Component_Spec),`a`
         assert_equal(str(a),'s = a % b')
 
-class test_Component_Spec_List(NumpyTestCase): # R458-list
+class TestComponentSpecList(NumpyTestCase): # R458-list
 
     def check_simple(self):
         cls = Component_Spec_List
@@ -763,7 +763,7 @@
         assert isinstance(a,cls),`a`
         assert_equal(str(a),'k = a, c')
 
-class test_Array_Constructor(NumpyTestCase): # R465
+class TestArrayConstructor(NumpyTestCase): # R465
 
     def check_simple(self):
         cls = Array_Constructor
@@ -785,7 +785,7 @@
         assert isinstance(a,cls),`a`
         assert_equal(str(a),'[INTEGER :: a, b]')
 
-class test_Ac_Spec(NumpyTestCase): # R466
+class TestAcSpec(NumpyTestCase): # R466
 
     def check_ac_spec(self):
         cls = Ac_Spec
@@ -806,7 +806,7 @@
         assert isinstance(a,cls),`a`
         assert_equal(str(a),'INTEGER :: a, (a, b, n = 1, 5)')
 
-class test_Ac_Value_List(NumpyTestCase): # R469-list
+class TestAcValueList(NumpyTestCase): # R469-list
 
     def check_ac_value_list(self):
         cls = Ac_Value_List
@@ -819,7 +819,7 @@
         assert isinstance(a,Name),`a`
         assert_equal(str(a),'a')
 
-class test_Ac_Implied_Do(NumpyTestCase): # R470
+class TestAcImpliedDo(NumpyTestCase): # R470
 
     def check_ac_implied_do(self):
         cls = Ac_Implied_Do
@@ -828,7 +828,7 @@
         assert_equal(str(a),'(a, b, n = 1, 5)')
         assert_equal(repr(a),"Ac_Implied_Do(Ac_Value_List(',', (Name('a'), Name('b'))), Ac_Implied_Do_Control(Name('n'), [Int_Literal_Constant('1', None), Int_Literal_Constant('5', None)]))")
 
-class test_Ac_Implied_Do_Control(NumpyTestCase): # R471
+class TestAcImpliedDoControl(NumpyTestCase): # R471
 
     def check_ac_implied_do_control(self):
         cls = Ac_Implied_Do_Control
@@ -845,7 +845,7 @@
 ############################### SECTION  5 ####################################
 ###############################################################################
 
-class test_Type_Declaration_Stmt(NumpyTestCase): # R501
+class TestTypeDeclarationStmt(NumpyTestCase): # R501
 
     def check_simple(self):
         cls = Type_Declaration_Stmt
@@ -869,7 +869,7 @@
         a = cls('DOUBLE PRECISION   ALPHA, BETA')
         assert isinstance(a, cls),`a`
 
-class test_Declaration_Type_Spec(NumpyTestCase): # R502
+class TestDeclarationTypeSpec(NumpyTestCase): # R502
 
     def check_simple(self):
         cls = Declaration_Type_Spec
@@ -882,7 +882,7 @@
         assert_equal(str(a), 'TYPE(foo)')
         assert_equal(repr(a), "Declaration_Type_Spec('TYPE', Type_Name('foo'))")
 
-class test_Attr_Spec(NumpyTestCase): # R503
+class TestAttrSpec(NumpyTestCase): # R503
 
     def check_simple(self):
         cls = Attr_Spec
@@ -894,7 +894,7 @@
         assert isinstance(a, Dimension_Attr_Spec),`a`
         assert_equal(str(a),'DIMENSION(a)')
 
-class test_Dimension_Attr_Spec(NumpyTestCase): # R503.d
+class TestDimensionAttrSpec(NumpyTestCase): # R503.d
 
     def check_simple(self):
         cls = Dimension_Attr_Spec
@@ -903,7 +903,7 @@
         assert_equal(str(a),'DIMENSION(a)')
         assert_equal(repr(a),"Dimension_Attr_Spec('DIMENSION', Explicit_Shape_Spec(None, Name('a')))")
 
-class test_Intent_Attr_Spec(NumpyTestCase): # R503.f
+class TestIntentAttrSpec(NumpyTestCase): # R503.f
 
     def check_simple(self):
         cls = Intent_Attr_Spec
@@ -912,7 +912,7 @@
         assert_equal(str(a),'INTENT(IN)')
         assert_equal(repr(a),"Intent_Attr_Spec('INTENT', Intent_Spec('IN'))")
 
-class test_Entity_Decl(NumpyTestCase): # 504
+class TestEntityDecl(NumpyTestCase): # 504
 
     def check_simple(self):
         cls = Entity_Decl
@@ -929,7 +929,7 @@
         assert isinstance(a, cls),`a`
         assert_equal(str(a),'a(1)*(3) = 2')
 
-class test_Access_Spec(NumpyTestCase): # R508
+class TestAccessSpec(NumpyTestCase): # R508
 
     def check_simple(self):
         cls = Access_Spec
@@ -942,7 +942,7 @@
         assert isinstance(a, cls),`a`
         assert_equal(str(a),'PUBLIC')
 
-class test_Language_Binding_Spec(NumpyTestCase): # R509
+class TestLanguageBindingSpec(NumpyTestCase): # R509
 
     def check_simple(self):
         cls = Language_Binding_Spec
@@ -955,7 +955,7 @@
         assert isinstance(a, cls),`a`
         assert_equal(str(a),'BIND(C, NAME = "hey")')
 
-class test_Explicit_Shape_Spec(NumpyTestCase): # R511
+class TestExplicitShapeSpec(NumpyTestCase): # R511
 
     def check_simple(self):
         cls = Explicit_Shape_Spec
@@ -968,7 +968,7 @@
         assert isinstance(a, cls),`a`
         assert_equal(str(a),'a')
 
-class test_Upper_Bound(NumpyTestCase): # R513
+class TestUpperBound(NumpyTestCase): # R513
 
     def check_simple(self):
         cls = Upper_Bound
@@ -978,7 +978,7 @@
 
         self.assertRaises(NoMatchError,cls,'*')
 
-class test_Assumed_Shape_Spec(NumpyTestCase): # R514
+class TestAssumedShapeSpec(NumpyTestCase): # R514
 
     def check_simple(self):
         cls = Assumed_Shape_Spec
@@ -991,7 +991,7 @@
         assert isinstance(a, cls),`a`
         assert_equal(str(a),'a :')
 
-class test_Deferred_Shape_Spec(NumpyTestCase): # R515
+class TestDeferredShapeSpec(NumpyTestCase): # R515
 
     def check_simple(self):
         cls = Deferred_Shape_Spec
@@ -1001,7 +1001,7 @@
         assert_equal(repr(a),'Deferred_Shape_Spec(None, None)')
 
 
-class test_Assumed_Size_Spec(NumpyTestCase): # R516
+class TestAssumedSizeSpec(NumpyTestCase): # R516
 
     def check_simple(self):
         cls = Assumed_Size_Spec
@@ -1022,7 +1022,7 @@
         assert isinstance(a, cls),`a`
         assert_equal(str(a),'a : b, 1 : *')
 
-class test_Access_Stmt(NumpyTestCase): # R518
+class TestAccessStmt(NumpyTestCase): # R518
 
     def check_simple(self):
         cls = Access_Stmt
@@ -1039,7 +1039,7 @@
         assert isinstance(a, cls),`a`
         assert_equal(str(a),'PUBLIC :: a')
 
-class test_Parameter_Stmt(NumpyTestCase): # R538
+class TestParameterStmt(NumpyTestCase): # R538
 
     def check_simple(self):
         cls = Parameter_Stmt
@@ -1056,7 +1056,7 @@
         assert isinstance(a, cls),`a`
         assert_equal(str(a),'PARAMETER(ONE = 1.0D+0, ZERO = 0.0D+0)')
 
-class test_Named_Constant_Def(NumpyTestCase): # R539
+class TestNamedConstantDef(NumpyTestCase): # R539
 
     def check_simple(self):
         cls = Named_Constant_Def
@@ -1065,7 +1065,7 @@
         assert_equal(str(a),'a = 1')
         assert_equal(repr(a),"Named_Constant_Def(Name('a'), Int_Literal_Constant('1', None))")
 
-class test_Pointer_Decl(NumpyTestCase): # R541
+class TestPointerDecl(NumpyTestCase): # R541
 
     def check_simple(self):
         cls = Pointer_Decl
@@ -1078,7 +1078,7 @@
         assert isinstance(a, cls),`a`
         assert_equal(str(a),'a(:, :)')
 
-class test_Implicit_Stmt(NumpyTestCase): # R549
+class TestImplicitStmt(NumpyTestCase): # R549
 
     def check_simple(self):
         cls = Implicit_Stmt
@@ -1091,7 +1091,7 @@
         assert isinstance(a, cls),`a`
         assert_equal(str(a),'IMPLICIT REAL(A - D), DOUBLE PRECISION(R - T, X), TYPE(a)(Y - Z)')
 
-class test_Implicit_Spec(NumpyTestCase): # R550
+class TestImplicitSpec(NumpyTestCase): # R550
 
     def check_simple(self):
         cls = Implicit_Spec
@@ -1104,7 +1104,7 @@
         assert isinstance(a, cls),`a`
         assert_equal(str(a),'DOUBLE COMPLEX(R, D - G)')
 
-class test_Letter_Spec(NumpyTestCase): # R551
+class TestLetterSpec(NumpyTestCase): # R551
 
     def check_simple(self):
         cls = Letter_Spec
@@ -1117,7 +1117,7 @@
         assert isinstance(a, cls),`a`
         assert_equal(str(a),'D')
 
-class test_Equivalence_Stmt(NumpyTestCase): # R554
+class TestEquivalenceStmt(NumpyTestCase): # R554
 
     def check_simple(self):
         cls = Equivalence_Stmt
@@ -1130,7 +1130,7 @@
         assert isinstance(a, cls),`a`
         assert_equal(str(a),'EQUIVALENCE(a, b, z), (b, l)')
 
-class test_Common_Stmt(NumpyTestCase): # R557
+class TestCommonStmt(NumpyTestCase): # R557
 
     def check_simple(self):
         cls = Common_Stmt
@@ -1151,7 +1151,7 @@
         assert isinstance(a, cls),`a`
         assert_equal(str(a),'COMMON /name/ a, b(4, 5) // c /ljuks/ g(2)')
 
-class test_Common_Block_Object(NumpyTestCase): # R558
+class TestCommonBlockObject(NumpyTestCase): # R558
 
     def check_simple(self):
         cls = Common_Block_Object
@@ -1169,7 +1169,7 @@
 ############################### SECTION  6 ####################################
 ###############################################################################
 
-class test_Substring(NumpyTestCase): # R609
+class TestSubstring(NumpyTestCase): # R609
 
     def check_simple(self):
         cls = Substring
@@ -1184,7 +1184,7 @@
         assert_equal(repr(a),"Substring(Name('a'), Substring_Range(Int_Literal_Constant('1', None), Int_Literal_Constant('2', None)))")
 
 
-class test_Substring_Range(NumpyTestCase): # R611
+class TestSubstringRange(NumpyTestCase): # R611
 
     def check_simple(self):
         cls = Substring_Range
@@ -1215,7 +1215,7 @@
         assert_equal(str(a),': b')
 
 
-class test_Data_Ref(NumpyTestCase): # R612
+class TestDataRef(NumpyTestCase): # R612
 
     def check_data_ref(self):
         cls = Data_Ref
@@ -1228,7 +1228,7 @@
         assert isinstance(a,Name),`a`
         assert_equal(str(a),'a')
 
-class test_Part_Ref(NumpyTestCase): # R613
+class TestPartRef(NumpyTestCase): # R613
 
     def check_part_ref(self):
         cls = Part_Ref
@@ -1236,7 +1236,7 @@
         assert isinstance(a, Name),`a`
         assert_equal(str(a),'a')
 
-class test_Type_Param_Inquiry(NumpyTestCase): # R615
+class TestTypeParamInquiry(NumpyTestCase): # R615
 
     def check_simple(self):
         cls = Type_Param_Inquiry
@@ -1246,7 +1246,7 @@
         assert_equal(repr(a),"Type_Param_Inquiry(Name('a'), '%', Name('b'))")
 
 
-class test_Array_Section(NumpyTestCase): # R617
+class TestArraySection(NumpyTestCase): # R617
 
     def check_array_section(self):
         cls = Array_Section
@@ -1260,7 +1260,7 @@
         assert_equal(str(a),'a(2 :)')
 
 
-class test_Section_Subscript(NumpyTestCase): # R619
+class TestSectionSubscript(NumpyTestCase): # R619
 
     def check_simple(self):
         cls = Section_Subscript
@@ -1273,7 +1273,7 @@
         assert isinstance(a, Name),`a`
         assert_equal(str(a),'zzz')
 
-class test_Section_Subscript_List(NumpyTestCase): # R619-list
+class TestSectionSubscriptList(NumpyTestCase): # R619-list
 
     def check_simple(self):
         cls = Section_Subscript_List
@@ -1290,7 +1290,7 @@
         assert isinstance(a,cls),`a`
         assert_equal(str(a),': : 1, 3')
 
-class test_Subscript_Triplet(NumpyTestCase): # R620
+class TestSubscriptTriplet(NumpyTestCase): # R620
 
     def check_simple(self):
         cls = Subscript_Triplet
@@ -1319,7 +1319,7 @@
         assert isinstance(a,cls),`a`
         assert_equal(str(a),'a + 1 :')
 
-class test_Alloc_Opt(NumpyTestCase): # R624
+class TestAllocOpt(NumpyTestCase): # R624
 
     def check_simple(self):
         cls = Alloc_Opt
@@ -1328,7 +1328,7 @@
         assert_equal(str(a),'STAT = a')
         assert_equal(repr(a),"Alloc_Opt('STAT', Name('a'))")
 
-class test_Nullify_Stmt(NumpyTestCase): # R633
+class TestNullifyStmt(NumpyTestCase): # R633
 
     def check_simple(self):
         cls = Nullify_Stmt
@@ -1345,7 +1345,7 @@
 ############################### SECTION  7 ####################################
 ###############################################################################
 
-class test_Primary(NumpyTestCase): # R701
+class TestPrimary(NumpyTestCase): # R701
 
     def check_simple(self):
         cls = Primary
@@ -1401,7 +1401,7 @@
         assert isinstance(a,Real_Literal_Constant),`a`
         assert_equal(str(a),'0.0E-1')
 
-class test_Parenthesis(NumpyTestCase): # R701.h
+class TestParenthesis(NumpyTestCase): # R701.h
 
     def check_simple(self):
         cls = Parenthesis
@@ -1422,7 +1422,7 @@
         assert isinstance(a,cls),`a`
         assert_equal(str(a),'(a + (a + c))')
 
-class test_Level_1_Expr(NumpyTestCase): # R702
+class TestLevel1Expr(NumpyTestCase): # R702
 
     def check_simple(self):
         cls = Level_1_Expr
@@ -1433,7 +1433,7 @@
 
         self.assertRaises(NoMatchError,cls,'.not. a')
 
-class test_Mult_Operand(NumpyTestCase): # R704
+class TestMultOperand(NumpyTestCase): # R704
 
     def check_simple(self):
         cls = Mult_Operand
@@ -1454,7 +1454,7 @@
         assert isinstance(a,Real_Literal_Constant),`a`
         assert_equal(str(a),'0.0E-1')
 
-class test_Add_Operand(NumpyTestCase): # R705
+class TestAddOperand(NumpyTestCase): # R705
 
     def check_simple(self):
         cls = Add_Operand
@@ -1475,7 +1475,7 @@
         assert isinstance(a,Real_Literal_Constant),`a`
         assert_equal(str(a),'0.0E-1')
 
-class test_Level_2_Expr(NumpyTestCase): # R706
+class TestLevel2Expr(NumpyTestCase): # R706
 
     def check_simple(self):
         cls = Level_2_Expr
@@ -1509,7 +1509,7 @@
         assert_equal(str(a),'0.0E-1')
 
 
-class test_Level_2_Unary_Expr(NumpyTestCase):
+class TestLevel2UnaryExpr(NumpyTestCase):
 
     def check_simple(self):
         cls = Level_2_Unary_Expr
@@ -1531,7 +1531,7 @@
         assert_equal(str(a),'0.0E-1')
 
 
-class test_Level_3_Expr(NumpyTestCase): # R710
+class TestLevel3Expr(NumpyTestCase): # R710
 
     def check_simple(self):
         cls = Level_3_Expr
@@ -1544,7 +1544,7 @@
         assert isinstance(a,cls),`a`
         assert_equal(str(a),'"a" // "b"')
 
-class test_Level_4_Expr(NumpyTestCase): # R712
+class TestLevel4Expr(NumpyTestCase): # R712
 
     def check_simple(self):
         cls = Level_4_Expr
@@ -1593,7 +1593,7 @@
         assert isinstance(a,cls),`a`
         assert_equal(str(a),'a > b')
 
-class test_And_Operand(NumpyTestCase): # R714
+class TestAndOperand(NumpyTestCase): # R714
 
     def check_simple(self):
         cls = And_Operand
@@ -1602,7 +1602,7 @@
         assert_equal(str(a),'.NOT. a')
         assert_equal(repr(a),"And_Operand('.NOT.', Name('a'))")
 
-class test_Or_Operand(NumpyTestCase): # R715
+class TestOrOperand(NumpyTestCase): # R715
 
     def check_simple(self):
         cls = Or_Operand
@@ -1612,7 +1612,7 @@
         assert_equal(repr(a),"Or_Operand(Name('a'), '.AND.', Name('b'))")
 
 
-class test_Equiv_Operand(NumpyTestCase): # R716
+class TestEquivOperand(NumpyTestCase): # R716
 
     def check_simple(self):
         cls = Equiv_Operand
@@ -1622,7 +1622,7 @@
         assert_equal(repr(a),"Equiv_Operand(Name('a'), '.OR.', Name('b'))")
 
 
-class test_Level_5_Expr(NumpyTestCase): # R717
+class TestLevel5Expr(NumpyTestCase): # R717
 
     def check_simple(self):
         cls = Level_5_Expr
@@ -1639,7 +1639,7 @@
         assert isinstance(a,Level_4_Expr),`a`
         assert_equal(str(a),'a .EQ. b')
 
-class test_Expr(NumpyTestCase): # R722
+class TestExpr(NumpyTestCase): # R722
 
     def check_simple(self):
         cls = Expr
@@ -1661,7 +1661,7 @@
 
         self.assertRaises(NoMatchError,Scalar_Int_Expr,'a,b')
 
-class test_Assignment_Stmt(NumpyTestCase): # R734
+class TestAssignmentStmt(NumpyTestCase): # R734
 
     def check_simple(self):
         cls = Assignment_Stmt
@@ -1678,7 +1678,7 @@
         assert isinstance(a, cls),`a`
         assert_equal(str(a),'a % c = b + c')
 
-class test_Proc_Component_Ref(NumpyTestCase): # R741
+class TestProcComponentRef(NumpyTestCase): # R741
 
     def check_proc_component_ref(self):
         cls = Proc_Component_Ref
@@ -1687,7 +1687,7 @@
         assert_equal(str(a),'a % b')
         assert_equal(repr(a),"Proc_Component_Ref(Name('a'), '%', Name('b'))")
 
-class test_Where_Stmt(NumpyTestCase): # R743
+class TestWhereStmt(NumpyTestCase): # R743
 
     def check_simple(self):
         cls = Where_Stmt
@@ -1696,7 +1696,7 @@
         assert_equal(str(a),'WHERE (a) c = 2')
         assert_equal(repr(a),"Where_Stmt(Name('a'), Assignment_Stmt(Name('c'), '=', Int_Literal_Constant('2', None)))")
 
-class test_Where_Construct_Stmt(NumpyTestCase): # R745
+class TestWhereConstructStmt(NumpyTestCase): # R745
 
     def check_simple(self):
         cls = Where_Construct_Stmt
@@ -1710,7 +1710,7 @@
 ############################### SECTION  8 ####################################
 ###############################################################################
 
-class test_Continue_Stmt(NumpyTestCase): # R848
+class TestContinueStmt(NumpyTestCase): # R848
 
     def check_simple(self):
         cls = Continue_Stmt
@@ -1723,7 +1723,7 @@
 ############################### SECTION  9 ####################################
 ###############################################################################
 
-class test_Io_Unit(NumpyTestCase): # R901
+class TestIoUnit(NumpyTestCase): # R901
 
     def check_simple(self):
         cls = Io_Unit
@@ -1735,7 +1735,7 @@
         assert isinstance(a, Name),`a`
         assert_equal(str(a),'a')
 
-class test_Write_Stmt(NumpyTestCase): # R911
+class TestWriteStmt(NumpyTestCase): # R911
 
     def check_simple(self):
         cls = Write_Stmt
@@ -1744,7 +1744,7 @@
         assert_equal(str(a),'WRITE(UNIT = 123) "hey"')
         assert_equal(repr(a),'Write_Stmt(Io_Control_Spec_List(\',\', (Io_Control_Spec(\'UNIT\', Int_Literal_Constant(\'123\', None)),)), Char_Literal_Constant(\'"hey"\', None))')
 
-class test_Print_Stmt(NumpyTestCase): # R912
+class TestPrintStmt(NumpyTestCase): # R912
 
     def check_simple(self):
         cls = Print_Stmt
@@ -1757,7 +1757,7 @@
         assert isinstance(a, cls),`a`
         assert_equal(str(a),'PRINT *, "a=", a')
 
-class test_Io_Control_Spec(NumpyTestCase): # R913
+class TestIoControlSpec(NumpyTestCase): # R913
 
     def check_simple(self):
         cls = Io_Control_Spec
@@ -1766,7 +1766,7 @@
         assert_equal(str(a),'END = 123')
         assert_equal(repr(a),"Io_Control_Spec('END', Label('123'))")
 
-class test_Io_Control_Spec_List(NumpyTestCase): # R913-list
+class TestIoControlSpecList(NumpyTestCase): # R913-list
 
     def check_simple(self):
         cls = Io_Control_Spec_List
@@ -1793,7 +1793,7 @@
             assert isinstance(a, cls),`a`
             assert_equal(str(a),'UNIT = 123, NML = a')
 
-class test_Format(NumpyTestCase): # R914
+class TestFormat(NumpyTestCase): # R914
 
     def check_simple(self):
         cls = Format
@@ -1810,7 +1810,7 @@
         assert isinstance(a, Label),`a`
         assert_equal(str(a),'123')
 
-class test_Wait_Stmt(NumpyTestCase): # R921
+class TestWaitStmt(NumpyTestCase): # R921
 
     def check_simple(self):
         cls = Wait_Stmt
@@ -1818,7 +1818,7 @@
         assert isinstance(a, cls),`a`
         assert_equal(str(a),'WAIT(UNIT = 123)')
 
-class test_Wait_Spec(NumpyTestCase): # R922
+class TestWaitSpec(NumpyTestCase): # R922
 
     def check_simple(self):
         cls = Wait_Spec
@@ -1840,7 +1840,7 @@
 ############################### SECTION 11 ####################################
 ###############################################################################
 
-class test_Use_Stmt(NumpyTestCase): # R1109
+class TestUseStmt(NumpyTestCase): # R1109
 
     def check_simple(self):
         cls = Use_Stmt
@@ -1861,7 +1861,7 @@
         assert isinstance(a, cls),`a`
         assert_equal(str(a),'USE, INTRINSIC :: a, OPERATOR(.HEY.) => OPERATOR(.HOO.), c => g')
 
-class test_Module_Nature(NumpyTestCase): # R1110
+class TestModuleNature(NumpyTestCase): # R1110
 
     def check_simple(self):
         cls = Module_Nature
@@ -1878,7 +1878,7 @@
 ############################### SECTION 12 ####################################
 ###############################################################################
 
-class test_Function_Reference(NumpyTestCase): # R1217
+class TestFunctionReference(NumpyTestCase): # R1217
 
     def check_simple(self):
         cls = Function_Reference
@@ -1892,7 +1892,7 @@
         assert_equal(str(a),'f(2, k = 1, a)')
 
 
-class test_Procedure_Designator(NumpyTestCase): # R1219
+class TestProcedureDesignator(NumpyTestCase): # R1219
 
     def check_procedure_designator(self):
         cls = Procedure_Designator
@@ -1901,7 +1901,7 @@
         assert_equal(str(a),'a % b')
         assert_equal(repr(a),"Procedure_Designator(Name('a'), '%', Name('b'))")
 
-class test_Actual_Arg_Spec(NumpyTestCase): # R1220
+class TestActualArgSpec(NumpyTestCase): # R1220
 
     def check_simple(self):
         cls = Actual_Arg_Spec
@@ -1914,7 +1914,7 @@
         assert isinstance(a,Name),`a`
         assert_equal(str(a),'a')
 
-class test_Actual_Arg_Spec_List(NumpyTestCase):
+class TestActualArgSpecList(NumpyTestCase):
 
     def check_simple(self):
         cls = Actual_Arg_Spec_List
@@ -1935,7 +1935,7 @@
         assert isinstance(a,Name),`a`
         assert_equal(str(a),'a')
 
-class test_Alt_Return_Spec(NumpyTestCase): # R1222
+class TestAltReturnSpec(NumpyTestCase): # R1222
 
     def check_alt_return_spec(self):
         cls = Alt_Return_Spec
@@ -1944,7 +1944,7 @@
         assert_equal(str(a),'*123')
         assert_equal(repr(a),"Alt_Return_Spec(Label('123'))")
 
-class test_Prefix(NumpyTestCase): # R1227
+class TestPrefix(NumpyTestCase): # R1227
 
     def check_simple(self):
         cls = Prefix
@@ -1957,7 +1957,7 @@
         assert isinstance(a, cls),`a`
         assert_equal(str(a),'INTEGER*2 PURE')
 
-class test_Prefix_Spec(NumpyTestCase): # R1228
+class TestPrefixSpec(NumpyTestCase): # R1228
 
     def check_simple(self):
         cls = Prefix_Spec
@@ -1978,7 +1978,7 @@
         assert isinstance(a, Intrinsic_Type_Spec),`a`
         assert_equal(str(a),'INTEGER*2')
 
-class test_Subroutine_Subprogram(NumpyTestCase): # R1231
+class TestSubroutineSubprogram(NumpyTestCase): # R1231
 
     def check_simple(self):
         from api import get_reader
@@ -2000,7 +2000,7 @@
         assert isinstance(a, cls),`a`
         assert_equal(str(a),'SUBROUTINE foo\n  INTEGER :: a\nEND SUBROUTINE foo')
 
-class test_Subroutine_Stmt(NumpyTestCase): # R1232
+class TestSubroutineStmt(NumpyTestCase): # R1232
 
     def check_simple(self):
         cls = Subroutine_Stmt
@@ -2021,7 +2021,7 @@
         assert isinstance(a, cls),`a`
         assert_equal(str(a),'SUBROUTINE foo BIND(C)')
 
-class test_End_Subroutine_Stmt(NumpyTestCase): # R1234
+class TestEndSubroutineStmt(NumpyTestCase): # R1234
 
     def check_simple(self):
         cls = End_Subroutine_Stmt
@@ -2038,7 +2038,7 @@
         assert isinstance(a, cls),`a`
         assert_equal(str(a),'END SUBROUTINE')
 
-class test_Return_Stmt(NumpyTestCase): # R1236
+class TestReturnStmt(NumpyTestCase): # R1236
 
     def check_simple(self):
         cls = Return_Stmt
@@ -2047,7 +2047,7 @@
         assert_equal(str(a), 'RETURN')
         assert_equal(repr(a), 'Return_Stmt(None)')
 
-class test_Contains(NumpyTestCase): # R1237
+class TestContains(NumpyTestCase): # R1237
 
     def check_simple(self):
         cls = Contains_Stmt

Modified: trunk/numpy/f2py/lib/parser/test_parser.py
===================================================================
--- trunk/numpy/f2py/lib/parser/test_parser.py	2007-10-02 07:32:06 UTC (rev 4150)
+++ trunk/numpy/f2py/lib/parser/test_parser.py	2007-10-02 07:54:11 UTC (rev 4151)
@@ -34,7 +34,7 @@
         return r
     raise ValueError, 'parsing %r with %s pattern failed' % (line, cls.__name__)
 
-class test_Statements(NumpyTestCase):
+class TestStatements(NumpyTestCase):
 
     def check_assignment(self):
         assert_equal(parse(Assignment,'a=b'), 'a = b')

Modified: trunk/numpy/f2py/lib/tests/test_derived_scalar.py
===================================================================
--- trunk/numpy/f2py/lib/tests/test_derived_scalar.py	2007-10-02 07:32:06 UTC (rev 4150)
+++ trunk/numpy/f2py/lib/tests/test_derived_scalar.py	2007-10-02 07:54:11 UTC (rev 4151)
@@ -42,7 +42,7 @@
 
 from numpy import *
 
-class test_m(NumpyTestCase):
+class TestM(NumpyTestCase):
 
     def check_foo_simple(self, level=1):
         a = m.myt(2)

Modified: trunk/numpy/f2py/lib/tests/test_module_module.py
===================================================================
--- trunk/numpy/f2py/lib/tests/test_module_module.py	2007-10-02 07:32:06 UTC (rev 4150)
+++ trunk/numpy/f2py/lib/tests/test_module_module.py	2007-10-02 07:54:11 UTC (rev 4151)
@@ -51,7 +51,7 @@
 
 from numpy import *
 
-class test_m(NumpyTestCase):
+class TestM(NumpyTestCase):
 
     def check_foo_simple(self, level=1):
         foo = m.foo

Modified: trunk/numpy/f2py/lib/tests/test_module_scalar.py
===================================================================
--- trunk/numpy/f2py/lib/tests/test_module_scalar.py	2007-10-02 07:32:06 UTC (rev 4150)
+++ trunk/numpy/f2py/lib/tests/test_module_scalar.py	2007-10-02 07:54:11 UTC (rev 4151)
@@ -40,7 +40,7 @@
 
 from numpy import *
 
-class test_m(NumpyTestCase):
+class TestM(NumpyTestCase):
 
     def check_foo_simple(self, level=1):
         foo = m.foo

Modified: trunk/numpy/f2py/lib/tests/test_scalar_function_in.py
===================================================================
--- trunk/numpy/f2py/lib/tests/test_scalar_function_in.py	2007-10-02 07:32:06 UTC (rev 4150)
+++ trunk/numpy/f2py/lib/tests/test_scalar_function_in.py	2007-10-02 07:54:11 UTC (rev 4151)
@@ -107,7 +107,7 @@
 
 from numpy import *
 
-class test_m(NumpyTestCase):
+class TestM(NumpyTestCase):
 
     def check_foo_integer1(self, level=1):
         i = int8(2)

Modified: trunk/numpy/f2py/lib/tests/test_scalar_in_out.py
===================================================================
--- trunk/numpy/f2py/lib/tests/test_scalar_in_out.py	2007-10-02 07:32:06 UTC (rev 4150)
+++ trunk/numpy/f2py/lib/tests/test_scalar_in_out.py	2007-10-02 07:54:11 UTC (rev 4151)
@@ -104,7 +104,7 @@
 
 from numpy import *
 
-class test_m(NumpyTestCase):
+class TestM(NumpyTestCase):
 
     def check_foo_integer1(self, level=1):
         i = int8(2)

Modified: trunk/numpy/fft/tests/test_fftpack.py
===================================================================
--- trunk/numpy/fft/tests/test_fftpack.py	2007-10-02 07:32:06 UTC (rev 4150)
+++ trunk/numpy/fft/tests/test_fftpack.py	2007-10-02 07:54:11 UTC (rev 4151)
@@ -4,7 +4,7 @@
 from numpy.fft import *
 restore_path()
 
-class test_fftshift(NumpyTestCase):
+class TestFFTShift(NumpyTestCase):
     def check_fft_n(self):
         self.failUnlessRaises(ValueError,fft,[1,2,3],0)
 

Modified: trunk/numpy/fft/tests/test_helper.py
===================================================================
--- trunk/numpy/fft/tests/test_helper.py	2007-10-02 07:32:06 UTC (rev 4150)
+++ trunk/numpy/fft/tests/test_helper.py	2007-10-02 07:54:11 UTC (rev 4151)
@@ -14,7 +14,7 @@
 def random(size):
     return rand(*size)
 
-class test_fftshift(NumpyTestCase):
+class TestFFTShift(NumpyTestCase):
 
     def check_definition(self):
         x = [0,1,2,3,4,-4,-3,-2,-1]
@@ -31,7 +31,7 @@
             x = random((n,))
             assert_array_almost_equal(ifftshift(fftshift(x)),x)
 
-class test_fftfreq(NumpyTestCase):
+class TestFFTFreq(NumpyTestCase):
 
     def check_definition(self):
         x = [0,1,2,3,4,-4,-3,-2,-1]

Modified: trunk/numpy/lib/tests/test_arraysetops.py
===================================================================
--- trunk/numpy/lib/tests/test_arraysetops.py	2007-10-02 07:32:06 UTC (rev 4150)
+++ trunk/numpy/lib/tests/test_arraysetops.py	2007-10-02 07:54:11 UTC (rev 4151)
@@ -11,7 +11,7 @@
 
 ##################################################
 
-class test_aso(NumpyTestCase):
+class TestAso(NumpyTestCase):
     ##
     # 03.11.2005, c
     def check_unique1d( self ):

Modified: trunk/numpy/lib/tests/test_function_base.py
===================================================================
--- trunk/numpy/lib/tests/test_function_base.py	2007-10-02 07:32:06 UTC (rev 4150)
+++ trunk/numpy/lib/tests/test_function_base.py	2007-10-02 07:54:11 UTC (rev 4151)
@@ -7,7 +7,7 @@
 from numpy.core import *
 del sys.path[0]
 
-class test_any(NumpyTestCase):
+class TestAny(NumpyTestCase):
     def check_basic(self):
         y1 = [0,0,1,0]
         y2 = [0,0,0,0]
@@ -22,7 +22,7 @@
         assert_array_equal(sometrue(y1,axis=0),[1,1,0])
         assert_array_equal(sometrue(y1,axis=1),[0,1,1])
 
-class test_all(NumpyTestCase):
+class TestAll(NumpyTestCase):
     def check_basic(self):
         y1 = [0,1,1,0]
         y2 = [0,0,0,0]
@@ -38,7 +38,7 @@
         assert_array_equal(alltrue(y1,axis=0),[0,0,1])
         assert_array_equal(alltrue(y1,axis=1),[0,0,1])
 
-class test_average(NumpyTestCase):
+class TestAverage(NumpyTestCase):
     def check_basic(self):
         y1 = array([1,2,3])
         assert(average(y1,axis=0) == 2.)
@@ -64,7 +64,7 @@
         desired = array([3.,4.,5.])
         assert_array_equal(actual, desired)
 
-class test_select(NumpyTestCase):
+class TestSelect(NumpyTestCase):
     def _select(self,cond,values,default=0):
         output = []
         for m in range(len(cond)):
@@ -84,7 +84,7 @@
         assert_equal(len(choices),3)
         assert_equal(len(conditions),3)
 
-class test_logspace(NumpyTestCase):
+class TestLogspace(NumpyTestCase):
     def check_basic(self):
         y = logspace(0,6)
         assert(len(y)==50)
@@ -95,7 +95,7 @@
         y = logspace(0,6,num=7)
         assert_array_equal(y,[1,10,100,1e3,1e4,1e5,1e6])
 
-class test_linspace(NumpyTestCase):
+class TestLinspace(NumpyTestCase):
     def check_basic(self):
         y = linspace(0,10)
         assert(len(y)==50)
@@ -120,14 +120,14 @@
         assert_equal(t1, t2)
         assert_equal(t2, t3)
 
-class test_insert(NumpyTestCase):
+class TestInsert(NumpyTestCase):
     def check_basic(self):
         a = [1,2,3]
         assert_equal(insert(a,0,1), [1,1,2,3])
         assert_equal(insert(a,3,1), [1,2,3,1])
         assert_equal(insert(a,[1,1,1],[1,2,3]), [1,1,2,3,2,3])
 
-class test_amax(NumpyTestCase):
+class TestAmax(NumpyTestCase):
     def check_basic(self):
         a = [3,4,5,10,-3,-5,6.0]
         assert_equal(amax(a),10.0)
@@ -137,7 +137,7 @@
         assert_equal(amax(b,axis=0),[8.0,10.0,9.0])
         assert_equal(amax(b,axis=1),[9.0,10.0,8.0])
 
-class test_amin(NumpyTestCase):
+class TestAmin(NumpyTestCase):
     def check_basic(self):
         a = [3,4,5,10,-3,-5,6.0]
         assert_equal(amin(a),-5.0)
@@ -147,7 +147,7 @@
         assert_equal(amin(b,axis=0),[3.0,3.0,2.0])
         assert_equal(amin(b,axis=1),[3.0,4.0,2.0])
 
-class test_ptp(NumpyTestCase):
+class TestPtp(NumpyTestCase):
     def check_basic(self):
         a = [3,4,5,10,-3,-5,6.0]
         assert_equal(ptp(a,axis=0),15.0)
@@ -157,7 +157,7 @@
         assert_equal(ptp(b,axis=0),[5.0,7.0,7.0])
         assert_equal(ptp(b,axis=-1),[6.0,6.0,6.0])
 
-class test_cumsum(NumpyTestCase):
+class TestCumsum(NumpyTestCase):
     def check_basic(self):
         ba = [1,2,10,11,6,5,4]
         ba2 = [[1,2,3,4],[5,6,7,9],[10,3,4,5]]
@@ -173,7 +173,7 @@
                                       [5,11,18,27],
                                       [10,13,17,22]],ctype))
 
-class test_prod(NumpyTestCase):
+class TestProd(NumpyTestCase):
     def check_basic(self):
         ba = [1,2,10,11,6,5,4]
         ba2 = [[1,2,3,4],[5,6,7,9],[10,3,4,5]]
@@ -191,7 +191,7 @@
                                    array([50,36,84,180],ctype))
                 assert_array_equal(prod(a2,axis=-1),array([24, 1890, 600],ctype))
 
-class test_cumprod(NumpyTestCase):
+class TestCumprod(NumpyTestCase):
     def check_basic(self):
         ba = [1,2,10,11,6,5,4]
         ba2 = [[1,2,3,4],[5,6,7,9],[10,3,4,5]]
@@ -216,7 +216,7 @@
                                           [ 5, 30, 210, 1890],
                                           [10, 30, 120,  600]],ctype))
 
-class test_diff(NumpyTestCase):
+class TestDiff(NumpyTestCase):
     def check_basic(self):
         x = [1,4,6,7,12]
         out = array([3,2,1,5])
@@ -237,7 +237,7 @@
         assert_array_equal(diff(x,axis=0),out3)
         assert_array_equal(diff(x,n=2,axis=0),out4)
 
-class test_angle(NumpyTestCase):
+class TestAngle(NumpyTestCase):
     def check_basic(self):
         x = [1+3j,sqrt(2)/2.0+1j*sqrt(2)/2,1,1j,-1,-1j,1-3j,-1+3j]
         y = angle(x)
@@ -248,7 +248,7 @@
         assert_array_almost_equal(y,yo,11)
         assert_array_almost_equal(z,zo,11)
 
-class test_trim_zeros(NumpyTestCase):
+class TestTrimZeros(NumpyTestCase):
     """ only testing for integer splits.
     """
     def check_basic(self):
@@ -265,7 +265,7 @@
         assert_array_equal(res,array([1,0,2,3,0,4]))
 
 
-class test_extins(NumpyTestCase):
+class TestExtins(NumpyTestCase):
     def check_basic(self):
         a = array([1,3,2,1,2,3,3])
         b = extract(a>1,a)
@@ -283,7 +283,7 @@
         place(a,mask,c)
         assert_array_equal(a,ac)
 
-class test_vectorize(NumpyTestCase):
+class TestVectorize(NumpyTestCase):
     def check_simple(self):
         def addsubtract(a,b):
             if a > b:
@@ -308,7 +308,7 @@
         y = f(x)
         assert_array_equal(y, x)
 
-class test_digitize(NumpyTestCase):
+class TestDigitize(NumpyTestCase):
     def check_forward(self):
         x = arange(-6,5)
         bins = arange(-5,5)
@@ -324,7 +324,7 @@
         bin = linspace(x.min(), x.max(), 10)
         assert all(digitize(x,bin) != 0)
 
-class test_unwrap(NumpyTestCase):
+class TestUnwrap(NumpyTestCase):
     def check_simple(self):
                 #check that unwrap removes jumps greather that 2*pi
         assert_array_equal(unwrap([1,1+2*pi]),[1,1])
@@ -332,7 +332,7 @@
         assert(all(diff(unwrap(rand(10)*100))<pi))
 
 
-class test_filterwindows(NumpyTestCase):
+class TestFilterwindows(NumpyTestCase):
     def check_hanning(self):
         #check symmetry
         w=hanning(10)
@@ -362,20 +362,20 @@
         assert_almost_equal(sum(w,axis=0),3.7800,4)
 
 
-class test_trapz(NumpyTestCase):
+class TestTrapz(NumpyTestCase):
     def check_simple(self):
         r=trapz(exp(-1.0/2*(arange(-10,10,.1))**2)/sqrt(2*pi),dx=0.1)
         #check integral of normal equals 1
         assert_almost_equal(sum(r,axis=0),1,7)
 
-class test_sinc(NumpyTestCase):
+class TestSinc(NumpyTestCase):
     def check_simple(self):
         assert(sinc(0)==1)
         w=sinc(linspace(-1,1,100))
         #check symmetry
         assert_array_almost_equal(w,flipud(w),7)
 
-class test_histogram(NumpyTestCase):
+class TestHistogram(NumpyTestCase):
     def check_simple(self):
         n=100
         v=rand(n)
@@ -386,7 +386,7 @@
         (a,b)=histogram(linspace(0,10,100))
         assert(all(a==10))
 
-class test_histogramdd(NumpyTestCase):
+class TestHistogramdd(NumpyTestCase):
     def check_simple(self):
         x = array([[-.5, .5, 1.5], [-.5, 1.5, 2.5], [-.5, 2.5, .5], \
         [.5, .5, 1.5], [.5, 1.5, 2.5], [.5, 2.5, 2.5]])
@@ -436,7 +436,7 @@
         hist, edges = histogramdd(x, bins=2)
         assert_array_equal(edges[0],array([-0.5,  0. ,  0.5]))
 
-class test_unique(NumpyTestCase):
+class TestUnique(NumpyTestCase):
     def check_simple(self):
         x = array([4,3,2,1,1,2,3,4, 0])
         assert(all(unique(x) == [0,1,2,3,4]))

Modified: trunk/numpy/lib/tests/test_getlimits.py
===================================================================
--- trunk/numpy/lib/tests/test_getlimits.py	2007-10-02 07:32:06 UTC (rev 4150)
+++ trunk/numpy/lib/tests/test_getlimits.py	2007-10-02 07:54:11 UTC (rev 4151)
@@ -11,31 +11,31 @@
 
 ##################################################
 
-class test_python_float(NumpyTestCase):
+class TestPythonFloat(NumpyTestCase):
     def check_singleton(self):
         ftype = finfo(float)
         ftype2 = finfo(float)
         assert_equal(id(ftype),id(ftype2))
 
-class test_single(NumpyTestCase):
+class TestSingle(NumpyTestCase):
     def check_singleton(self):
         ftype = finfo(single)
         ftype2 = finfo(single)
         assert_equal(id(ftype),id(ftype2))
 
-class test_double(NumpyTestCase):
+class TestDouble(NumpyTestCase):
     def check_singleton(self):
         ftype = finfo(double)
         ftype2 = finfo(double)
         assert_equal(id(ftype),id(ftype2))
 
-class test_longdouble(NumpyTestCase):
+class TestLongdouble(NumpyTestCase):
     def check_singleton(self,level=2):
         ftype = finfo(longdouble)
         ftype2 = finfo(longdouble)
         assert_equal(id(ftype),id(ftype2))
 
-class test_iinfo(NumpyTestCase):
+class TestIinfo(NumpyTestCase):
     def check_basic(self):
         dts = zip(['i1', 'i2', 'i4', 'i8',
                    'u1', 'u2', 'u4', 'u8'],

Modified: trunk/numpy/lib/tests/test_index_tricks.py
===================================================================
--- trunk/numpy/lib/tests/test_index_tricks.py	2007-10-02 07:32:06 UTC (rev 4150)
+++ trunk/numpy/lib/tests/test_index_tricks.py	2007-10-02 07:54:11 UTC (rev 4151)
@@ -3,7 +3,7 @@
 from numpy import array, ones, r_, mgrid
 restore_path()
 
-class test_grid(NumpyTestCase):
+class TestGrid(NumpyTestCase):
     def check_basic(self):
         a = mgrid[-1:1:10j]
         b = mgrid[-1:1:0.1]
@@ -28,7 +28,7 @@
         assert_array_almost_equal(d[0,1,:]-d[0,0,:], 0.1*ones(20,'d'),11)
         assert_array_almost_equal(d[1,:,1]-d[1,:,0], 0.2*ones(20,'d'),11)
 
-class test_concatenator(NumpyTestCase):
+class TestConcatenator(NumpyTestCase):
     def check_1d(self):
         assert_array_equal(r_[1,2,3,4,5,6],array([1,2,3,4,5,6]))
         b = ones(5)

Modified: trunk/numpy/lib/tests/test_polynomial.py
===================================================================
--- trunk/numpy/lib/tests/test_polynomial.py	2007-10-02 07:32:06 UTC (rev 4150)
+++ trunk/numpy/lib/tests/test_polynomial.py	2007-10-02 07:54:11 UTC (rev 4151)
@@ -76,7 +76,7 @@
 from numpy.testing import *
 import numpy as N
 
-class test_docs(NumpyTestCase):
+class TestDocs(NumpyTestCase):
     def check_doctests(self): return self.rundocs()
 
     def check_roots(self):

Modified: trunk/numpy/lib/tests/test_shape_base.py
===================================================================
--- trunk/numpy/lib/tests/test_shape_base.py	2007-10-02 07:32:06 UTC (rev 4150)
+++ trunk/numpy/lib/tests/test_shape_base.py	2007-10-02 07:54:11 UTC (rev 4151)
@@ -5,7 +5,7 @@
 from numpy.core import *
 restore_path()
 
-class test_apply_along_axis(NumpyTestCase):
+class TestApplyAlongAxis(NumpyTestCase):
     def check_simple(self):
         a = ones((20,10),'d')
         assert_array_equal(apply_along_axis(len,0,a),len(a)*ones(shape(a)[1]))
@@ -17,7 +17,7 @@
         a = arange(27).reshape((3,3,3))
         assert_array_equal(apply_along_axis(sum,0,a), [[27,30,33],[36,39,42],[45,48,51]])
 
-class test_array_split(NumpyTestCase):
+class TestArraySplit(NumpyTestCase):
     def check_integer_0_split(self):
         a = arange(10)
         try:
@@ -120,7 +120,7 @@
                    array([]),array([])]
         compare_results(res,desired)
 
-class test_split(NumpyTestCase):
+class TestSplit(NumpyTestCase):
     """* This function is essentially the same as array_split,
          except that it test if splitting will result in an
          equal split.  Only test for this case.
@@ -139,7 +139,7 @@
         except ValueError:
             pass
 
-class test_atleast_1d(NumpyTestCase):
+class TestAtleast1d(NumpyTestCase):
     def check_0D_array(self):
         a = array(1); b = array(2);
         res=map(atleast_1d,[a,b])
@@ -170,7 +170,7 @@
         assert(atleast_1d(3.0).shape == (1,))
         assert(atleast_1d([[2,3],[4,5]]).shape == (2,2))
 
-class test_atleast_2d(NumpyTestCase):
+class TestAtleast2d(NumpyTestCase):
     def check_0D_array(self):
         a = array(1); b = array(2);
         res=map(atleast_2d,[a,b])
@@ -199,7 +199,7 @@
         assert(atleast_2d([3j,1]).shape == (1,2))
         assert(atleast_2d([[[3,1],[4,5]],[[3,5],[1,2]]]).shape == (2,2,2))
 
-class test_atleast_3d(NumpyTestCase):
+class TestAtleast3d(NumpyTestCase):
     def check_0D_array(self):
         a = array(1); b = array(2);
         res=map(atleast_3d,[a,b])
@@ -222,7 +222,7 @@
         desired = [a,b]
         assert_array_equal(res,desired)
 
-class test_hstack(NumpyTestCase):
+class TestHstack(NumpyTestCase):
     def check_0D_array(self):
         a = array(1); b = array(2);
         res=hstack([a,b])
@@ -239,7 +239,7 @@
         desired = array([[1,1],[2,2]])
         assert_array_equal(res,desired)
 
-class test_vstack(NumpyTestCase):
+class TestVstack(NumpyTestCase):
     def check_0D_array(self):
         a = array(1); b = array(2);
         res=vstack([a,b])
@@ -261,7 +261,7 @@
         desired = array([[1,2],[1,2]])
         assert_array_equal(res,desired)
 
-class test_dstack(NumpyTestCase):
+class TestDstack(NumpyTestCase):
     def check_0D_array(self):
         a = array(1); b = array(2);
         res=dstack([a,b])
@@ -286,7 +286,7 @@
 """ array_split has more comprehensive test of splitting.
     only do simple test on hsplit, vsplit, and dsplit
 """
-class test_hsplit(NumpyTestCase):
+class TestHsplit(NumpyTestCase):
     """ only testing for integer splits.
     """
     def check_0D_array(self):
@@ -308,7 +308,7 @@
         desired = [array([[1,2],[1,2]]),array([[3,4],[3,4]])]
         compare_results(res,desired)
 
-class test_vsplit(NumpyTestCase):
+class TestVsplit(NumpyTestCase):
     """ only testing for integer splits.
     """
     def check_1D_array(self):
@@ -325,7 +325,7 @@
         desired = [array([[1,2,3,4]]),array([[1,2,3,4]])]
         compare_results(res,desired)
 
-class test_dsplit(NumpyTestCase):
+class TestDsplit(NumpyTestCase):
     """ only testing for integer splits.
     """
     def check_2D_array(self):
@@ -346,7 +346,7 @@
                    array([[[3,4],[3,4]],[[3,4],[3,4]]])]
         compare_results(res,desired)
 
-class test_squeeze(NumpyTestCase):
+class TestSqueeze(NumpyTestCase):
     def check_basic(self):
         a = rand(20,10,10,1,1)
         b = rand(20,1,10,1,20)
@@ -355,7 +355,7 @@
         assert_array_equal(squeeze(b),reshape(b,(20,10,20)))
         assert_array_equal(squeeze(c),reshape(c,(20,10)))
 
-class test_kron(NumpyTestCase):
+class TestKron(NumpyTestCase):
     def check_return_type(self):
         a = ones([2,2])
         m = asmatrix(a)
@@ -372,7 +372,7 @@
         assert_equal(type(kron(ma,a)), myarray)
 
 
-class test_tile(NumpyTestCase):
+class TestTile(NumpyTestCase):
     def check_basic(self):
         a = array([0,1,2])
         b = [[1,2],[3,4]]

Modified: trunk/numpy/lib/tests/test_twodim_base.py
===================================================================
--- trunk/numpy/lib/tests/test_twodim_base.py	2007-10-02 07:32:06 UTC (rev 4150)
+++ trunk/numpy/lib/tests/test_twodim_base.py	2007-10-02 07:54:11 UTC (rev 4151)
@@ -17,7 +17,7 @@
     data = add.outer(data,data)
     return data
 
-class test_eye(NumpyTestCase):
+class TestEye(NumpyTestCase):
     def check_basic(self):
         assert_equal(eye(4),array([[1,0,0,0],
                                    [0,1,0,0],
@@ -55,7 +55,7 @@
                                           [1,0,0],
                                           [0,1,0]]))
 
-class test_diag(NumpyTestCase):
+class TestDiag(NumpyTestCase):
     def check_vector(self):
         vals = (100*arange(5)).astype('l')
         b = zeros((5,5))
@@ -84,7 +84,7 @@
             b[k] = vals[k+2,k]
         assert_equal(diag(vals,-2),b[:3])
 
-class test_fliplr(NumpyTestCase):
+class TestFliplr(NumpyTestCase):
     def check_basic(self):
         self.failUnlessRaises(ValueError, fliplr, ones(4))
         a = get_mat(4)
@@ -96,7 +96,7 @@
              [5,4,3]]
         assert_equal(fliplr(a),b)
 
-class test_flipud(NumpyTestCase):
+class TestFlipud(NumpyTestCase):
     def check_basic(self):
         a = get_mat(4)
         b = a[::-1,:]
@@ -107,7 +107,7 @@
              [0,1,2]]
         assert_equal(flipud(a),b)
 
-class test_rot90(NumpyTestCase):
+class TestRot90(NumpyTestCase):
     def check_basic(self):
         self.failUnlessRaises(ValueError, rot90, ones(4))
 
@@ -137,7 +137,7 @@
         a = ones((50,40,3))
         assert_equal(rot90(a).shape,(40,50,3))
 
-class test_histogram2d(NumpyTestCase):
+class TestHistogram2d(NumpyTestCase):
     def check_simple(self):
         x = array([ 0.41702200,  0.72032449,  0.00011437481, 0.302332573,  0.146755891])
         y = array([ 0.09233859,  0.18626021,  0.34556073,  0.39676747,  0.53881673])
@@ -188,7 +188,7 @@
         H, xed, yed = histogram2d(r, r, (4, 5), range=([0,1], [0,1]))
         assert_array_equal(H, 0)
 
-class test_tri(NumpyTestCase):
+class TestTri(NumpyTestCase):
     def test_dtype(self):
         out = array([[1,0,0],
                      [1,1,0],

Modified: trunk/numpy/lib/tests/test_type_check.py
===================================================================
--- trunk/numpy/lib/tests/test_type_check.py	2007-10-02 07:32:06 UTC (rev 4150)
+++ trunk/numpy/lib/tests/test_type_check.py	2007-10-02 07:54:11 UTC (rev 4151)
@@ -10,7 +10,7 @@
 def assert_all(x):
     assert(all(x)), x
 
-class test_mintypecode(NumpyTestCase):
+class TestMintypecode(NumpyTestCase):
 
     def check_default_1(self):
         for itype in '1bcsuwil':
@@ -59,7 +59,7 @@
         #assert_equal(mintypecode('idF',savespace=1),'F')
         assert_equal(mintypecode('idD'),'D')
 
-class test_isscalar(NumpyTestCase):
+class TestIsscalar(NumpyTestCase):
     def check_basic(self):
         assert(isscalar(3))
         assert(not isscalar([3]))
@@ -68,7 +68,7 @@
         assert(isscalar(10L))
         assert(isscalar(4.0))
 
-class test_real(NumpyTestCase):
+class TestReal(NumpyTestCase):
     def check_real(self):
         y = rand(10,)
         assert_array_equal(y,real(y))
@@ -77,7 +77,7 @@
         y = rand(10,)+1j*rand(10,)
         assert_array_equal(y.real,real(y))
 
-class test_imag(NumpyTestCase):
+class TestImag(NumpyTestCase):
     def check_real(self):
         y = rand(10,)
         assert_array_equal(0,imag(y))
@@ -86,7 +86,7 @@
         y = rand(10,)+1j*rand(10,)
         assert_array_equal(y.imag,imag(y))
 
-class test_iscomplex(NumpyTestCase):
+class TestIscomplex(NumpyTestCase):
     def check_fail(self):
         z = array([-1,0,1])
         res = iscomplex(z)
@@ -96,7 +96,7 @@
         res = iscomplex(z)
         assert_array_equal(res,[1,0,0])
 
-class test_isreal(NumpyTestCase):
+class TestIsreal(NumpyTestCase):
     def check_pass(self):
         z = array([-1,0,1j])
         res = isreal(z)
@@ -106,21 +106,21 @@
         res = isreal(z)
         assert_array_equal(res,[0,1,1])
 
-class test_iscomplexobj(NumpyTestCase):
+class TestIscomplexobj(NumpyTestCase):
     def check_basic(self):
         z = array([-1,0,1])
         assert(not iscomplexobj(z))
         z = array([-1j,0,-1])
         assert(iscomplexobj(z))
 
-class test_isrealobj(NumpyTestCase):
+class TestIsrealobj(NumpyTestCase):
     def check_basic(self):
         z = array([-1,0,1])
         assert(isrealobj(z))
         z = array([-1j,0,-1])
         assert(not isrealobj(z))
 
-class test_isnan(NumpyTestCase):
+class TestIsnan(NumpyTestCase):
     def check_goodvalues(self):
         z = array((-1.,0.,1.))
         res = isnan(z) == 0
@@ -148,7 +148,7 @@
         assert_all(isnan(array(0+0j)/0.) == 1)
         seterr(**olderr)
 
-class test_isfinite(NumpyTestCase):
+class TestIsfinite(NumpyTestCase):
     def check_goodvalues(self):
         z = array((-1.,0.,1.))
         res = isfinite(z) == 1
@@ -176,7 +176,7 @@
         assert_all(isfinite(array(1+1j)/0.) == 0)
         seterr(**olderr)
 
-class test_isinf(NumpyTestCase):
+class TestIsinf(NumpyTestCase):
     def check_goodvalues(self):
         z = array((-1.,0.,1.))
         res = isinf(z) == 0
@@ -205,7 +205,7 @@
     #    assert_all(isinf(log(-1.)) == 0)
     #    assert_all(isnan(log(-1.)) == 1)
 
-class test_isposinf(NumpyTestCase):
+class TestIsposinf(NumpyTestCase):
     def check_generic(self):
         olderr = seterr(divide='ignore', invalid='ignore')
         vals = isposinf(array((-1.,0,1))/0.)
@@ -214,7 +214,7 @@
         assert(vals[1] == 0)
         assert(vals[2] == 1)
 
-class test_isneginf(NumpyTestCase):
+class TestIsneginf(NumpyTestCase):
     def check_generic(self):
         olderr = seterr(divide='ignore', invalid='ignore')
         vals = isneginf(array((-1.,0,1))/0.)
@@ -223,7 +223,7 @@
         assert(vals[1] == 0)
         assert(vals[2] == 0)
 
-class test_nan_to_num(NumpyTestCase):
+class TestNanToNum(NumpyTestCase):
     def check_generic(self):
         olderr = seterr(divide='ignore', invalid='ignore')
         vals = nan_to_num(array((-1.,0,1))/0.)
@@ -259,7 +259,7 @@
         #assert_all(vals.real < -1e10) and assert_all(isfinite(vals))
 
 
-class test_real_if_close(NumpyTestCase):
+class TestRealIfClose(NumpyTestCase):
     def check_basic(self):
         a = rand(10)
         b = real_if_close(a+1e-15j)
@@ -270,7 +270,7 @@
         b = real_if_close(a+1e-7j,tol=1e-6)
         assert_all(isrealobj(b))
 
-class test_array_conversion(NumpyTestCase):
+class TestArrayConversion(NumpyTestCase):
     def check_asfarray(self):
         a = asfarray(array([1,2,3]))
         assert_equal(a.__class__,ndarray)

Modified: trunk/numpy/lib/tests/test_ufunclike.py
===================================================================
--- trunk/numpy/lib/tests/test_ufunclike.py	2007-10-02 07:32:06 UTC (rev 4150)
+++ trunk/numpy/lib/tests/test_ufunclike.py	2007-10-02 07:54:11 UTC (rev 4151)
@@ -59,7 +59,7 @@
 
 from numpy.testing import *
 
-class test_docs(NumpyTestCase):
+class TestDocs(NumpyTestCase):
     def check_doctests(self): return self.rundocs()
 
 if __name__ == "__main__":

Modified: trunk/numpy/random/tests/test_random.py
===================================================================
--- trunk/numpy/random/tests/test_random.py	2007-10-02 07:32:06 UTC (rev 4150)
+++ trunk/numpy/random/tests/test_random.py	2007-10-02 07:54:11 UTC (rev 4151)
@@ -2,7 +2,7 @@
 from numpy import random
 import numpy as N
 
-class test_multinomial(NumpyTestCase):
+class TestMultinomial(NumpyTestCase):
     def test_basic(self):
         random.multinomial(100, [0.2, 0.8])
 

Modified: trunk/numpy/tests/test_ctypeslib.py
===================================================================
--- trunk/numpy/tests/test_ctypeslib.py	2007-10-02 07:32:06 UTC (rev 4150)
+++ trunk/numpy/tests/test_ctypeslib.py	2007-10-02 07:54:11 UTC (rev 4151)
@@ -4,7 +4,7 @@
 from numpy.ctypeslib import ndpointer
 restore_path()
 
-class test_ndpointer(NumpyTestCase):
+class TestNdpointer(NumpyTestCase):
     def check_dtype(self):
         dt = N.intc
         p = ndpointer(dtype=dt)



More information about the Numpy-svn mailing list