diff options
| author | Stefan van der Walt <stefan@sun.ac.za> | 2007-10-02 07:54:11 +0000 |
|---|---|---|
| committer | Stefan van der Walt <stefan@sun.ac.za> | 2007-10-02 07:54:11 +0000 |
| commit | 610438f1fb2436cec44b9ddd451daa67d846cdd0 (patch) | |
| tree | 05dd27f00f161ee3a54b1dcf5f3b7f161cf8a68c | |
| parent | b4bb63c29c8bb81bcc2d2070f1bd3b81253acd85 (diff) | |
| download | python-numpy-610438f1fb2436cec44b9ddd451daa67d846cdd0.tar.gz python-numpy-610438f1fb2436cec44b9ddd451daa67d846cdd0.tar.bz2 python-numpy-610438f1fb2436cec44b9ddd451daa67d846cdd0.zip | |
Rename test classes to CapWords.
38 files changed, 263 insertions, 263 deletions
diff --git a/numpy/core/tests/test_defmatrix.py b/numpy/core/tests/test_defmatrix.py index 1330bfff2..6f99114a9 100644 --- a/numpy/core/tests/test_defmatrix.py +++ b/numpy/core/tests/test_defmatrix.py @@ -4,7 +4,7 @@ import numpy.core;reload(numpy.core) 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 @@ class test_ctor(NumpyTestCase): 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 @@ class test_properties(NumpyTestCase): 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 @@ class test_casting(NumpyTestCase): 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 @@ class test_algebra(NumpyTestCase): 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 @@ class test_matrix_return(NumpyTestCase): 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) diff --git a/numpy/core/tests/test_errstate.py b/numpy/core/tests/test_errstate.py index a7ce798b0..1e1082559 100644 --- a/numpy/core/tests/test_errstate.py +++ b/numpy/core/tests/test_errstate.py @@ -14,7 +14,7 @@ from numpy.testing import * -class test_errstate(NumpyTestCase):
+class TestErrstate(NumpyTestCase):
def test_invalid(self):
diff --git a/numpy/core/tests/test_ma.py b/numpy/core/tests/test_ma.py index a74638a23..ed7cb2a79 100644 --- a/numpy/core/tests/test_ma.py +++ b/numpy/core/tests/test_ma.py @@ -13,7 +13,7 @@ def eq(v,w, msg=''): %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 @@ class test_ma(NumpyTestCase): 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 @@ class test_ufuncs(NumpyTestCase): 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, diff --git a/numpy/core/tests/test_multiarray.py b/numpy/core/tests/test_multiarray.py index c31c298bc..475787a09 100644 --- a/numpy/core/tests/test_multiarray.py +++ b/numpy/core/tests/test_multiarray.py @@ -3,7 +3,7 @@ from numpy.core import * 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 @@ class test_flags(NumpyTestCase): 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 @@ class test_attributes(NumpyTestCase): 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 @@ class test_fromstring(NumpyTestCase): 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 @@ class test_zero_rank(NumpyTestCase): 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 @@ class test_bool(NumpyTestCase): 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 @@ class test_methods(NumpyTestCase): 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 @@ class test_pickling(NumpyTestCase): 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 @@ class test_fancy_indexing(NumpyTestCase): 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 @@ class test_string_compare(NumpyTestCase): 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 @@ class test_argmax(NumpyTestCase): 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) diff --git a/numpy/core/tests/test_numeric.py b/numpy/core/tests/test_numeric.py index 3e06b4747..891bf3be7 100644 --- a/numpy/core/tests/test_numeric.py +++ b/numpy/core/tests/test_numeric.py @@ -31,7 +31,7 @@ class Vec: 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 @@ class test_dot(NumpyTestCase): 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 @@ class test_bool_scalar(NumpyTestCase): 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 @@ class test_seterr(NumpyTestCase): array([1.]) / array([0.]) -class test_fromiter(NumpyTestCase): +class TestFromiter(NumpyTestCase): def makegen(self): for x in xrange(24): @@ -232,7 +232,7 @@ class test_fromiter(NumpyTestCase): 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 @@ class test_index(NumpyTestCase): 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 @@ def assert_array_strict_equal(x, y): assert x.dtype.isnative == y.dtype.isnative -class test_clip(NumpyTestCase): +class TestClip(NumpyTestCase): def setUp(self): self.nr = 5 self.nc = 3 diff --git a/numpy/core/tests/test_numerictypes.py b/numpy/core/tests/test_numerictypes.py index b6a7f6202..527b89b53 100644 --- a/numpy/core/tests/test_numerictypes.py +++ b/numpy/core/tests/test_numerictypes.py @@ -331,7 +331,7 @@ class test_read_values_nested_multiple(read_values_nested, NumpyTestCase): 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")] diff --git a/numpy/core/tests/test_records.py b/numpy/core/tests/test_records.py index 4fc263ada..431852ce4 100644 --- a/numpy/core/tests/test_records.py +++ b/numpy/core/tests/test_records.py @@ -6,7 +6,7 @@ import numpy.core;reload(numpy.core) 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 @@ class test_fromrecords(NumpyTestCase): 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"), diff --git a/numpy/core/tests/test_regression.py b/numpy/core/tests/test_regression.py index d87c587f8..a2353da82 100644 --- a/numpy/core/tests/test_regression.py +++ b/numpy/core/tests/test_regression.py @@ -22,7 +22,7 @@ def assert_valid_refcount(op): assert(sys.getrefcount(i) >= rc) -class test_regression(NumpyTestCase): +class TestRegression(NumpyTestCase): def check_invalid_round(self,level=rlevel): """Ticket #3""" v = 4.7599999999999998 diff --git a/numpy/core/tests/test_scalarmath.py b/numpy/core/tests/test_scalarmath.py index bb4974b12..84cca37a9 100644 --- a/numpy/core/tests/test_scalarmath.py +++ b/numpy/core/tests/test_scalarmath.py @@ -12,7 +12,7 @@ types = [N.bool_, N.byte, N.ubyte, N.short, N.ushort, N.intc, N.uintc, # 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 @@ class test_types(NumpyTestCase): 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 @@ class test_power(NumpyTestCase): 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] diff --git a/numpy/core/tests/test_umath.py b/numpy/core/tests/test_umath.py index 09e5c1d93..70076627b 100644 --- a/numpy/core/tests/test_umath.py +++ b/numpy/core/tests/test_umath.py @@ -5,7 +5,7 @@ import numpy.core.umath as ncu 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 @@ class test_division(NumpyTestCase): 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 @@ class test_power(NumpyTestCase): 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 @@ class test_special_methods(NumpyTestCase): 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 @@ class _test_complex_real(NumpyTestCase): 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') diff --git a/numpy/distutils/tests/f2py_ext/tests/test_fib2.py b/numpy/distutils/tests/f2py_ext/tests/test_fib2.py index cbb0498d2..9a52ab17a 100644 --- a/numpy/distutils/tests/f2py_ext/tests/test_fib2.py +++ b/numpy/distutils/tests/f2py_ext/tests/test_fib2.py @@ -4,7 +4,7 @@ set_package_path() 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]) diff --git a/numpy/distutils/tests/f2py_f90_ext/tests/test_foo.py b/numpy/distutils/tests/f2py_f90_ext/tests/test_foo.py index da52c8aff..3d48f6ca9 100644 --- a/numpy/distutils/tests/f2py_f90_ext/tests/test_foo.py +++ b/numpy/distutils/tests/f2py_f90_ext/tests/test_foo.py @@ -4,7 +4,7 @@ set_package_path() 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) diff --git a/numpy/distutils/tests/gen_ext/tests/test_fib3.py b/numpy/distutils/tests/gen_ext/tests/test_fib3.py index e1c1ff070..b962a12aa 100644 --- a/numpy/distutils/tests/gen_ext/tests/test_fib3.py +++ b/numpy/distutils/tests/gen_ext/tests/test_fib3.py @@ -4,7 +4,7 @@ set_package_path() 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]) diff --git a/numpy/distutils/tests/pyrex_ext/tests/test_primes.py b/numpy/distutils/tests/pyrex_ext/tests/test_primes.py index bb1e4c332..1ca5ed8e7 100644 --- a/numpy/distutils/tests/pyrex_ext/tests/test_primes.py +++ b/numpy/distutils/tests/pyrex_ext/tests/test_primes.py @@ -5,7 +5,7 @@ set_package_path() 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]) diff --git a/numpy/distutils/tests/swig_ext/tests/test_example.py b/numpy/distutils/tests/swig_ext/tests/test_example.py index 71cb3d2c5..f24162077 100644 --- a/numpy/distutils/tests/swig_ext/tests/test_example.py +++ b/numpy/distutils/tests/swig_ext/tests/test_example.py @@ -4,7 +4,7 @@ set_package_path() from swig_ext import example restore_path() -class test_example(NumpyTestCase): +class TestExample(NumpyTestCase): def check_fact(self): assert_equal(example.fact(10),3628800) diff --git a/numpy/distutils/tests/swig_ext/tests/test_example2.py b/numpy/distutils/tests/swig_ext/tests/test_example2.py index 1d8e73a12..3150e1a16 100644 --- a/numpy/distutils/tests/swig_ext/tests/test_example2.py +++ b/numpy/distutils/tests/swig_ext/tests/test_example2.py @@ -4,7 +4,7 @@ set_package_path() from swig_ext import example2 restore_path() -class test_example2(NumpyTestCase): +class TestExample2(NumpyTestCase): def check_zoo(self): z = example2.Zoo() diff --git a/numpy/distutils/tests/test_fcompiler_gnu.py b/numpy/distutils/tests/test_fcompiler_gnu.py index c6ccea054..002d360b9 100644 --- a/numpy/distutils/tests/test_fcompiler_gnu.py +++ b/numpy/distutils/tests/test_fcompiler_gnu.py @@ -21,7 +21,7 @@ gfortran_version_strings = [ ('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 @@ class test_g77_versions(NumpyTestCase): 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: diff --git a/numpy/distutils/tests/test_misc_util.py b/numpy/distutils/tests/test_misc_util.py index b75eb8cf2..4d2404092 100644 --- a/numpy/distutils/tests/test_misc_util.py +++ b/numpy/distutils/tests/test_misc_util.py @@ -8,7 +8,7 @@ from os.path import join, sep 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 @@ class test_appendpath(NumpyTestCase): 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 @@ class test_minrelpath(NumpyTestCase): 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__),'..')) diff --git a/numpy/f2py/lib/parser/test_Fortran2003.py b/numpy/f2py/lib/parser/test_Fortran2003.py index a8aae6081..525061db4 100644 --- a/numpy/f2py/lib/parser/test_Fortran2003.py +++ b/numpy/f2py/lib/parser/test_Fortran2003.py @@ -7,7 +7,7 @@ from api import get_reader ############################### SECTION 2 #################################### ############################################################################### -class test_Program(NumpyTestCase): # R201 +class TestProgram(NumpyTestCase): # R201 def check_simple(self): reader = get_reader('''\ @@ -21,7 +21,7 @@ class test_Program(NumpyTestCase): # R201 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 @@ class test_Specification_Part(NumpyTestCase): # R204 ############################### SECTION 3 #################################### ############################################################################### -class test_Name(NumpyTestCase): # R304 +class TestName(NumpyTestCase): # R304 def check_name(self): a = Name('a') @@ -55,7 +55,7 @@ class test_Name(NumpyTestCase): # R304 ############################### 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 @@ class test_Type_Param_Value(NumpyTestCase): # 402 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 @@ class test_Intrinsic_Type_Spec(NumpyTestCase): # R403 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 @@ class test_Kind_Selector(NumpyTestCase): # R404 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 @@ class test_Signed_Int_Literal_Constant(NumpyTestCase): # R405 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 @@ class test_Int_Literal_Constant(NumpyTestCase): # R406 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 @@ class test_Binary_Constant(NumpyTestCase): # R412 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 @@ class test_Octal_Constant(NumpyTestCase): # R413 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 @@ class test_Hex_Constant(NumpyTestCase): # R414 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 @@ class test_Signed_Real_Literal_Constant(NumpyTestCase): # R416 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 @@ class test_Real_Literal_Constant(NumpyTestCase): # R417 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 @@ class test_Char_Selector(NumpyTestCase): # R424 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 @@ class test_Complex_Literal_Constant(NumpyTestCase): # R421 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 @@ class test_Type_Name(NumpyTestCase): # C424 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 @@ class test_Length_Selector(NumpyTestCase): # R425 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 @@ class test_Char_Length(NumpyTestCase): # R426 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 @@ class test_Char_Literal_Constant(NumpyTestCase): # R427 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 @@ class test_Logical_Literal_Constant(NumpyTestCase): # R428 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 @@ class test_Derived_Type_Stmt(NumpyTestCase): # R430 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 @@ class test_Type_Name(NumpyTestCase): # C423 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 @@ class test_Type_Attr_Spec(NumpyTestCase): # R431 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 @@ class test_End_Type_Stmt(NumpyTestCase): # R433 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 @@ class test_Sequence_Stmt(NumpyTestCase): # R434 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 @@ class test_Type_Param_Def_Stmt(NumpyTestCase): # R435 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 @@ class test_Type_Param_Decl(NumpyTestCase): # R436 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 @@ class test_Type_Param_Attr_Spec(NumpyTestCase): # R437 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 @@ class test_Component_Attr_Spec(NumpyTestCase): # R441 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 @@ class test_Component_Decl(NumpyTestCase): # R442 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 @@ class test_Final_Binding(NumpyTestCase): # R454 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 @@ class test_Derived_Type_Spec(NumpyTestCase): # R455 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 @@ class test_Type_Param_Spec(NumpyTestCase): # R456 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 @@ class test_Type_Param_Spec_List(NumpyTestCase): # R456-list 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 @@ class test_Structure_Constructor_2(NumpyTestCase): # R457.b 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 @@ class test_Structure_Constructor(NumpyTestCase): # R457 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 @@ class test_Component_Spec(NumpyTestCase): # R458 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 @@ class test_Component_Spec_List(NumpyTestCase): # R458-list 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 @@ class test_Array_Constructor(NumpyTestCase): # R465 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 @@ class test_Ac_Spec(NumpyTestCase): # R466 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 @@ class test_Ac_Value_List(NumpyTestCase): # R469-list 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 @@ class test_Ac_Implied_Do(NumpyTestCase): # R470 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 @@ class test_Ac_Implied_Do_Control(NumpyTestCase): # R471 ############################### 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 @@ class test_Type_Declaration_Stmt(NumpyTestCase): # R501 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 @@ class test_Declaration_Type_Spec(NumpyTestCase): # R502 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 @@ class test_Attr_Spec(NumpyTestCase): # R503 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 @@ class test_Dimension_Attr_Spec(NumpyTestCase): # R503.d 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 @@ class test_Intent_Attr_Spec(NumpyTestCase): # R503.f 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 @@ class test_Entity_Decl(NumpyTestCase): # 504 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 @@ class test_Access_Spec(NumpyTestCase): # R508 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 @@ class test_Language_Binding_Spec(NumpyTestCase): # R509 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 @@ class test_Explicit_Shape_Spec(NumpyTestCase): # R511 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 @@ class test_Upper_Bound(NumpyTestCase): # R513 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 @@ class test_Assumed_Shape_Spec(NumpyTestCase): # R514 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 @@ class test_Deferred_Shape_Spec(NumpyTestCase): # R515 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 @@ class test_Assumed_Size_Spec(NumpyTestCase): # R516 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 @@ class test_Access_Stmt(NumpyTestCase): # R518 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 @@ class test_Parameter_Stmt(NumpyTestCase): # R538 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 @@ class test_Named_Constant_Def(NumpyTestCase): # R539 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 @@ class test_Pointer_Decl(NumpyTestCase): # R541 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 @@ class test_Implicit_Stmt(NumpyTestCase): # R549 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 @@ class test_Implicit_Spec(NumpyTestCase): # R550 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 @@ class test_Letter_Spec(NumpyTestCase): # R551 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 @@ class test_Equivalence_Stmt(NumpyTestCase): # R554 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 @@ class test_Common_Stmt(NumpyTestCase): # R557 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 @@ class test_Common_Block_Object(NumpyTestCase): # R558 ############################### SECTION 6 #################################### ############################################################################### -class test_Substring(NumpyTestCase): # R609 +class TestSubstring(NumpyTestCase): # R609 def check_simple(self): cls = Substring @@ -1184,7 +1184,7 @@ class test_Substring(NumpyTestCase): # R609 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 @@ class test_Substring_Range(NumpyTestCase): # R611 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 @@ class test_Data_Ref(NumpyTestCase): # R612 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 @@ class test_Part_Ref(NumpyTestCase): # R613 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 @@ class test_Type_Param_Inquiry(NumpyTestCase): # R615 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 @@ class test_Array_Section(NumpyTestCase): # R617 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 @@ class test_Section_Subscript(NumpyTestCase): # R619 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 @@ class test_Section_Subscript_List(NumpyTestCase): # R619-list 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 @@ class test_Subscript_Triplet(NumpyTestCase): # R620 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 @@ class test_Alloc_Opt(NumpyTestCase): # R624 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 @@ class test_Nullify_Stmt(NumpyTestCase): # R633 ############################### SECTION 7 #################################### ############################################################################### -class test_Primary(NumpyTestCase): # R701 +class TestPrimary(NumpyTestCase): # R701 def check_simple(self): cls = Primary @@ -1401,7 +1401,7 @@ class test_Primary(NumpyTestCase): # R701 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 @@ class test_Parenthesis(NumpyTestCase): # R701.h 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 @@ class test_Level_1_Expr(NumpyTestCase): # R702 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 @@ class test_Mult_Operand(NumpyTestCase): # R704 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 @@ class test_Add_Operand(NumpyTestCase): # R705 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 @@ class test_Level_2_Expr(NumpyTestCase): # R706 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 @@ class test_Level_2_Unary_Expr(NumpyTestCase): 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 @@ class test_Level_3_Expr(NumpyTestCase): # R710 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 @@ class test_Level_4_Expr(NumpyTestCase): # R712 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 @@ class test_And_Operand(NumpyTestCase): # R714 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 @@ class test_Or_Operand(NumpyTestCase): # R715 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 @@ class test_Equiv_Operand(NumpyTestCase): # R716 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 @@ class test_Level_5_Expr(NumpyTestCase): # R717 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 @@ class test_Expr(NumpyTestCase): # R722 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 @@ class test_Assignment_Stmt(NumpyTestCase): # R734 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 @@ class test_Proc_Component_Ref(NumpyTestCase): # R741 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 @@ class test_Where_Stmt(NumpyTestCase): # R743 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 @@ class test_Where_Construct_Stmt(NumpyTestCase): # R745 ############################### SECTION 8 #################################### ############################################################################### -class test_Continue_Stmt(NumpyTestCase): # R848 +class TestContinueStmt(NumpyTestCase): # R848 def check_simple(self): cls = Continue_Stmt @@ -1723,7 +1723,7 @@ class test_Continue_Stmt(NumpyTestCase): # R848 ############################### SECTION 9 #################################### ############################################################################### -class test_Io_Unit(NumpyTestCase): # R901 +class TestIoUnit(NumpyTestCase): # R901 def check_simple(self): cls = Io_Unit @@ -1735,7 +1735,7 @@ class test_Io_Unit(NumpyTestCase): # R901 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 @@ class test_Write_Stmt(NumpyTestCase): # R911 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 @@ class test_Print_Stmt(NumpyTestCase): # R912 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 @@ class test_Io_Control_Spec(NumpyTestCase): # R913 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 @@ class test_Io_Control_Spec_List(NumpyTestCase): # R913-list 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 @@ class test_Format(NumpyTestCase): # R914 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 @@ class test_Wait_Stmt(NumpyTestCase): # R921 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 @@ class test_Wait_Spec(NumpyTestCase): # R922 ############################### SECTION 11 #################################### ############################################################################### -class test_Use_Stmt(NumpyTestCase): # R1109 +class TestUseStmt(NumpyTestCase): # R1109 def check_simple(self): cls = Use_Stmt @@ -1861,7 +1861,7 @@ class test_Use_Stmt(NumpyTestCase): # R1109 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 @@ class test_Module_Nature(NumpyTestCase): # R1110 ############################### SECTION 12 #################################### ############################################################################### -class test_Function_Reference(NumpyTestCase): # R1217 +class TestFunctionReference(NumpyTestCase): # R1217 def check_simple(self): cls = Function_Reference @@ -1892,7 +1892,7 @@ class test_Function_Reference(NumpyTestCase): # R1217 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 @@ class test_Procedure_Designator(NumpyTestCase): # R1219 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 @@ class test_Actual_Arg_Spec(NumpyTestCase): # R1220 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 @@ class test_Actual_Arg_Spec_List(NumpyTestCase): 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 @@ class test_Alt_Return_Spec(NumpyTestCase): # R1222 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 @@ class test_Prefix(NumpyTestCase): # R1227 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 @@ class test_Prefix_Spec(NumpyTestCase): # R1228 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 @@ class test_Subroutine_Subprogram(NumpyTestCase): # R1231 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 @@ class test_Subroutine_Stmt(NumpyTestCase): # R1232 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 @@ class test_End_Subroutine_Stmt(NumpyTestCase): # R1234 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 @@ class test_Return_Stmt(NumpyTestCase): # R1236 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 diff --git a/numpy/f2py/lib/parser/test_parser.py b/numpy/f2py/lib/parser/test_parser.py index 9f1767a1a..e7dd4f971 100644 --- a/numpy/f2py/lib/parser/test_parser.py +++ b/numpy/f2py/lib/parser/test_parser.py @@ -34,7 +34,7 @@ def parse(cls, line, label='', 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') diff --git a/numpy/f2py/lib/tests/test_derived_scalar.py b/numpy/f2py/lib/tests/test_derived_scalar.py index c57778020..b5f24dea5 100644 --- a/numpy/f2py/lib/tests/test_derived_scalar.py +++ b/numpy/f2py/lib/tests/test_derived_scalar.py @@ -42,7 +42,7 @@ m, = compile(fortran_code, 'test_derived_scalar_ext') from numpy import * -class test_m(NumpyTestCase): +class TestM(NumpyTestCase): def check_foo_simple(self, level=1): a = m.myt(2) diff --git a/numpy/f2py/lib/tests/test_module_module.py b/numpy/f2py/lib/tests/test_module_module.py index 4d242ed54..0f0e88cc9 100644 --- a/numpy/f2py/lib/tests/test_module_module.py +++ b/numpy/f2py/lib/tests/test_module_module.py @@ -51,7 +51,7 @@ m,m2 = compile(fortran_code, modulenames=['test_module_module_ext', from numpy import * -class test_m(NumpyTestCase): +class TestM(NumpyTestCase): def check_foo_simple(self, level=1): foo = m.foo diff --git a/numpy/f2py/lib/tests/test_module_scalar.py b/numpy/f2py/lib/tests/test_module_scalar.py index e11a1e0ae..1ac4455be 100644 --- a/numpy/f2py/lib/tests/test_module_scalar.py +++ b/numpy/f2py/lib/tests/test_module_scalar.py @@ -40,7 +40,7 @@ m, = compile(fortran_code, modulenames = ['test_module_scalar_ext']) from numpy import * -class test_m(NumpyTestCase): +class TestM(NumpyTestCase): def check_foo_simple(self, level=1): foo = m.foo diff --git a/numpy/f2py/lib/tests/test_scalar_function_in.py b/numpy/f2py/lib/tests/test_scalar_function_in.py index 9c5cd8aba..24387def5 100644 --- a/numpy/f2py/lib/tests/test_scalar_function_in.py +++ b/numpy/f2py/lib/tests/test_scalar_function_in.py @@ -107,7 +107,7 @@ m, = compile(fortran_code, 'test_scalar_function_in_ext') from numpy import * -class test_m(NumpyTestCase): +class TestM(NumpyTestCase): def check_foo_integer1(self, level=1): i = int8(2) diff --git a/numpy/f2py/lib/tests/test_scalar_in_out.py b/numpy/f2py/lib/tests/test_scalar_in_out.py index b73036848..dc6007b8e 100644 --- a/numpy/f2py/lib/tests/test_scalar_in_out.py +++ b/numpy/f2py/lib/tests/test_scalar_in_out.py @@ -104,7 +104,7 @@ m, = compile(fortran_code, 'test_scalar_in_out_ext', source_ext = '.f') from numpy import * -class test_m(NumpyTestCase): +class TestM(NumpyTestCase): def check_foo_integer1(self, level=1): i = int8(2) diff --git a/numpy/fft/tests/test_fftpack.py b/numpy/fft/tests/test_fftpack.py index 0e38fb3ea..74e2d06f5 100644 --- a/numpy/fft/tests/test_fftpack.py +++ b/numpy/fft/tests/test_fftpack.py @@ -4,7 +4,7 @@ set_package_path() 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) diff --git a/numpy/fft/tests/test_helper.py b/numpy/fft/tests/test_helper.py index 3d02c01df..aaec6530a 100644 --- a/numpy/fft/tests/test_helper.py +++ b/numpy/fft/tests/test_helper.py @@ -14,7 +14,7 @@ from numpy import pi 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 @@ class test_fftshift(NumpyTestCase): 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] diff --git a/numpy/lib/tests/test_arraysetops.py b/numpy/lib/tests/test_arraysetops.py index ccdcc7556..e2e703b9a 100644 --- a/numpy/lib/tests/test_arraysetops.py +++ b/numpy/lib/tests/test_arraysetops.py @@ -11,7 +11,7 @@ restore_path() ################################################## -class test_aso(NumpyTestCase): +class TestAso(NumpyTestCase): ## # 03.11.2005, c def check_unique1d( self ): diff --git a/numpy/lib/tests/test_function_base.py b/numpy/lib/tests/test_function_base.py index 77cc29199..f1b64c8d5 100644 --- a/numpy/lib/tests/test_function_base.py +++ b/numpy/lib/tests/test_function_base.py @@ -7,7 +7,7 @@ from numpy.lib import * 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 @@ class test_any(NumpyTestCase): 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 @@ class test_all(NumpyTestCase): 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 @@ class test_average(NumpyTestCase): 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 @@ class test_select(NumpyTestCase): 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 @@ class test_logspace(NumpyTestCase): 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 @@ class test_linspace(NumpyTestCase): 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 @@ class test_amax(NumpyTestCase): 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 @@ class test_amin(NumpyTestCase): 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 @@ class test_ptp(NumpyTestCase): 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 @@ class test_cumsum(NumpyTestCase): [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 @@ class test_prod(NumpyTestCase): 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 @@ class test_cumprod(NumpyTestCase): [ 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 @@ class test_diff(NumpyTestCase): 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 @@ class test_angle(NumpyTestCase): 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 @@ class test_trim_zeros(NumpyTestCase): 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 @@ class test_extins(NumpyTestCase): 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 @@ class test_vectorize(NumpyTestCase): 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 @@ class test_digitize(NumpyTestCase): 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 @@ class test_unwrap(NumpyTestCase): 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 @@ class test_filterwindows(NumpyTestCase): 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 @@ class test_histogram(NumpyTestCase): (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 @@ class test_histogramdd(NumpyTestCase): 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])) diff --git a/numpy/lib/tests/test_getlimits.py b/numpy/lib/tests/test_getlimits.py index 7a4fea57a..3c53f3322 100644 --- a/numpy/lib/tests/test_getlimits.py +++ b/numpy/lib/tests/test_getlimits.py @@ -11,31 +11,31 @@ restore_path() ################################################## -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'], diff --git a/numpy/lib/tests/test_index_tricks.py b/numpy/lib/tests/test_index_tricks.py index 5d4f540b2..8fc192202 100644 --- a/numpy/lib/tests/test_index_tricks.py +++ b/numpy/lib/tests/test_index_tricks.py @@ -3,7 +3,7 @@ set_package_path() 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 @@ class test_grid(NumpyTestCase): 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) diff --git a/numpy/lib/tests/test_polynomial.py b/numpy/lib/tests/test_polynomial.py index d7c2c917d..c9a230775 100644 --- a/numpy/lib/tests/test_polynomial.py +++ b/numpy/lib/tests/test_polynomial.py @@ -76,7 +76,7 @@ poly1d([ 2.]) 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): diff --git a/numpy/lib/tests/test_shape_base.py b/numpy/lib/tests/test_shape_base.py index b7b3458e4..c819ba366 100644 --- a/numpy/lib/tests/test_shape_base.py +++ b/numpy/lib/tests/test_shape_base.py @@ -5,7 +5,7 @@ from numpy.lib import * 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 @@ class test_apply_along_axis(NumpyTestCase): 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 @@ class test_array_split(NumpyTestCase): 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 @@ class test_split(NumpyTestCase): 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 @@ class test_atleast_1d(NumpyTestCase): 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 @@ class test_atleast_2d(NumpyTestCase): 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 @@ class test_atleast_3d(NumpyTestCase): 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 @@ class test_hstack(NumpyTestCase): 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 @@ class test_vstack(NumpyTestCase): 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 @@ class test_dstack(NumpyTestCase): """ 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 @@ class test_hsplit(NumpyTestCase): 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 @@ class test_vsplit(NumpyTestCase): 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 @@ class test_dsplit(NumpyTestCase): 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 @@ class test_squeeze(NumpyTestCase): 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 @@ class test_kron(NumpyTestCase): 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]] diff --git a/numpy/lib/tests/test_twodim_base.py b/numpy/lib/tests/test_twodim_base.py index 92ddf5b34..3a9e8df80 100644 --- a/numpy/lib/tests/test_twodim_base.py +++ b/numpy/lib/tests/test_twodim_base.py @@ -17,7 +17,7 @@ def get_mat(n): 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 @@ class test_eye(NumpyTestCase): [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 @@ class test_diag(NumpyTestCase): 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 @@ class test_fliplr(NumpyTestCase): [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 @@ class test_flipud(NumpyTestCase): [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 @@ class test_rot90(NumpyTestCase): 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 @@ class test_histogram2d(NumpyTestCase): 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], diff --git a/numpy/lib/tests/test_type_check.py b/numpy/lib/tests/test_type_check.py index a89d6ce7f..633c34dc8 100644 --- a/numpy/lib/tests/test_type_check.py +++ b/numpy/lib/tests/test_type_check.py @@ -10,7 +10,7 @@ restore_path() 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 @@ class test_mintypecode(NumpyTestCase): #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 @@ class test_isscalar(NumpyTestCase): 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 @@ class test_real(NumpyTestCase): 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 @@ class test_imag(NumpyTestCase): 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 @@ class test_iscomplex(NumpyTestCase): 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 @@ class test_isreal(NumpyTestCase): 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 @@ class test_isnan(NumpyTestCase): 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 @@ class test_isfinite(NumpyTestCase): 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 @@ class test_isinf(NumpyTestCase): # 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 @@ class test_isposinf(NumpyTestCase): 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 @@ class test_isneginf(NumpyTestCase): 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 @@ class test_nan_to_num(NumpyTestCase): #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 @@ class test_real_if_close(NumpyTestCase): 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) diff --git a/numpy/lib/tests/test_ufunclike.py b/numpy/lib/tests/test_ufunclike.py index 8f9ac2833..926439fb4 100644 --- a/numpy/lib/tests/test_ufunclike.py +++ b/numpy/lib/tests/test_ufunclike.py @@ -59,7 +59,7 @@ array([ 2.169925 , 1.20163386, 2.70043972]) from numpy.testing import * -class test_docs(NumpyTestCase): +class TestDocs(NumpyTestCase): def check_doctests(self): return self.rundocs() if __name__ == "__main__": diff --git a/numpy/random/tests/test_random.py b/numpy/random/tests/test_random.py index 8f7842085..9b9e5d828 100644 --- a/numpy/random/tests/test_random.py +++ b/numpy/random/tests/test_random.py @@ -2,7 +2,7 @@ from numpy.testing import * 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]) diff --git a/numpy/tests/test_ctypeslib.py b/numpy/tests/test_ctypeslib.py index 6ee75271d..875e1a1c7 100644 --- a/numpy/tests/test_ctypeslib.py +++ b/numpy/tests/test_ctypeslib.py @@ -4,7 +4,7 @@ import numpy as N 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) |