diff options
Diffstat (limited to 'numpy/ma')
| -rw-r--r-- | numpy/ma/tests/test_core.py | 392 | ||||
| -rw-r--r-- | numpy/ma/tests/test_deprecations.py | 6 | ||||
| -rw-r--r-- | numpy/ma/tests/test_extras.py | 67 | ||||
| -rw-r--r-- | numpy/ma/tests/test_mrecords.py | 77 | ||||
| -rw-r--r-- | numpy/ma/tests/test_old_ma.py | 514 | ||||
| -rw-r--r-- | numpy/ma/tests/test_regression.py | 9 | ||||
| -rw-r--r-- | numpy/ma/tests/test_subclassing.py | 112 |
7 files changed, 583 insertions, 594 deletions
diff --git a/numpy/ma/tests/test_core.py b/numpy/ma/tests/test_core.py index c8bcb758d..06f4df000 100644 --- a/numpy/ma/tests/test_core.py +++ b/numpy/ma/tests/test_core.py @@ -20,7 +20,7 @@ import numpy.ma.core import numpy.core.fromnumeric as fromnumeric import numpy.core.umath as umath from numpy.testing import ( - TestCase, run_module_suite, assert_raises, assert_warns, suppress_warnings + run_module_suite, assert_raises, assert_warns, suppress_warnings ) from numpy import ndarray from numpy.compat import asbytes, asbytes_nested @@ -56,10 +56,10 @@ suppress_copy_mask_on_assignment.filter( "setting an item on a masked array which has a shared mask will not copy") -class TestMaskedArray(TestCase): +class TestMaskedArray(object): # Base test class for MaskedArrays. - def setUp(self): + def setup(self): # Base data definition. x = np.array([1., 1., 1., -2., pi/2.0, 4., 5., -10., 10., 1., 2., 3.]) y = np.array([5., 0., 3., 2., -1., -4., 0., -10., 10., 1., 0., 3.]) @@ -94,14 +94,14 @@ class TestMaskedArray(TestCase): x = masked_array(0, mask=False) assert_equal(str(x), '0') x = array(0, mask=1) - self.assertTrue(x.filled().dtype is x._data.dtype) + assert_(x.filled().dtype is x._data.dtype) def test_basic1d(self): # Test of basic array creation and properties in 1 dimension. (x, y, a10, m1, m2, xm, ym, z, zm, xf) = self.d - self.assertTrue(not isMaskedArray(x)) - self.assertTrue(isMaskedArray(xm)) - self.assertTrue((xm - ym).filled(0).any()) + assert_(not isMaskedArray(x)) + assert_(isMaskedArray(xm)) + assert_((xm - ym).filled(0).any()) fail_if_equal(xm.mask.astype(int), ym.mask.astype(int)) s = x.shape assert_equal(np.shape(xm), s) @@ -124,8 +124,8 @@ class TestMaskedArray(TestCase): ym.shape = s xf.shape = s - self.assertTrue(not isMaskedArray(x)) - self.assertTrue(isMaskedArray(xm)) + assert_(not isMaskedArray(x)) + assert_(isMaskedArray(xm)) assert_equal(shape(xm), s) assert_equal(xm.shape, s) assert_equal(xm.size, reduce(lambda x, y:x * y, s)) @@ -218,7 +218,7 @@ class TestMaskedArray(TestCase): x.mask = nomask data = array((x, x[::-1])) assert_equal(data, [[0, 1, 2, 3, 4], [4, 3, 2, 1, 0]]) - self.assertTrue(data.mask is nomask) + assert_(data.mask is nomask) def test_creation_from_ndarray_with_padding(self): x = np.array([('A', 0)], dtype={'names':['f0','f1'], @@ -239,18 +239,18 @@ class TestMaskedArray(TestCase): def test_asarray_default_order(self): # See Issue #6646 m = np.eye(3).T - self.assertFalse(m.flags.c_contiguous) + assert_(not m.flags.c_contiguous) new_m = asarray(m) - self.assertTrue(new_m.flags.c_contiguous) + assert_(new_m.flags.c_contiguous) def test_asarray_enforce_order(self): # See Issue #6646 m = np.eye(3).T - self.assertFalse(m.flags.c_contiguous) + assert_(not m.flags.c_contiguous) new_m = asarray(m, order='C') - self.assertTrue(new_m.flags.c_contiguous) + assert_(new_m.flags.c_contiguous) def test_fix_invalid(self): # Checks fix_invalid. @@ -264,8 +264,8 @@ class TestMaskedArray(TestCase): # Test of masked element x = arange(6) x[1] = masked - self.assertTrue(str(masked) == '--') - self.assertTrue(x[1] is masked) + assert_(str(masked) == '--') + assert_(x[1] is masked) assert_equal(filled(x[1], 0), 0) def test_set_element_as_object(self): @@ -274,12 +274,12 @@ class TestMaskedArray(TestCase): x = (1, 2, 3, 4, 5) a[0] = x assert_equal(a[0], x) - self.assertTrue(a[0] is x) + assert_(a[0] is x) import datetime dt = datetime.datetime.now() a[0] = dt - self.assertTrue(a[0] is dt) + assert_(a[0] is dt) def test_indexing(self): # Tests conversions and indexing @@ -380,43 +380,43 @@ class TestMaskedArray(TestCase): n = [0, 0, 1, 0, 0] m = make_mask(n) m2 = make_mask(m) - self.assertTrue(m is m2) + assert_(m is m2) m3 = make_mask(m, copy=1) - self.assertTrue(m is not m3) + assert_(m is not m3) x1 = np.arange(5) y1 = array(x1, mask=m) assert_equal(y1._data.__array_interface__, x1.__array_interface__) - self.assertTrue(allequal(x1, y1.data)) + assert_(allequal(x1, y1.data)) assert_equal(y1._mask.__array_interface__, m.__array_interface__) y1a = array(y1) - self.assertTrue(y1a._data.__array_interface__ == + assert_(y1a._data.__array_interface__ == y1._data.__array_interface__) - self.assertTrue(y1a.mask is y1.mask) + assert_(y1a.mask is y1.mask) y2 = array(x1, mask=m3) - self.assertTrue(y2._data.__array_interface__ == x1.__array_interface__) - self.assertTrue(y2._mask.__array_interface__ == m3.__array_interface__) - self.assertTrue(y2[2] is masked) + assert_(y2._data.__array_interface__ == x1.__array_interface__) + assert_(y2._mask.__array_interface__ == m3.__array_interface__) + assert_(y2[2] is masked) y2[2] = 9 - self.assertTrue(y2[2] is not masked) - self.assertTrue(y2._mask.__array_interface__ == m3.__array_interface__) - self.assertTrue(allequal(y2.mask, 0)) + assert_(y2[2] is not masked) + assert_(y2._mask.__array_interface__ == m3.__array_interface__) + assert_(allequal(y2.mask, 0)) y2a = array(x1, mask=m, copy=1) - self.assertTrue(y2a._data.__array_interface__ != x1.__array_interface__) - #self.assertTrue( y2a.mask is not m) - self.assertTrue(y2a._mask.__array_interface__ != m.__array_interface__) - self.assertTrue(y2a[2] is masked) + assert_(y2a._data.__array_interface__ != x1.__array_interface__) + #assert_( y2a.mask is not m) + assert_(y2a._mask.__array_interface__ != m.__array_interface__) + assert_(y2a[2] is masked) y2a[2] = 9 - self.assertTrue(y2a[2] is not masked) - #self.assertTrue( y2a.mask is not m) - self.assertTrue(y2a._mask.__array_interface__ != m.__array_interface__) - self.assertTrue(allequal(y2a.mask, 0)) + assert_(y2a[2] is not masked) + #assert_( y2a.mask is not m) + assert_(y2a._mask.__array_interface__ != m.__array_interface__) + assert_(allequal(y2a.mask, 0)) y3 = array(x1 * 1.0, mask=m) - self.assertTrue(filled(y3).dtype is (x1 * 1.0).dtype) + assert_(filled(y3).dtype is (x1 * 1.0).dtype) x4 = arange(4) x4[2] = masked @@ -447,8 +447,8 @@ class TestMaskedArray(TestCase): def test_copy_on_python_builtins(self): # Tests copy works on python builtins (issue#8019) - self.assertTrue(isMaskedArray(np.ma.copy([1,2,3]))) - self.assertTrue(isMaskedArray(np.ma.copy((1,2,3)))) + assert_(isMaskedArray(np.ma.copy([1,2,3]))) + assert_(isMaskedArray(np.ma.copy((1,2,3)))) def test_copy_immutable(self): # Tests that the copy method is immutable, GitHub issue #5247 @@ -518,7 +518,7 @@ class TestMaskedArray(TestCase): a_pickled = pickle.loads(a.dumps()) assert_equal(a_pickled._mask, a._mask) assert_equal(a_pickled, a) - self.assertTrue(isinstance(a_pickled._data, np.matrix)) + assert_(isinstance(a_pickled._data, np.matrix)) def test_pickling_maskedconstant(self): # Test pickling MaskedConstant @@ -558,19 +558,19 @@ class TestMaskedArray(TestCase): assert_equal(1.0, float(array(1))) assert_equal(1, int(array([[[1]]]))) assert_equal(1.0, float(array([[1]]))) - self.assertRaises(TypeError, float, array([1, 1])) + assert_raises(TypeError, float, array([1, 1])) with suppress_warnings() as sup: sup.filter(UserWarning, 'Warning: converting a masked element') assert_(np.isnan(float(array([1], mask=[1])))) a = array([1, 2, 3], mask=[1, 0, 0]) - self.assertRaises(TypeError, lambda: float(a)) + assert_raises(TypeError, lambda: float(a)) assert_equal(float(a[-1]), 3.) - self.assertTrue(np.isnan(float(a[0]))) - self.assertRaises(TypeError, int, a) + assert_(np.isnan(float(a[0]))) + assert_raises(TypeError, int, a) assert_equal(int(a[-1]), 3) - self.assertRaises(MAError, lambda:int(a[0])) + assert_raises(MAError, lambda:int(a[0])) def test_oddfeatures_1(self): # Test of other odd features @@ -679,8 +679,8 @@ class TestMaskedArray(TestCase): a = array(np.array([(0, 1, 2), (4, 5, 6)], order='F'), mask=np.array([(0, 0, 1), (1, 0, 0)], order='F'), order='F') # this is currently ignored - self.assertTrue(a.flags['F_CONTIGUOUS']) - self.assertTrue(a.filled(0).flags['F_CONTIGUOUS']) + assert_(a.flags['F_CONTIGUOUS']) + assert_(a.filled(0).flags['F_CONTIGUOUS']) def test_optinfo_propagation(self): # Checks that _optinfo dictionary isn't back-propagated @@ -768,14 +768,14 @@ class TestMaskedArray(TestCase): dtype=ndtype) # w/o mask f = a[0] - self.assertTrue(isinstance(f, mvoid)) + assert_(isinstance(f, mvoid)) assert_equal((f[0], f['a']), (1, 1)) assert_equal(f['b'], 2) # w/ mask f = a[1] - self.assertTrue(isinstance(f, mvoid)) - self.assertTrue(f[0] is masked) - self.assertTrue(f['a'] is masked) + assert_(isinstance(f, mvoid)) + assert_(f[0] is masked) + assert_(f['a'] is masked) assert_equal(f[1], 4) # exotic dtype @@ -862,10 +862,10 @@ class TestMaskedArray(TestCase): assert_(mx2[0] == 0.) -class TestMaskedArrayArithmetic(TestCase): +class TestMaskedArrayArithmetic(object): # Base test class for MaskedArrays. - def setUp(self): + def setup(self): # Base data definition. x = np.array([1., 1., 1., -2., pi/2.0, 4., 5., -10., 10., 1., 2., 3.]) y = np.array([5., 0., 3., 2., -1., -4., 0., -10., 10., 1., 0., 3.]) @@ -882,7 +882,7 @@ class TestMaskedArrayArithmetic(TestCase): self.err_status = np.geterr() np.seterr(divide='ignore', invalid='ignore') - def tearDown(self): + def teardown(self): np.seterr(**self.err_status) def test_basic_arithmetic(self): @@ -942,8 +942,8 @@ class TestMaskedArrayArithmetic(TestCase): # Tests mixed arithmetics. na = np.array([1]) ma = array([1]) - self.assertTrue(isinstance(na + ma, MaskedArray)) - self.assertTrue(isinstance(ma + na, MaskedArray)) + assert_(isinstance(na + ma, MaskedArray)) + assert_(isinstance(ma + na, MaskedArray)) def test_limits_arithmetic(self): tiny = np.finfo(float).tiny @@ -955,11 +955,11 @@ class TestMaskedArrayArithmetic(TestCase): # Tests some scalar arithmetics on MaskedArrays. # Masked singleton should remain masked no matter what xm = array(0, mask=1) - self.assertTrue((1 / array(0)).mask) - self.assertTrue((1 + xm).mask) - self.assertTrue((-xm).mask) - self.assertTrue(maximum(xm, xm).mask) - self.assertTrue(minimum(xm, xm).mask) + assert_((1 / array(0)).mask) + assert_((1 + xm).mask) + assert_((-xm).mask) + assert_(maximum(xm, xm).mask) + assert_(minimum(xm, xm).mask) def test_masked_singleton_equality(self): # Tests (in)equality on masked singleton @@ -1031,7 +1031,7 @@ class TestMaskedArrayArithmetic(TestCase): ott = array([0., 1., 2., 3.], mask=[1, 0, 0, 0]) res = count(ott) - self.assertTrue(res.dtype.type is np.intp) + assert_(res.dtype.type is np.intp) assert_equal(3, res) ott = ott.reshape((2, 2)) @@ -1082,19 +1082,19 @@ class TestMaskedArrayArithmetic(TestCase): def test_minimummaximum_func(self): a = np.ones((2, 2)) aminimum = minimum(a, a) - self.assertTrue(isinstance(aminimum, MaskedArray)) + assert_(isinstance(aminimum, MaskedArray)) assert_equal(aminimum, np.minimum(a, a)) aminimum = minimum.outer(a, a) - self.assertTrue(isinstance(aminimum, MaskedArray)) + assert_(isinstance(aminimum, MaskedArray)) assert_equal(aminimum, np.minimum.outer(a, a)) amaximum = maximum(a, a) - self.assertTrue(isinstance(amaximum, MaskedArray)) + assert_(isinstance(amaximum, MaskedArray)) assert_equal(amaximum, np.maximum(a, a)) amaximum = maximum.outer(a, a) - self.assertTrue(isinstance(amaximum, MaskedArray)) + assert_(isinstance(amaximum, MaskedArray)) assert_equal(amaximum, np.maximum.outer(a, a)) def test_minmax_reduce(self): @@ -1120,33 +1120,33 @@ class TestMaskedArrayArithmetic(TestCase): pass nout = np.empty((4,), dtype=float) result = npfunc(xm, axis=0, out=nout) - self.assertTrue(result is nout) + assert_(result is nout) # Use the ma version nout.fill(-999) result = mafunc(xm, axis=0, out=nout) - self.assertTrue(result is nout) + assert_(result is nout) def test_minmax_methods(self): # Additional tests on max/min (_, _, _, _, _, xm, _, _, _, _) = self.d xm.shape = (xm.size,) assert_equal(xm.max(), 10) - self.assertTrue(xm[0].max() is masked) - self.assertTrue(xm[0].max(0) is masked) - self.assertTrue(xm[0].max(-1) is masked) + assert_(xm[0].max() is masked) + assert_(xm[0].max(0) is masked) + assert_(xm[0].max(-1) is masked) assert_equal(xm.min(), -10.) - self.assertTrue(xm[0].min() is masked) - self.assertTrue(xm[0].min(0) is masked) - self.assertTrue(xm[0].min(-1) is masked) + assert_(xm[0].min() is masked) + assert_(xm[0].min(0) is masked) + assert_(xm[0].min(-1) is masked) assert_equal(xm.ptp(), 20.) - self.assertTrue(xm[0].ptp() is masked) - self.assertTrue(xm[0].ptp(0) is masked) - self.assertTrue(xm[0].ptp(-1) is masked) + assert_(xm[0].ptp() is masked) + assert_(xm[0].ptp(0) is masked) + assert_(xm[0].ptp(-1) is masked) x = array([1, 2, 3], mask=True) - self.assertTrue(x.min() is masked) - self.assertTrue(x.max() is masked) - self.assertTrue(x.ptp() is masked) + assert_(x.min() is masked) + assert_(x.max() is masked) + assert_(x.ptp() is masked) def test_addsumprod(self): # Tests add, sum, product. @@ -1503,7 +1503,7 @@ class TestMaskedArrayArithmetic(TestCase): assert_equal(a.mask, [0, 0, 0, 0, 1]) -class TestMaskedArrayAttributes(TestCase): +class TestMaskedArrayAttributes(object): def test_keepmask(self): # Tests the keep mask flag @@ -1531,8 +1531,8 @@ class TestMaskedArrayAttributes(TestCase): assert_equal(xh._data, [0, 10, 2, 3, 4]) assert_equal(xs._data, [0, 10, 2, 3, 40]) assert_equal(xs.mask, [0, 0, 0, 1, 0]) - self.assertTrue(xh._hardmask) - self.assertTrue(not xs._hardmask) + assert_(xh._hardmask) + assert_(not xs._hardmask) xh[1:4] = [10, 20, 30] xs[1:4] = [10, 20, 30] assert_equal(xh._data, [0, 10, 20, 3, 4]) @@ -1622,7 +1622,7 @@ class TestMaskedArrayAttributes(TestCase): test = masked_array(np.matrix([[1, 2, 3]]), mask=[0, 0, 1]) assert_equal(test.flat[1], 2) assert_equal(test.flat[2], masked) - self.assertTrue(np.all(test.flat[0:2] == test[0, 0:2])) + assert_(np.all(test.flat[0:2] == test[0, 0:2])) # Test flat on masked_matrices test = masked_array(np.matrix([[1, 2, 3]]), mask=[0, 0, 1]) test.flat = masked_array([3, 2, 1], mask=[1, 0, 0]) @@ -1696,7 +1696,7 @@ class TestMaskedArrayAttributes(TestCase): assert_equal(m._mask, np.ma.nomask) -class TestFillingValues(TestCase): +class TestFillingValues(object): def test_check_on_scalar(self): # Test _check_fill_value set to valid and invalid values @@ -1711,8 +1711,8 @@ class TestFillingValues(TestCase): assert_equal(fval, b"0") fval = _check_fill_value(None, "|S3") assert_equal(fval, default_fill_value(b"camelot!")) - self.assertRaises(TypeError, _check_fill_value, 1e+20, int) - self.assertRaises(TypeError, _check_fill_value, 'stuff', int) + assert_raises(TypeError, _check_fill_value, 1e+20, int) + assert_raises(TypeError, _check_fill_value, 'stuff', int) def test_check_on_fields(self): # Tests _check_fill_value with records @@ -1720,18 +1720,18 @@ class TestFillingValues(TestCase): ndtype = [('a', int), ('b', float), ('c', "|S3")] # A check on a list should return a single record fval = _check_fill_value([-999, -12345678.9, "???"], ndtype) - self.assertTrue(isinstance(fval, ndarray)) + assert_(isinstance(fval, ndarray)) assert_equal(fval.item(), [-999, -12345678.9, b"???"]) # A check on None should output the defaults fval = _check_fill_value(None, ndtype) - self.assertTrue(isinstance(fval, ndarray)) + assert_(isinstance(fval, ndarray)) assert_equal(fval.item(), [default_fill_value(0), default_fill_value(0.), asbytes(default_fill_value("0"))]) #.....Using a structured type as fill_value should work fill_val = np.array((-999, -12345678.9, "???"), dtype=ndtype) fval = _check_fill_value(fill_val, ndtype) - self.assertTrue(isinstance(fval, ndarray)) + assert_(isinstance(fval, ndarray)) assert_equal(fval.item(), [-999, -12345678.9, b"???"]) #.....Using a flexible type w/ a different type shouldn't matter @@ -1744,25 +1744,25 @@ class TestFillingValues(TestCase): # suppress deprecation warning in 1.12 (remove in 1.13) with assert_warns(FutureWarning): fval = _check_fill_value(fill_val, ndtype) - self.assertTrue(isinstance(fval, ndarray)) + assert_(isinstance(fval, ndarray)) assert_equal(fval.item(), [-999, -12345678.9, b"???"]) #.....Using an object-array shouldn't matter either fill_val = np.ndarray(shape=(1,), dtype=object) fill_val[0] = (-999, -12345678.9, b"???") fval = _check_fill_value(fill_val, object) - self.assertTrue(isinstance(fval, ndarray)) + assert_(isinstance(fval, ndarray)) assert_equal(fval.item(), [-999, -12345678.9, b"???"]) # NOTE: This test was never run properly as "fill_value" rather than # "fill_val" was assigned. Written properly, it fails. #fill_val = np.array((-999, -12345678.9, "???")) #fval = _check_fill_value(fill_val, ndtype) - #self.assertTrue(isinstance(fval, ndarray)) + #assert_(isinstance(fval, ndarray)) #assert_equal(fval.item(), [-999, -12345678.9, b"???"]) #.....One-field-only flexible type should work as well ndtype = [("a", int)] fval = _check_fill_value(-999999999, ndtype) - self.assertTrue(isinstance(fval, ndarray)) + assert_(isinstance(fval, ndarray)) assert_equal(fval.item(), (-999999999,)) def test_fillvalue_conversion(self): @@ -2027,17 +2027,17 @@ class TestFillingValues(TestCase): assert_equal(a["f1"].fill_value, default_fill_value("eggs")) -class TestUfuncs(TestCase): +class TestUfuncs(object): # Test class for the application of ufuncs on MaskedArrays. - def setUp(self): + def setup(self): # Base data definition. 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),) self.err_status = np.geterr() np.seterr(divide='ignore', invalid='ignore') - def tearDown(self): + def teardown(self): np.seterr(**self.err_status) def test_testUfuncRegression(self): @@ -2073,8 +2073,8 @@ class TestUfuncs(TestCase): def test_reduce(self): # Tests reduce on MaskedArrays. a = self.d[0] - self.assertTrue(not alltrue(a, axis=0)) - self.assertTrue(sometrue(a, axis=0)) + assert_(not alltrue(a, axis=0)) + assert_(sometrue(a, axis=0)) assert_equal(sum(a[:3], axis=0), 0) assert_equal(product(a, axis=0), 0) assert_equal(add.reduce(a), pi) @@ -2087,8 +2087,8 @@ class TestUfuncs(TestCase): assert_equal(amask.min(), 5) assert_equal(amask.max(0), a.max(0)) assert_equal(amask.min(0), [5, 6, 7, 8]) - self.assertTrue(amask.max(1)[0].mask) - self.assertTrue(amask.min(1)[0].mask) + assert_(amask.max(1)[0].mask) + assert_(amask.min(1)[0].mask) def test_ndarray_mask(self): # Check that the mask of the result is a ndarray (not a MaskedArray...) @@ -2098,14 +2098,14 @@ class TestUfuncs(TestCase): mask=[1, 0, 0, 0, 1]) assert_equal(test, control) assert_equal(test.mask, control.mask) - self.assertTrue(not isinstance(test.mask, MaskedArray)) + assert_(not isinstance(test.mask, MaskedArray)) def test_treatment_of_NotImplemented(self): # Check that NotImplemented is returned at appropriate places a = masked_array([1., 2.], mask=[1, 0]) - self.assertRaises(TypeError, operator.mul, a, "abc") - self.assertRaises(TypeError, operator.truediv, a, "abc") + assert_raises(TypeError, operator.mul, a, "abc") + assert_raises(TypeError, operator.truediv, a, "abc") class MyClass(object): __array_priority__ = a.__array_priority__ + 1 @@ -2171,10 +2171,10 @@ class TestUfuncs(TestCase): # also check that allclose uses ma ufuncs, to avoid warning allclose(m, 0.5) -class TestMaskedArrayInPlaceArithmetics(TestCase): +class TestMaskedArrayInPlaceArithmetics(object): # Test MaskedArray Arithmetics - def setUp(self): + def setup(self): x = arange(10) y = arange(10) xm = arange(10) @@ -2673,9 +2673,9 @@ class TestMaskedArrayInPlaceArithmetics(TestCase): assert_equal(len(w), 0, "Failed on type=%s." % t) -class TestMaskedArrayMethods(TestCase): +class TestMaskedArrayMethods(object): # Test class for miscellaneous MaskedArrays methods. - def setUp(self): + def setup(self): # Base data definition. x = np.array([8.375, 7.545, 8.828, 8.5, 1.757, 5.928, 8.43, 7.78, 9.865, 5.878, 8.979, 4.732, @@ -2729,25 +2729,25 @@ class TestMaskedArrayMethods(TestCase): # Tests allclose on arrays a = np.random.rand(10) b = a + np.random.rand(10) * 1e-8 - self.assertTrue(allclose(a, b)) + assert_(allclose(a, b)) # Test allclose w/ infs a[0] = np.inf - self.assertTrue(not allclose(a, b)) + assert_(not allclose(a, b)) b[0] = np.inf - self.assertTrue(allclose(a, b)) + assert_(allclose(a, b)) # Test allclose w/ masked a = masked_array(a) a[-1] = masked - self.assertTrue(allclose(a, b, masked_equal=True)) - self.assertTrue(not allclose(a, b, masked_equal=False)) + assert_(allclose(a, b, masked_equal=True)) + assert_(not allclose(a, b, masked_equal=False)) # Test comparison w/ scalar a *= 1e-8 a[0] = 0 - self.assertTrue(allclose(a, 0, masked_equal=True)) + assert_(allclose(a, 0, masked_equal=True)) # Test that the function works for MIN_INT integer typed arrays a = masked_array([np.iinfo(np.int_).min], dtype=np.int_) - self.assertTrue(allclose(a, a)) + assert_(allclose(a, a)) def test_allany(self): # Checks the any/all methods/functions. @@ -2761,15 +2761,15 @@ class TestMaskedArrayMethods(TestCase): mxbig = (mx > 0.5) mxsmall = (mx < 0.5) - self.assertFalse(mxbig.all()) - self.assertTrue(mxbig.any()) + assert_(not mxbig.all()) + assert_(mxbig.any()) assert_equal(mxbig.all(0), [False, False, True]) assert_equal(mxbig.all(1), [False, False, True]) assert_equal(mxbig.any(0), [False, False, True]) assert_equal(mxbig.any(1), [True, True, True]) - self.assertFalse(mxsmall.all()) - self.assertTrue(mxsmall.any()) + assert_(not mxsmall.all()) + assert_(mxsmall.any()) assert_equal(mxsmall.all(0), [True, True, False]) assert_equal(mxsmall.all(1), [False, False, False]) assert_equal(mxsmall.any(0), [True, True, False]) @@ -2787,15 +2787,15 @@ class TestMaskedArrayMethods(TestCase): mXbig = (mX > 0.5) mXsmall = (mX < 0.5) - self.assertFalse(mXbig.all()) - self.assertTrue(mXbig.any()) + assert_(not mXbig.all()) + assert_(mXbig.any()) assert_equal(mXbig.all(0), np.matrix([False, False, True])) assert_equal(mXbig.all(1), np.matrix([False, False, True]).T) assert_equal(mXbig.any(0), np.matrix([False, False, True])) assert_equal(mXbig.any(1), np.matrix([True, True, True]).T) - self.assertFalse(mXsmall.all()) - self.assertTrue(mXsmall.any()) + assert_(not mXsmall.all()) + assert_(mXsmall.any()) assert_equal(mXsmall.all(0), np.matrix([True, True, False])) assert_equal(mXsmall.all(1), np.matrix([False, False, False]).T) assert_equal(mXsmall.any(0), np.matrix([True, True, False])) @@ -2806,18 +2806,18 @@ class TestMaskedArrayMethods(TestCase): store = empty((), dtype=bool) full = array([1, 2, 3], mask=True) - self.assertTrue(full.all() is masked) + assert_(full.all() is masked) full.all(out=store) - self.assertTrue(store) - self.assertTrue(store._mask, True) - self.assertTrue(store is not masked) + assert_(store) + assert_(store._mask, True) + assert_(store is not masked) store = empty((), dtype=bool) - self.assertTrue(full.any() is masked) + assert_(full.any() is masked) full.any(out=store) - self.assertTrue(not store) - self.assertTrue(store._mask, True) - self.assertTrue(store is not masked) + assert_(not store) + assert_(store._mask, True) + assert_(store is not masked) def test_argmax_argmin(self): # Tests argmin & argmax on MaskedArrays. @@ -2902,7 +2902,7 @@ class TestMaskedArrayMethods(TestCase): a = array(np.matrix([1, 2, 3, 4]), mask=[0, 0, 0, 0]) b = a.compressed() assert_equal(b, a) - self.assertTrue(isinstance(b, np.matrix)) + assert_(isinstance(b, np.matrix)) a[0, 0] = masked b = a.compressed() assert_equal(b, [[2, 3, 4]]) @@ -2936,11 +2936,11 @@ class TestMaskedArrayMethods(TestCase): n = [0, 0, 0, 1, 1] m = make_mask(n) x = array(d, mask=m) - self.assertTrue(x[3] is masked) - self.assertTrue(x[4] is masked) + assert_(x[3] is masked) + assert_(x[4] is masked) x[[1, 4]] = [10, 40] - self.assertTrue(x[3] is masked) - self.assertTrue(x[4] is not masked) + assert_(x[3] is masked) + assert_(x[4] is not masked) assert_equal(x, [0, 10, 2, -1, 40]) x = masked_array(arange(10), mask=[1, 0, 0, 0, 0] * 2) @@ -2966,12 +2966,12 @@ class TestMaskedArrayMethods(TestCase): z = array([3., -1.], mask=[False, True]) x.put([1, 2], z) - self.assertTrue(x[0] is not masked) + assert_(x[0] is not masked) assert_equal(x[0], 0) - self.assertTrue(x[1] is not masked) + assert_(x[1] is not masked) assert_equal(x[1], 3) - self.assertTrue(x[2] is masked) - self.assertTrue(x[3] is not masked) + assert_(x[2] is masked) + assert_(x[3] is not masked) assert_equal(x[3], 0) def test_put_hardmask(self): @@ -3072,7 +3072,7 @@ class TestMaskedArrayMethods(TestCase): x = [1, 4, 2, 3] sortedx = sort(x) - self.assertTrue(not isinstance(sorted, MaskedArray)) + assert_(not isinstance(sorted, MaskedArray)) x = array([0, 1, -1, -2, 2], mask=nomask, dtype=np.int8) sortedx = sort(x, endwith=False) @@ -3186,7 +3186,7 @@ class TestMaskedArrayMethods(TestCase): assert_equal(data.squeeze(), [1, 2, 3]) assert_equal(data.squeeze()._mask, [1, 1, 1]) data = masked_array([[1]], mask=True) - self.assertTrue(data.squeeze() is masked) + assert_(data.squeeze() is masked) def test_swapaxes(self): # Tests swapaxes on MaskedArrays. @@ -3220,8 +3220,8 @@ class TestMaskedArrayMethods(TestCase): masked_array([[10, 20], [10, 20]], [[0, 1], [0, 1]])) # assert_equal crashes when passed np.ma.mask - self.assertIs(x[1], np.ma.masked) - self.assertIs(x.take(1), np.ma.masked) + assert_(x[1] is np.ma.masked) + assert_(x.take(1) is np.ma.masked) x = array([[10, 20, 30], [40, 50, 60]], mask=[[0, 0, 1], [1, 0, 0, ]]) assert_equal(x.take([0, 2], axis=1), @@ -3265,8 +3265,8 @@ class TestMaskedArrayMethods(TestCase): x = array(np.arange(12)) x[[1, -2]] = masked xlist = x.tolist() - self.assertTrue(xlist[1] is None) - self.assertTrue(xlist[-2] is None) + assert_(xlist[1] is None) + assert_(xlist[-2] is None) # ... on 2D x.shape = (3, 4) xlist = x.tolist() @@ -3370,9 +3370,9 @@ class TestMaskedArrayMethods(TestCase): assert_equal(MaskedArray.cumsum(marray.T, 0), control.cumsum(0)) -class TestMaskedArrayMathMethods(TestCase): +class TestMaskedArrayMathMethods(object): - def setUp(self): + def setup(self): # Base data definition. x = np.array([8.375, 7.545, 8.828, 8.5, 1.757, 5.928, 8.43, 7.78, 9.865, 5.878, 8.979, 4.732, @@ -3431,12 +3431,12 @@ class TestMaskedArrayMathMethods(TestCase): output.fill(-9999) result = npfunc(xm, axis=0, out=output) # ... the result should be the given output - self.assertTrue(result is output) + assert_(result is output) assert_equal(result, xmmeth(axis=0, out=output)) output = empty((3, 4), dtype=int) result = xmmeth(axis=0, out=output) - self.assertTrue(result is output) + assert_(result is output) def test_ptp(self): # Tests ptp on MaskedArrays. @@ -3568,31 +3568,31 @@ class TestMaskedArrayMathMethods(TestCase): x = array(arange(10), mask=True) for methodname in ('var', 'std'): method = getattr(x, methodname) - self.assertTrue(method() is masked) - self.assertTrue(method(0) is masked) - self.assertTrue(method(-1) is masked) + assert_(method() is masked) + assert_(method(0) is masked) + assert_(method(-1) is masked) # Using a masked array as explicit output method(out=mout) - self.assertTrue(mout is not masked) + assert_(mout is not masked) assert_equal(mout.mask, True) # Using a ndarray as explicit output method(out=nout) - self.assertTrue(np.isnan(nout)) + assert_(np.isnan(nout)) x = array(arange(10), mask=True) x[-1] = 9 for methodname in ('var', 'std'): method = getattr(x, methodname) - self.assertTrue(method(ddof=1) is masked) - self.assertTrue(method(0, ddof=1) is masked) - self.assertTrue(method(-1, ddof=1) is masked) + assert_(method(ddof=1) is masked) + assert_(method(0, ddof=1) is masked) + assert_(method(-1, ddof=1) is masked) # Using a masked array as explicit output method(out=mout, ddof=1) - self.assertTrue(mout is not masked) + assert_(mout is not masked) assert_equal(mout.mask, True) # Using a ndarray as explicit output method(out=nout, ddof=1) - self.assertTrue(np.isnan(nout)) + assert_(np.isnan(nout)) def test_varstd_ddof(self): a = array([[1, 1, 0], [1, 1, 0]], mask=[[0, 0, 1], [0, 0, 1]]) @@ -3641,9 +3641,9 @@ class TestMaskedArrayMathMethods(TestCase): assert_equal(a.max(1), [3, 6]) -class TestMaskedArrayMathMethodsComplex(TestCase): +class TestMaskedArrayMathMethodsComplex(object): # Test class for miscellaneous MaskedArrays methods. - def setUp(self): + def setup(self): # Base data definition. x = np.array([8.375j, 7.545j, 8.828j, 8.5j, 1.757j, 5.928, 8.43, 7.78, 9.865, 5.878, 8.979, 4.732, @@ -3694,10 +3694,10 @@ class TestMaskedArrayMathMethodsComplex(TestCase): mX[:, k].compressed().std()) -class TestMaskedArrayFunctions(TestCase): +class TestMaskedArrayFunctions(object): # Test class for miscellaneous functions. - def setUp(self): + def setup(self): x = np.array([1., 1., 1., -2., pi/2.0, 4., 5., -10., 10., 1., 2., 3.]) y = np.array([5., 0., 3., 2., -1., -4., 0., -10., 10., 1., 0., 3.]) m1 = [1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0] @@ -3821,12 +3821,12 @@ class TestMaskedArrayFunctions(TestCase): output.fill(-9999) result = np.round(xm, decimals=2, out=output) # ... the result should be the given output - self.assertTrue(result is output) + assert_(result is output) assert_equal(result, xm.round(decimals=2, out=output)) output = empty((3, 4), dtype=float) result = xm.round(decimals=2, out=output) - self.assertTrue(result is output) + assert_(result is output) def test_round_with_scalar(self): # Testing round with scalar/zero dimension input @@ -3855,13 +3855,13 @@ class TestMaskedArrayFunctions(TestCase): def test_identity(self): a = identity(5) - self.assertTrue(isinstance(a, MaskedArray)) + assert_(isinstance(a, MaskedArray)) assert_equal(a, np.identity(5)) def test_power(self): x = -1.1 assert_almost_equal(power(x, 2.), 1.21) - self.assertTrue(power(x, masked) is masked) + assert_(power(x, masked) is masked) x = array([-1.1, -1.1, 1.1, 1.1, 0.]) b = array([0.5, 2., 0.5, 2., -1.], mask=[0, 0, 0, 0, 1]) y = power(x, b) @@ -4069,7 +4069,7 @@ class TestMaskedArrayFunctions(TestCase): store = empty(4, dtype=int) chosen = choose([2, 3, 1, 0], choices, out=store) assert_equal(store, array([20, 31, 12, 3])) - self.assertTrue(store is chosen) + assert_(store is chosen) # Check with some masked indices + out store = empty(4, dtype=int) indices_ = array([2, 3, 1, 0], mask=[1, 0, 0, 1]) @@ -4090,25 +4090,25 @@ class TestMaskedArrayFunctions(TestCase): # Try the default b = a.reshape((5, 2)) assert_equal(b.shape, (5, 2)) - self.assertTrue(b.flags['C']) + assert_(b.flags['C']) # Try w/ arguments as list instead of tuple b = a.reshape(5, 2) assert_equal(b.shape, (5, 2)) - self.assertTrue(b.flags['C']) + assert_(b.flags['C']) # Try w/ order b = a.reshape((5, 2), order='F') assert_equal(b.shape, (5, 2)) - self.assertTrue(b.flags['F']) + assert_(b.flags['F']) # Try w/ order b = a.reshape(5, 2, order='F') assert_equal(b.shape, (5, 2)) - self.assertTrue(b.flags['F']) + assert_(b.flags['F']) c = np.reshape(a, (2, 5)) - self.assertTrue(isinstance(c, MaskedArray)) + assert_(isinstance(c, MaskedArray)) assert_equal(c.shape, (2, 5)) - self.assertTrue(c[0, 0] is masked) - self.assertTrue(c.flags['C']) + assert_(c[0, 0] is masked) + assert_(c.flags['C']) def test_make_mask_descr(self): # Flexible @@ -4331,9 +4331,9 @@ class TestMaskedArrayFunctions(TestCase): assert_equal(test, masked_equal([-1, -1, -1, -1, -1], -1)) -class TestMaskedFields(TestCase): +class TestMaskedFields(object): - def setUp(self): + def setup(self): ilist = [1, 2, 3, 4, 5] flist = [1.1, 2.2, 3.3, 4.4, 5.5] slist = ['one', 'two', 'three', 'four', 'five'] @@ -4432,7 +4432,7 @@ class TestMaskedFields(TestCase): test = a.view((float, 2), np.matrix) assert_equal(test, data) - self.assertTrue(isinstance(test, np.matrix)) + assert_(isinstance(test, np.matrix)) def test_getitem(self): ndtype = [('a', float), ('b', float)] @@ -4497,7 +4497,7 @@ class TestMaskedFields(TestCase): assert_equal(len(rec), len(self.data['ddtype'])) -class TestMaskedObjectArray(TestCase): +class TestMaskedObjectArray(object): def test_getitem(self): arr = np.ma.array([None, None]) @@ -4545,9 +4545,9 @@ class TestMaskedObjectArray(TestCase): assert_(arr[0] is np.ma.masked) -class TestMaskedView(TestCase): +class TestMaskedView(object): - def setUp(self): + def setup(self): iterator = list(zip(np.arange(10), np.random.rand(10))) data = np.array(iterator) a = array(iterator, dtype=[('a', float), ('b', float)]) @@ -4558,14 +4558,14 @@ class TestMaskedView(TestCase): def test_view_to_nothing(self): (data, a, controlmask) = self.data test = a.view() - self.assertTrue(isinstance(test, MaskedArray)) + assert_(isinstance(test, MaskedArray)) assert_equal(test._data, a._data) assert_equal(test._mask, a._mask) def test_view_to_type(self): (data, a, controlmask) = self.data test = a.view(np.ndarray) - self.assertTrue(not isinstance(test, MaskedArray)) + assert_(not isinstance(test, MaskedArray)) assert_equal(test, a._data) assert_equal_records(test, data.view(a.dtype).squeeze()) @@ -4573,7 +4573,7 @@ class TestMaskedView(TestCase): (data, a, controlmask) = self.data # View globally test = a.view(float) - self.assertTrue(isinstance(test, MaskedArray)) + assert_(isinstance(test, MaskedArray)) assert_equal(test, data.ravel()) assert_equal(test.mask, controlmask) @@ -4586,13 +4586,13 @@ class TestMaskedView(TestCase): assert_equal(test['B'], a['b']) test = a[0].view([('A', float), ('B', float)]) - self.assertTrue(isinstance(test, MaskedArray)) + assert_(isinstance(test, MaskedArray)) assert_equal(test.mask.dtype.names, ('A', 'B')) assert_equal(test['A'], a['a'][0]) assert_equal(test['B'], a['b'][0]) test = a[-1].view([('A', float), ('B', float)]) - self.assertTrue(isinstance(test, MaskedArray)) + assert_(isinstance(test, MaskedArray)) assert_equal(test.dtype.names, ('A', 'B')) assert_equal(test['A'], a['a'][-1]) assert_equal(test['B'], a['b'][-1]) @@ -4601,17 +4601,17 @@ class TestMaskedView(TestCase): (data, a, controlmask) = self.data # View globally test = a.view((float, 2)) - self.assertTrue(isinstance(test, MaskedArray)) + assert_(isinstance(test, MaskedArray)) assert_equal(test, data) assert_equal(test.mask, controlmask.reshape(-1, 2)) # View on 1 masked element test = a[0].view((float, 2)) - self.assertTrue(isinstance(test, MaskedArray)) + assert_(isinstance(test, MaskedArray)) assert_equal(test, data[0]) assert_equal(test.mask, (1, 0)) # View on 1 unmasked element test = a[-1].view((float, 2)) - self.assertTrue(isinstance(test, MaskedArray)) + assert_(isinstance(test, MaskedArray)) assert_equal(test, data[-1]) def test_view_to_dtype_and_type(self): @@ -4619,10 +4619,10 @@ class TestMaskedView(TestCase): test = a.view((float, 2), np.matrix) assert_equal(test, data) - self.assertTrue(isinstance(test, np.matrix)) - self.assertTrue(not isinstance(test, MaskedArray)) + assert_(isinstance(test, np.matrix)) + assert_(not isinstance(test, MaskedArray)) -class TestOptionalArgs(TestCase): +class TestOptionalArgs(object): def test_ndarrayfuncs(self): # test axis arg behaves the same as ndarray (including multiple axes) @@ -4709,10 +4709,10 @@ class TestOptionalArgs(TestCase): assert_raises(np.AxisError, count, np.ma.array(1), axis=1) -class TestMaskedConstant(TestCase): +class TestMaskedConstant(object): def _do_add_test(self, add): # sanity check - self.assertIs(add(np.ma.masked, 1), np.ma.masked) + assert_(add(np.ma.masked, 1) is np.ma.masked) # now try with a vector vector = np.array([1, 2, 3]) diff --git a/numpy/ma/tests/test_deprecations.py b/numpy/ma/tests/test_deprecations.py index 24dd7cb8d..23c095470 100644 --- a/numpy/ma/tests/test_deprecations.py +++ b/numpy/ma/tests/test_deprecations.py @@ -4,11 +4,11 @@ from __future__ import division, absolute_import, print_function import numpy as np -from numpy.testing import TestCase, run_module_suite, assert_warns +from numpy.testing import run_module_suite, assert_warns from numpy.ma.testutils import assert_equal from numpy.ma.core import MaskedArrayFutureWarning -class TestArgsort(TestCase): +class TestArgsort(object): """ gh-8701 """ def _test_base(self, argsort, cls): arr_0d = np.array(1).view(cls) @@ -37,7 +37,7 @@ class TestArgsort(TestCase): return self._test_base(np.ma.MaskedArray.argsort, np.ma.MaskedArray) -class TestMinimumMaximum(TestCase): +class TestMinimumMaximum(object): def test_minimum(self): assert_warns(DeprecationWarning, np.ma.minimum, np.ma.array([1, 2])) diff --git a/numpy/ma/tests/test_extras.py b/numpy/ma/tests/test_extras.py index 18198d4a4..897a0fd88 100644 --- a/numpy/ma/tests/test_extras.py +++ b/numpy/ma/tests/test_extras.py @@ -14,8 +14,7 @@ import itertools import numpy as np from numpy.testing import ( - TestCase, run_module_suite, assert_warns, suppress_warnings, - assert_raises + run_module_suite, assert_warns, suppress_warnings, assert_raises, ) from numpy.ma.testutils import ( assert_, assert_array_equal, assert_equal, assert_almost_equal @@ -35,7 +34,7 @@ from numpy.ma.extras import ( import numpy.ma.extras as mae -class TestGeneric(TestCase): +class TestGeneric(object): # def test_masked_all(self): # Tests masked_all @@ -140,7 +139,7 @@ class TestGeneric(TestCase): assert_equal(test, None) -class TestAverage(TestCase): +class TestAverage(object): # Several tests of average. Why so many ? Good point... def test_testAverage1(self): # Test of average. @@ -149,7 +148,7 @@ class TestAverage(TestCase): assert_equal(2.0, average(ott, weights=[1., 1., 2., 1.])) result, wts = average(ott, weights=[1., 1., 2., 1.], returned=1) assert_equal(2.0, result) - self.assertTrue(wts == 4.0) + assert_(wts == 4.0) ott[:] = masked assert_equal(average(ott, axis=0).mask, [True]) ott = array([0., 1., 2., 3.], mask=[True, False, False, False]) @@ -271,7 +270,7 @@ class TestAverage(TestCase): assert_almost_equal(wav1.imag, expected1.imag) -class TestConcatenator(TestCase): +class TestConcatenator(object): # Tests for mr_, the equivalent of r_ for masked arrays. def test_1d(self): @@ -281,7 +280,7 @@ class TestConcatenator(TestCase): m = [1, 0, 0, 0, 0] d = masked_array(b, mask=m) c = mr_[d, 0, 0, d] - self.assertTrue(isinstance(c, MaskedArray)) + assert_(isinstance(c, MaskedArray)) assert_array_equal(c, [1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1]) assert_array_equal(c.mask, mr_[m, 0, 0, m]) @@ -295,12 +294,12 @@ class TestConcatenator(TestCase): b_2 = masked_array(a_2, mask=m_2) # append columns d = mr_['1', b_1, b_2] - self.assertTrue(d.shape == (5, 10)) + assert_(d.shape == (5, 10)) assert_array_equal(d[:, :5], b_1) assert_array_equal(d[:, 5:], b_2) assert_array_equal(d.mask, np.r_['1', m_1, m_2]) d = mr_[b_1, b_2] - self.assertTrue(d.shape == (10, 5)) + assert_(d.shape == (10, 5)) assert_array_equal(d[:5,:], b_1) assert_array_equal(d[5:,:], b_2) assert_array_equal(d.mask, np.r_[m_1, m_2]) @@ -318,7 +317,7 @@ class TestConcatenator(TestCase): assert_equal(type(actual.data), type(expected.data)) -class TestNotMasked(TestCase): +class TestNotMasked(object): # Tests notmasked_edges and notmasked_contiguous. def test_edges(self): @@ -367,19 +366,19 @@ class TestNotMasked(TestCase): assert_equal(tmp[-3], slice(0, 4, None)) # tmp = notmasked_contiguous(a, 0) - self.assertTrue(len(tmp[-1]) == 1) - self.assertTrue(tmp[-2] is None) + assert_(len(tmp[-1]) == 1) + assert_(tmp[-2] is None) assert_equal(tmp[-3], tmp[-1]) - self.assertTrue(len(tmp[0]) == 2) + assert_(len(tmp[0]) == 2) # tmp = notmasked_contiguous(a, 1) assert_equal(tmp[0][-1], slice(0, 4, None)) - self.assertTrue(tmp[1] is None) + assert_(tmp[1] is None) assert_equal(tmp[2][-1], slice(7, 8, None)) assert_equal(tmp[2][-2], slice(0, 6, None)) -class TestCompressFunctions(TestCase): +class TestCompressFunctions(object): def test_compress_nd(self): # Tests compress_nd @@ -538,12 +537,12 @@ class TestCompressFunctions(TestCase): assert_equal(mask_rowcols(x, 1,).mask, [[1, 1, 0], [1, 1, 0], [1, 1, 0]]) x = array(x._data, mask=[[1, 0, 0], [0, 1, 0], [0, 0, 1]]) - self.assertTrue(mask_rowcols(x).all() is masked) - self.assertTrue(mask_rowcols(x, 0).all() is masked) - self.assertTrue(mask_rowcols(x, 1).all() is masked) - self.assertTrue(mask_rowcols(x).mask.all()) - self.assertTrue(mask_rowcols(x, 0).mask.all()) - self.assertTrue(mask_rowcols(x, 1).mask.all()) + assert_(mask_rowcols(x).all() is masked) + assert_(mask_rowcols(x, 0).all() is masked) + assert_(mask_rowcols(x, 1).all() is masked) + assert_(mask_rowcols(x).mask.all()) + assert_(mask_rowcols(x, 0).mask.all()) + assert_(mask_rowcols(x, 1).mask.all()) def test_dot(self): # Tests dot product @@ -632,7 +631,7 @@ class TestCompressFunctions(TestCase): assert_equal(a, res) -class TestApplyAlongAxis(TestCase): +class TestApplyAlongAxis(object): # Tests 2D functions def test_3d(self): a = arange(12.).reshape(2, 2, 3) @@ -654,7 +653,7 @@ class TestApplyAlongAxis(TestCase): assert_equal(xa, [[2, 5], [8, 11]]) -class TestApplyOverAxes(TestCase): +class TestApplyOverAxes(object): # Tests apply_over_axes def test_basic(self): a = arange(24).reshape(2, 3, 4) @@ -667,7 +666,7 @@ class TestApplyOverAxes(TestCase): assert_equal(test, ctrl) -class TestMedian(TestCase): +class TestMedian(object): def test_pytype(self): r = np.ma.median([[np.inf, np.inf], [np.inf, np.inf]], axis=-1) assert_equal(r, np.inf) @@ -1069,9 +1068,9 @@ class TestMedian(TestCase): assert_(type(np.ma.median(o.astype(object))), float) -class TestCov(TestCase): +class TestCov(object): - def setUp(self): + def setup(self): self.data = array(np.random.rand(12)) def test_1d_without_missing(self): @@ -1136,9 +1135,9 @@ class TestCov(TestCase): x.shape[0] / frac)) -class TestCorrcoef(TestCase): +class TestCorrcoef(object): - def setUp(self): + def setup(self): self.data = array(np.random.rand(12)) self.data2 = array(np.random.rand(12)) @@ -1243,7 +1242,7 @@ class TestCorrcoef(TestCase): control[:-1, :-1]) -class TestPolynomial(TestCase): +class TestPolynomial(object): # def test_polyfit(self): # Tests polyfit @@ -1301,13 +1300,13 @@ class TestPolynomial(TestCase): assert_almost_equal(a, a_) -class TestArraySetOps(TestCase): +class TestArraySetOps(object): def test_unique_onlist(self): # Test unique on list data = [1, 1, 1, 2, 2, 3] test = unique(data, return_index=True, return_inverse=True) - self.assertTrue(isinstance(test[0], MaskedArray)) + assert_(isinstance(test[0], MaskedArray)) assert_equal(test[0], masked_array([1, 2, 3], mask=[0, 0, 0])) assert_equal(test[1], [0, 3, 5]) assert_equal(test[2], [0, 0, 0, 1, 1, 2]) @@ -1404,13 +1403,13 @@ class TestArraySetOps(TestCase): test = ediff1d(x) control = array([1, 1, 1, 1], mask=[0, 0, 0, 0]) assert_equal(test, control) - self.assertTrue(isinstance(test, MaskedArray)) + assert_(isinstance(test, MaskedArray)) assert_equal(test.filled(0), control.filled(0)) assert_equal(test.mask, control.mask) # test = ediff1d(x, to_end=masked, to_begin=masked) control = array([0, 1, 1, 1, 1, 0], mask=[1, 0, 0, 0, 0, 1]) - self.assertTrue(isinstance(test, MaskedArray)) + assert_(isinstance(test, MaskedArray)) assert_equal(test.filled(0), control.filled(0)) assert_equal(test.mask, control.mask) @@ -1525,7 +1524,7 @@ class TestArraySetOps(TestCase): assert_array_equal(setdiff1d(a, b), np.array(['c'])) -class TestShapeBase(TestCase): +class TestShapeBase(object): def test_atleast_2d(self): # Test atleast_2d diff --git a/numpy/ma/tests/test_mrecords.py b/numpy/ma/tests/test_mrecords.py index 785733400..da22f8dcd 100644 --- a/numpy/ma/tests/test_mrecords.py +++ b/numpy/ma/tests/test_mrecords.py @@ -14,7 +14,7 @@ import numpy as np import numpy.ma as ma from numpy import recarray from numpy.ma import masked, nomask -from numpy.testing import TestCase, run_module_suite, temppath +from numpy.testing import run_module_suite, temppath from numpy.core.records import ( fromrecords as recfromrecords, fromarrays as recfromarrays ) @@ -28,21 +28,14 @@ from numpy.ma.testutils import ( ) -class TestMRecords(TestCase): - # Base test class for MaskedArrays. - def __init__(self, *args, **kwds): - TestCase.__init__(self, *args, **kwds) - self.setup() +class TestMRecords(object): - def setup(self): - # Generic setup - ilist = [1, 2, 3, 4, 5] - flist = [1.1, 2.2, 3.3, 4.4, 5.5] - slist = [b'one', b'two', b'three', b'four', b'five'] - ddtype = [('a', int), ('b', float), ('c', '|S8')] - mask = [0, 1, 0, 0, 1] - self.base = ma.array(list(zip(ilist, flist, slist)), - mask=mask, dtype=ddtype) + ilist = [1, 2, 3, 4, 5] + flist = [1.1, 2.2, 3.3, 4.4, 5.5] + slist = [b'one', b'two', b'three', b'four', b'five'] + ddtype = [('a', int), ('b', float), ('c', '|S8')] + mask = [0, 1, 0, 0, 1] + base = ma.array(list(zip(ilist, flist, slist)), mask=mask, dtype=ddtype) def test_byview(self): # Test creation by view @@ -279,16 +272,16 @@ class TestMRecords(TestCase): base = self.base.copy() mbase = base.view(mrecarray) mbase.harden_mask() - self.assertTrue(mbase._hardmask) + assert_(mbase._hardmask) mbase.mask = nomask assert_equal_records(mbase._mask, base._mask) mbase.soften_mask() - self.assertTrue(not mbase._hardmask) + assert_(not mbase._hardmask) mbase.mask = nomask # So, the mask of a field is no longer set to nomask... assert_equal_records(mbase._mask, ma.make_mask_none(base.shape, base.dtype)) - self.assertTrue(ma.make_mask(mbase['b']._mask) is nomask) + assert_(ma.make_mask(mbase['b']._mask) is nomask) assert_equal(mbase['a']._mask, mbase['b']._mask) def test_pickling(self): @@ -356,9 +349,9 @@ class TestMRecords(TestCase): dtype=mult.dtype)) -class TestView(TestCase): +class TestView(object): - def setUp(self): + def setup(self): (a, b) = (np.arange(10), np.random.rand(10)) ndtype = [('a', np.float), ('b', np.float)] arr = np.array(list(zip(a, b)), dtype=ndtype) @@ -370,7 +363,7 @@ class TestView(TestCase): def test_view_by_itself(self): (mrec, a, b, arr) = self.data test = mrec.view() - self.assertTrue(isinstance(test, MaskedRecords)) + assert_(isinstance(test, MaskedRecords)) assert_equal_records(test, mrec) assert_equal_records(test._mask, mrec._mask) @@ -378,40 +371,34 @@ class TestView(TestCase): (mrec, a, b, arr) = self.data ntype = (np.float, 2) test = mrec.view(ntype) - self.assertTrue(isinstance(test, ma.MaskedArray)) + assert_(isinstance(test, ma.MaskedArray)) assert_equal(test, np.array(list(zip(a, b)), dtype=np.float)) - self.assertTrue(test[3, 1] is ma.masked) + assert_(test[3, 1] is ma.masked) def test_view_flexible_type(self): (mrec, a, b, arr) = self.data alttype = [('A', np.float), ('B', np.float)] test = mrec.view(alttype) - self.assertTrue(isinstance(test, MaskedRecords)) + assert_(isinstance(test, MaskedRecords)) assert_equal_records(test, arr.view(alttype)) - self.assertTrue(test['B'][3] is masked) + assert_(test['B'][3] is masked) assert_equal(test.dtype, np.dtype(alttype)) - self.assertTrue(test._fill_value is None) + assert_(test._fill_value is None) ############################################################################## -class TestMRecordsImport(TestCase): - # Base test class for MaskedArrays. - def __init__(self, *args, **kwds): - TestCase.__init__(self, *args, **kwds) - self.setup() - - def setup(self): - # Generic setup - _a = ma.array([1, 2, 3], mask=[0, 0, 1], dtype=int) - _b = ma.array([1.1, 2.2, 3.3], mask=[0, 0, 1], dtype=float) - _c = ma.array([b'one', b'two', b'three'], - mask=[0, 0, 1], dtype='|S8') - ddtype = [('a', int), ('b', float), ('c', '|S8')] - mrec = fromarrays([_a, _b, _c], dtype=ddtype, - fill_value=(b'99999', b'99999.', - b'N/A')) - nrec = recfromarrays((_a._data, _b._data, _c._data), dtype=ddtype) - self.data = (mrec, nrec, ddtype) +class TestMRecordsImport(object): + + _a = ma.array([1, 2, 3], mask=[0, 0, 1], dtype=int) + _b = ma.array([1.1, 2.2, 3.3], mask=[0, 0, 1], dtype=float) + _c = ma.array([b'one', b'two', b'three'], + mask=[0, 0, 1], dtype='|S8') + ddtype = [('a', int), ('b', float), ('c', '|S8')] + mrec = fromarrays([_a, _b, _c], dtype=ddtype, + fill_value=(b'99999', b'99999.', + b'N/A')) + nrec = recfromarrays((_a._data, _b._data, _c._data), dtype=ddtype) + data = (mrec, nrec, ddtype) def test_fromarrays(self): _a = ma.array([1, 2, 3], mask=[0, 0, 1], dtype=int) @@ -485,7 +472,7 @@ class TestMRecordsImport(TestCase): with open(path, 'w') as f: f.write(fcontent) mrectxt = fromtextfile(path, delimitor=',', varnames='ABCDEFG') - self.assertTrue(isinstance(mrectxt, MaskedRecords)) + assert_(isinstance(mrectxt, MaskedRecords)) assert_equal(mrectxt.F, [1, 1, 1, 1]) assert_equal(mrectxt.E._mask, [1, 1, 1, 1]) assert_equal(mrectxt.C, [1, 2, 3.e+5, -1e-10]) diff --git a/numpy/ma/tests/test_old_ma.py b/numpy/ma/tests/test_old_ma.py index 769e281d4..9152e8d73 100644 --- a/numpy/ma/tests/test_old_ma.py +++ b/numpy/ma/tests/test_old_ma.py @@ -5,7 +5,9 @@ from functools import reduce import numpy as np import numpy.core.umath as umath import numpy.core.fromnumeric as fromnumeric -from numpy.testing import TestCase, run_module_suite, assert_ +from numpy.testing import ( + run_module_suite, assert_, assert_raises, assert_equal, + ) from numpy.ma.testutils import assert_array_equal from numpy.ma import ( MaskType, MaskedArray, absolute, add, all, allclose, allequal, alltrue, @@ -31,9 +33,9 @@ def eq(v, w, msg=''): return result -class TestMa(TestCase): +class TestMa(object): - def setUp(self): + def setup(self): x = np.array([1., 1., 1., -2., pi/2.0, 4., 5., -10., 10., 1., 2., 3.]) y = np.array([5., 0., 3., 2., -1., -4., 0., -10., 10., 1., 0., 3.]) a10 = 10. @@ -51,16 +53,16 @@ class TestMa(TestCase): def test_testBasic1d(self): # Test of basic array creation and properties in 1 dimension. (x, y, a10, m1, m2, xm, ym, z, zm, xf, s) = self.d - self.assertFalse(isMaskedArray(x)) - self.assertTrue(isMaskedArray(xm)) - self.assertEqual(shape(xm), s) - self.assertEqual(xm.shape, s) - self.assertEqual(xm.dtype, x.dtype) - self.assertEqual(xm.size, reduce(lambda x, y:x * y, s)) - self.assertEqual(count(xm), len(m1) - reduce(lambda x, y:x + y, m1)) - self.assertTrue(eq(xm, xf)) - self.assertTrue(eq(filled(xm, 1.e20), xf)) - self.assertTrue(eq(x, xm)) + assert_(not isMaskedArray(x)) + assert_(isMaskedArray(xm)) + assert_equal(shape(xm), s) + assert_equal(xm.shape, s) + assert_equal(xm.dtype, x.dtype) + assert_equal(xm.size, reduce(lambda x, y:x * y, s)) + assert_equal(count(xm), len(m1) - reduce(lambda x, y:x + y, m1)) + assert_(eq(xm, xf)) + assert_(eq(filled(xm, 1.e20), xf)) + assert_(eq(x, xm)) def test_testBasic2d(self): # Test of basic array creation and properties in 2 dimensions. @@ -72,107 +74,107 @@ class TestMa(TestCase): ym.shape = s xf.shape = s - self.assertFalse(isMaskedArray(x)) - self.assertTrue(isMaskedArray(xm)) - self.assertEqual(shape(xm), s) - self.assertEqual(xm.shape, s) - self.assertEqual(xm.size, reduce(lambda x, y:x * y, s)) - self.assertEqual(count(xm), + assert_(not isMaskedArray(x)) + assert_(isMaskedArray(xm)) + assert_equal(shape(xm), s) + assert_equal(xm.shape, s) + assert_equal(xm.size, reduce(lambda x, y:x * y, s)) + assert_equal(count(xm), len(m1) - reduce(lambda x, y:x + y, m1)) - self.assertTrue(eq(xm, xf)) - self.assertTrue(eq(filled(xm, 1.e20), xf)) - self.assertTrue(eq(x, xm)) - self.setUp() + assert_(eq(xm, xf)) + assert_(eq(filled(xm, 1.e20), xf)) + assert_(eq(x, xm)) + self.setup() def test_testArithmetic(self): # Test of basic arithmetic. (x, y, a10, m1, m2, xm, ym, z, zm, xf, s) = self.d a2d = array([[1, 2], [0, 4]]) a2dm = masked_array(a2d, [[0, 0], [1, 0]]) - self.assertTrue(eq(a2d * a2d, a2d * a2dm)) - self.assertTrue(eq(a2d + a2d, a2d + a2dm)) - self.assertTrue(eq(a2d - a2d, a2d - a2dm)) + assert_(eq(a2d * a2d, a2d * a2dm)) + assert_(eq(a2d + a2d, a2d + a2dm)) + assert_(eq(a2d - a2d, a2d - a2dm)) for s in [(12,), (4, 3), (2, 6)]: x = x.reshape(s) y = y.reshape(s) xm = xm.reshape(s) ym = ym.reshape(s) xf = xf.reshape(s) - self.assertTrue(eq(-x, -xm)) - self.assertTrue(eq(x + y, xm + ym)) - self.assertTrue(eq(x - y, xm - ym)) - self.assertTrue(eq(x * y, xm * ym)) + assert_(eq(-x, -xm)) + assert_(eq(x + y, xm + ym)) + assert_(eq(x - y, xm - ym)) + assert_(eq(x * y, xm * ym)) with np.errstate(divide='ignore', invalid='ignore'): - self.assertTrue(eq(x / y, xm / ym)) - self.assertTrue(eq(a10 + y, a10 + ym)) - self.assertTrue(eq(a10 - y, a10 - ym)) - self.assertTrue(eq(a10 * y, a10 * ym)) + assert_(eq(x / y, xm / ym)) + assert_(eq(a10 + y, a10 + ym)) + assert_(eq(a10 - y, a10 - ym)) + assert_(eq(a10 * y, a10 * ym)) with np.errstate(divide='ignore', invalid='ignore'): - self.assertTrue(eq(a10 / y, a10 / ym)) - self.assertTrue(eq(x + a10, xm + a10)) - self.assertTrue(eq(x - a10, xm - a10)) - self.assertTrue(eq(x * a10, xm * a10)) - self.assertTrue(eq(x / a10, xm / a10)) - self.assertTrue(eq(x ** 2, xm ** 2)) - self.assertTrue(eq(abs(x) ** 2.5, abs(xm) ** 2.5)) - self.assertTrue(eq(x ** y, xm ** ym)) - self.assertTrue(eq(np.add(x, y), add(xm, ym))) - self.assertTrue(eq(np.subtract(x, y), subtract(xm, ym))) - self.assertTrue(eq(np.multiply(x, y), multiply(xm, ym))) + assert_(eq(a10 / y, a10 / ym)) + assert_(eq(x + a10, xm + a10)) + assert_(eq(x - a10, xm - a10)) + assert_(eq(x * a10, xm * a10)) + assert_(eq(x / a10, xm / a10)) + assert_(eq(x ** 2, xm ** 2)) + assert_(eq(abs(x) ** 2.5, abs(xm) ** 2.5)) + assert_(eq(x ** y, xm ** ym)) + assert_(eq(np.add(x, y), add(xm, ym))) + assert_(eq(np.subtract(x, y), subtract(xm, ym))) + assert_(eq(np.multiply(x, y), multiply(xm, ym))) with np.errstate(divide='ignore', invalid='ignore'): - self.assertTrue(eq(np.divide(x, y), divide(xm, ym))) + assert_(eq(np.divide(x, y), divide(xm, ym))) def test_testMixedArithmetic(self): na = np.array([1]) ma = array([1]) - self.assertTrue(isinstance(na + ma, MaskedArray)) - self.assertTrue(isinstance(ma + na, MaskedArray)) + assert_(isinstance(na + ma, MaskedArray)) + assert_(isinstance(ma + na, MaskedArray)) def test_testUfuncs1(self): # Test various functions such as sin, cos. (x, y, a10, m1, m2, xm, ym, z, zm, xf, s) = self.d - self.assertTrue(eq(np.cos(x), cos(xm))) - self.assertTrue(eq(np.cosh(x), cosh(xm))) - self.assertTrue(eq(np.sin(x), sin(xm))) - self.assertTrue(eq(np.sinh(x), sinh(xm))) - self.assertTrue(eq(np.tan(x), tan(xm))) - self.assertTrue(eq(np.tanh(x), tanh(xm))) + assert_(eq(np.cos(x), cos(xm))) + assert_(eq(np.cosh(x), cosh(xm))) + assert_(eq(np.sin(x), sin(xm))) + assert_(eq(np.sinh(x), sinh(xm))) + assert_(eq(np.tan(x), tan(xm))) + assert_(eq(np.tanh(x), tanh(xm))) with np.errstate(divide='ignore', invalid='ignore'): - self.assertTrue(eq(np.sqrt(abs(x)), sqrt(xm))) - self.assertTrue(eq(np.log(abs(x)), log(xm))) - self.assertTrue(eq(np.log10(abs(x)), log10(xm))) - self.assertTrue(eq(np.exp(x), exp(xm))) - self.assertTrue(eq(np.arcsin(z), arcsin(zm))) - self.assertTrue(eq(np.arccos(z), arccos(zm))) - self.assertTrue(eq(np.arctan(z), arctan(zm))) - self.assertTrue(eq(np.arctan2(x, y), arctan2(xm, ym))) - self.assertTrue(eq(np.absolute(x), absolute(xm))) - self.assertTrue(eq(np.equal(x, y), equal(xm, ym))) - self.assertTrue(eq(np.not_equal(x, y), not_equal(xm, ym))) - self.assertTrue(eq(np.less(x, y), less(xm, ym))) - self.assertTrue(eq(np.greater(x, y), greater(xm, ym))) - self.assertTrue(eq(np.less_equal(x, y), less_equal(xm, ym))) - self.assertTrue(eq(np.greater_equal(x, y), greater_equal(xm, ym))) - self.assertTrue(eq(np.conjugate(x), conjugate(xm))) - self.assertTrue(eq(np.concatenate((x, y)), concatenate((xm, ym)))) - self.assertTrue(eq(np.concatenate((x, y)), concatenate((x, y)))) - self.assertTrue(eq(np.concatenate((x, y)), concatenate((xm, y)))) - self.assertTrue(eq(np.concatenate((x, y, x)), concatenate((x, ym, x)))) + assert_(eq(np.sqrt(abs(x)), sqrt(xm))) + assert_(eq(np.log(abs(x)), log(xm))) + assert_(eq(np.log10(abs(x)), log10(xm))) + assert_(eq(np.exp(x), exp(xm))) + assert_(eq(np.arcsin(z), arcsin(zm))) + assert_(eq(np.arccos(z), arccos(zm))) + assert_(eq(np.arctan(z), arctan(zm))) + assert_(eq(np.arctan2(x, y), arctan2(xm, ym))) + assert_(eq(np.absolute(x), absolute(xm))) + assert_(eq(np.equal(x, y), equal(xm, ym))) + assert_(eq(np.not_equal(x, y), not_equal(xm, ym))) + assert_(eq(np.less(x, y), less(xm, ym))) + assert_(eq(np.greater(x, y), greater(xm, ym))) + assert_(eq(np.less_equal(x, y), less_equal(xm, ym))) + assert_(eq(np.greater_equal(x, y), greater_equal(xm, ym))) + assert_(eq(np.conjugate(x), conjugate(xm))) + assert_(eq(np.concatenate((x, y)), concatenate((xm, ym)))) + assert_(eq(np.concatenate((x, y)), concatenate((x, y)))) + assert_(eq(np.concatenate((x, y)), concatenate((xm, y)))) + assert_(eq(np.concatenate((x, y, x)), concatenate((x, ym, x)))) def test_xtestCount(self): # Test count ott = array([0., 1., 2., 3.], mask=[1, 0, 0, 0]) - self.assertTrue(count(ott).dtype.type is np.intp) - self.assertEqual(3, count(ott)) - self.assertEqual(1, count(1)) - self.assertTrue(eq(0, array(1, mask=[1]))) + assert_(count(ott).dtype.type is np.intp) + assert_equal(3, count(ott)) + assert_equal(1, count(1)) + assert_(eq(0, array(1, mask=[1]))) ott = ott.reshape((2, 2)) - self.assertTrue(count(ott).dtype.type is np.intp) + assert_(count(ott).dtype.type is np.intp) assert_(isinstance(count(ott, 0), np.ndarray)) - self.assertTrue(count(ott).dtype.type is np.intp) - self.assertTrue(eq(3, count(ott))) + assert_(count(ott).dtype.type is np.intp) + assert_(eq(3, count(ott))) assert_(getmask(count(ott, 0)) is nomask) - self.assertTrue(eq([1, 2], count(ott, 0))) + assert_(eq([1, 2], count(ott, 0))) def test_testMinMax(self): # Test minimum and maximum. @@ -181,29 +183,29 @@ class TestMa(TestCase): xmr = ravel(xm) # true because of careful selection of data - self.assertTrue(eq(max(xr), maximum.reduce(xmr))) - self.assertTrue(eq(min(xr), minimum.reduce(xmr))) + assert_(eq(max(xr), maximum.reduce(xmr))) + assert_(eq(min(xr), minimum.reduce(xmr))) def test_testAddSumProd(self): # Test add, sum, product. (x, y, a10, m1, m2, xm, ym, z, zm, xf, s) = self.d - self.assertTrue(eq(np.add.reduce(x), add.reduce(x))) - self.assertTrue(eq(np.add.accumulate(x), add.accumulate(x))) - self.assertTrue(eq(4, sum(array(4), axis=0))) - self.assertTrue(eq(4, sum(array(4), axis=0))) - self.assertTrue(eq(np.sum(x, axis=0), sum(x, axis=0))) - self.assertTrue(eq(np.sum(filled(xm, 0), axis=0), sum(xm, axis=0))) - self.assertTrue(eq(np.sum(x, 0), sum(x, 0))) - self.assertTrue(eq(np.product(x, axis=0), product(x, axis=0))) - self.assertTrue(eq(np.product(x, 0), product(x, 0))) - self.assertTrue(eq(np.product(filled(xm, 1), axis=0), + assert_(eq(np.add.reduce(x), add.reduce(x))) + assert_(eq(np.add.accumulate(x), add.accumulate(x))) + assert_(eq(4, sum(array(4), axis=0))) + assert_(eq(4, sum(array(4), axis=0))) + assert_(eq(np.sum(x, axis=0), sum(x, axis=0))) + assert_(eq(np.sum(filled(xm, 0), axis=0), sum(xm, axis=0))) + assert_(eq(np.sum(x, 0), sum(x, 0))) + assert_(eq(np.product(x, axis=0), product(x, axis=0))) + assert_(eq(np.product(x, 0), product(x, 0))) + assert_(eq(np.product(filled(xm, 1), axis=0), product(xm, axis=0))) if len(s) > 1: - self.assertTrue(eq(np.concatenate((x, y), 1), + assert_(eq(np.concatenate((x, y), 1), concatenate((xm, ym), 1))) - self.assertTrue(eq(np.add.reduce(x, 1), add.reduce(x, 1))) - self.assertTrue(eq(np.sum(x, 1), sum(x, 1))) - self.assertTrue(eq(np.product(x, 1), product(x, 1))) + assert_(eq(np.add.reduce(x, 1), add.reduce(x, 1))) + assert_(eq(np.sum(x, 1), sum(x, 1))) + assert_(eq(np.product(x, 1), product(x, 1))) def test_testCI(self): # Test of conversions and indexing @@ -250,9 +252,9 @@ class TestMa(TestCase): x2 = np.array([1, 'hello', 2, 3], object) s1 = x1[1] s2 = x2[1] - self.assertEqual(type(s2), str) - self.assertEqual(type(s1), str) - self.assertEqual(s1, s2) + assert_equal(type(s2), str) + assert_equal(type(s1), str) + assert_equal(s1, s2) assert_(x1[1:1].shape == (0,)) def test_testCopySize(self): @@ -260,47 +262,47 @@ class TestMa(TestCase): n = [0, 0, 1, 0, 0] m = make_mask(n) m2 = make_mask(m) - self.assertTrue(m is m2) + assert_(m is m2) m3 = make_mask(m, copy=1) - self.assertTrue(m is not m3) + assert_(m is not m3) x1 = np.arange(5) y1 = array(x1, mask=m) - self.assertTrue(y1._data is not x1) - self.assertTrue(allequal(x1, y1._data)) - self.assertTrue(y1.mask is m) + assert_(y1._data is not x1) + assert_(allequal(x1, y1._data)) + assert_(y1.mask is m) y1a = array(y1, copy=0) - self.assertTrue(y1a.mask is y1.mask) + assert_(y1a.mask is y1.mask) y2 = array(x1, mask=m3, copy=0) - self.assertTrue(y2.mask is m3) - self.assertTrue(y2[2] is masked) + assert_(y2.mask is m3) + assert_(y2[2] is masked) y2[2] = 9 - self.assertTrue(y2[2] is not masked) - self.assertTrue(y2.mask is m3) - self.assertTrue(allequal(y2.mask, 0)) + assert_(y2[2] is not masked) + assert_(y2.mask is m3) + assert_(allequal(y2.mask, 0)) y2a = array(x1, mask=m, copy=1) - self.assertTrue(y2a.mask is not m) - self.assertTrue(y2a[2] is masked) + assert_(y2a.mask is not m) + assert_(y2a[2] is masked) y2a[2] = 9 - self.assertTrue(y2a[2] is not masked) - self.assertTrue(y2a.mask is not m) - self.assertTrue(allequal(y2a.mask, 0)) + assert_(y2a[2] is not masked) + assert_(y2a.mask is not m) + assert_(allequal(y2a.mask, 0)) y3 = array(x1 * 1.0, mask=m) - self.assertTrue(filled(y3).dtype is (x1 * 1.0).dtype) + assert_(filled(y3).dtype is (x1 * 1.0).dtype) x4 = arange(4) x4[2] = masked y4 = resize(x4, (8,)) - self.assertTrue(eq(concatenate([x4, x4]), y4)) - self.assertTrue(eq(getmask(y4), [0, 0, 1, 0, 0, 0, 1, 0])) + assert_(eq(concatenate([x4, x4]), y4)) + assert_(eq(getmask(y4), [0, 0, 1, 0, 0, 0, 1, 0])) y5 = repeat(x4, (2, 2, 2, 2), axis=0) - self.assertTrue(eq(y5, [0, 0, 1, 1, 2, 2, 3, 3])) + assert_(eq(y5, [0, 0, 1, 1, 2, 2, 3, 3])) y6 = repeat(x4, 2, axis=0) - self.assertTrue(eq(y5, y6)) + assert_(eq(y5, y6)) def test_testPut(self): # Test of put @@ -309,46 +311,46 @@ class TestMa(TestCase): m = make_mask(n) m2 = m.copy() x = array(d, mask=m) - self.assertTrue(x[3] is masked) - self.assertTrue(x[4] is masked) + assert_(x[3] is masked) + assert_(x[4] is masked) x[[1, 4]] = [10, 40] - self.assertTrue(x.mask is m) - self.assertTrue(x[3] is masked) - self.assertTrue(x[4] is not masked) - self.assertTrue(eq(x, [0, 10, 2, -1, 40])) + assert_(x.mask is m) + assert_(x[3] is masked) + assert_(x[4] is not masked) + assert_(eq(x, [0, 10, 2, -1, 40])) x = array(d, mask=m2, copy=True) x.put([0, 1, 2], [-1, 100, 200]) - self.assertTrue(x.mask is not m2) - self.assertTrue(x[3] is masked) - self.assertTrue(x[4] is masked) - self.assertTrue(eq(x, [-1, 100, 200, 0, 0])) + assert_(x.mask is not m2) + assert_(x[3] is masked) + assert_(x[4] is masked) + assert_(eq(x, [-1, 100, 200, 0, 0])) def test_testPut2(self): # Test of put d = arange(5) x = array(d, mask=[0, 0, 0, 0, 0]) z = array([10, 40], mask=[1, 0]) - self.assertTrue(x[2] is not masked) - self.assertTrue(x[3] is not masked) + assert_(x[2] is not masked) + assert_(x[3] is not masked) x[2:4] = z - self.assertTrue(x[2] is masked) - self.assertTrue(x[3] is not masked) - self.assertTrue(eq(x, [0, 1, 10, 40, 4])) + assert_(x[2] is masked) + assert_(x[3] is not masked) + assert_(eq(x, [0, 1, 10, 40, 4])) d = arange(5) x = array(d, mask=[0, 0, 0, 0, 0]) y = x[2:4] z = array([10, 40], mask=[1, 0]) - self.assertTrue(x[2] is not masked) - self.assertTrue(x[3] is not masked) + assert_(x[2] is not masked) + assert_(x[3] is not masked) y[:] = z - self.assertTrue(y[0] is masked) - self.assertTrue(y[1] is not masked) - self.assertTrue(eq(y, [10, 40])) - self.assertTrue(x[2] is masked) - self.assertTrue(x[3] is not masked) - self.assertTrue(eq(x, [0, 1, 10, 40, 4])) + assert_(y[0] is masked) + assert_(y[1] is not masked) + assert_(eq(y, [10, 40])) + assert_(x[2] is masked) + assert_(x[3] is not masked) + assert_(eq(x, [0, 1, 10, 40, 4])) def test_testMaPut(self): (x, y, a10, m1, m2, xm, ym, z, zm, xf, s) = self.d @@ -555,147 +557,147 @@ class TestMa(TestCase): # Test of masked element xx = arange(6) xx[1] = masked - self.assertTrue(str(masked) == '--') - self.assertTrue(xx[1] is masked) - self.assertEqual(filled(xx[1], 0), 0) + assert_(str(masked) == '--') + assert_(xx[1] is masked) + assert_equal(filled(xx[1], 0), 0) def test_testAverage1(self): # Test of average. ott = array([0., 1., 2., 3.], mask=[1, 0, 0, 0]) - self.assertTrue(eq(2.0, average(ott, axis=0))) - self.assertTrue(eq(2.0, average(ott, weights=[1., 1., 2., 1.]))) + assert_(eq(2.0, average(ott, axis=0))) + assert_(eq(2.0, average(ott, weights=[1., 1., 2., 1.]))) result, wts = average(ott, weights=[1., 1., 2., 1.], returned=1) - self.assertTrue(eq(2.0, result)) - self.assertTrue(wts == 4.0) + assert_(eq(2.0, result)) + assert_(wts == 4.0) ott[:] = masked - self.assertTrue(average(ott, axis=0) is masked) + assert_(average(ott, axis=0) is masked) ott = array([0., 1., 2., 3.], mask=[1, 0, 0, 0]) ott = ott.reshape(2, 2) ott[:, 1] = masked - self.assertTrue(eq(average(ott, axis=0), [2.0, 0.0])) - self.assertTrue(average(ott, axis=1)[0] is masked) - self.assertTrue(eq([2., 0.], average(ott, axis=0))) + assert_(eq(average(ott, axis=0), [2.0, 0.0])) + assert_(average(ott, axis=1)[0] is masked) + assert_(eq([2., 0.], average(ott, axis=0))) result, wts = average(ott, axis=0, returned=1) - self.assertTrue(eq(wts, [1., 0.])) + assert_(eq(wts, [1., 0.])) def test_testAverage2(self): # More tests of average. w1 = [0, 1, 1, 1, 1, 0] w2 = [[0, 1, 1, 1, 1, 0], [1, 0, 0, 0, 0, 1]] x = arange(6) - self.assertTrue(allclose(average(x, axis=0), 2.5)) - self.assertTrue(allclose(average(x, axis=0, weights=w1), 2.5)) + assert_(allclose(average(x, axis=0), 2.5)) + assert_(allclose(average(x, axis=0, weights=w1), 2.5)) y = array([arange(6), 2.0 * arange(6)]) - self.assertTrue(allclose(average(y, None), + assert_(allclose(average(y, None), np.add.reduce(np.arange(6)) * 3. / 12.)) - self.assertTrue(allclose(average(y, axis=0), np.arange(6) * 3. / 2.)) - self.assertTrue(allclose(average(y, axis=1), + assert_(allclose(average(y, axis=0), np.arange(6) * 3. / 2.)) + assert_(allclose(average(y, axis=1), [average(x, axis=0), average(x, axis=0)*2.0])) - self.assertTrue(allclose(average(y, None, weights=w2), 20. / 6.)) - self.assertTrue(allclose(average(y, axis=0, weights=w2), + assert_(allclose(average(y, None, weights=w2), 20. / 6.)) + assert_(allclose(average(y, axis=0, weights=w2), [0., 1., 2., 3., 4., 10.])) - self.assertTrue(allclose(average(y, axis=1), + assert_(allclose(average(y, axis=1), [average(x, axis=0), average(x, axis=0)*2.0])) m1 = zeros(6) m2 = [0, 0, 1, 1, 0, 0] m3 = [[0, 0, 1, 1, 0, 0], [0, 1, 1, 1, 1, 0]] m4 = ones(6) m5 = [0, 1, 1, 1, 1, 1] - self.assertTrue(allclose(average(masked_array(x, m1), axis=0), 2.5)) - self.assertTrue(allclose(average(masked_array(x, m2), axis=0), 2.5)) - self.assertTrue(average(masked_array(x, m4), axis=0) is masked) - self.assertEqual(average(masked_array(x, m5), axis=0), 0.0) - self.assertEqual(count(average(masked_array(x, m4), axis=0)), 0) + assert_(allclose(average(masked_array(x, m1), axis=0), 2.5)) + assert_(allclose(average(masked_array(x, m2), axis=0), 2.5)) + assert_(average(masked_array(x, m4), axis=0) is masked) + assert_equal(average(masked_array(x, m5), axis=0), 0.0) + assert_equal(count(average(masked_array(x, m4), axis=0)), 0) z = masked_array(y, m3) - self.assertTrue(allclose(average(z, None), 20. / 6.)) - self.assertTrue(allclose(average(z, axis=0), + assert_(allclose(average(z, None), 20. / 6.)) + assert_(allclose(average(z, axis=0), [0., 1., 99., 99., 4.0, 7.5])) - self.assertTrue(allclose(average(z, axis=1), [2.5, 5.0])) - self.assertTrue(allclose(average(z, axis=0, weights=w2), + assert_(allclose(average(z, axis=1), [2.5, 5.0])) + assert_(allclose(average(z, axis=0, weights=w2), [0., 1., 99., 99., 4.0, 10.0])) a = arange(6) b = arange(6) * 3 r1, w1 = average([[a, b], [b, a]], axis=1, returned=1) - self.assertEqual(shape(r1), shape(w1)) - self.assertEqual(r1.shape, w1.shape) + assert_equal(shape(r1), shape(w1)) + assert_equal(r1.shape, w1.shape) r2, w2 = average(ones((2, 2, 3)), axis=0, weights=[3, 1], returned=1) - self.assertEqual(shape(w2), shape(r2)) + assert_equal(shape(w2), shape(r2)) r2, w2 = average(ones((2, 2, 3)), returned=1) - self.assertEqual(shape(w2), shape(r2)) + assert_equal(shape(w2), shape(r2)) r2, w2 = average(ones((2, 2, 3)), weights=ones((2, 2, 3)), returned=1) - self.assertTrue(shape(w2) == shape(r2)) + assert_(shape(w2) == shape(r2)) a2d = array([[1, 2], [0, 4]], float) a2dm = masked_array(a2d, [[0, 0], [1, 0]]) a2da = average(a2d, axis=0) - self.assertTrue(eq(a2da, [0.5, 3.0])) + assert_(eq(a2da, [0.5, 3.0])) a2dma = average(a2dm, axis=0) - self.assertTrue(eq(a2dma, [1.0, 3.0])) + assert_(eq(a2dma, [1.0, 3.0])) a2dma = average(a2dm, axis=None) - self.assertTrue(eq(a2dma, 7. / 3.)) + assert_(eq(a2dma, 7. / 3.)) a2dma = average(a2dm, axis=1) - self.assertTrue(eq(a2dma, [1.5, 4.0])) + assert_(eq(a2dma, [1.5, 4.0])) def test_testToPython(self): - self.assertEqual(1, int(array(1))) - self.assertEqual(1.0, float(array(1))) - self.assertEqual(1, int(array([[[1]]]))) - self.assertEqual(1.0, float(array([[1]]))) - self.assertRaises(TypeError, float, array([1, 1])) - self.assertRaises(ValueError, bool, array([0, 1])) - self.assertRaises(ValueError, bool, array([0, 0], mask=[0, 1])) + assert_equal(1, int(array(1))) + assert_equal(1.0, float(array(1))) + assert_equal(1, int(array([[[1]]]))) + assert_equal(1.0, float(array([[1]]))) + assert_raises(TypeError, float, array([1, 1])) + assert_raises(ValueError, bool, array([0, 1])) + assert_raises(ValueError, bool, array([0, 0], mask=[0, 1])) def test_testScalarArithmetic(self): xm = array(0, mask=1) #TODO FIXME: Find out what the following raises a warning in r8247 with np.errstate(divide='ignore'): - self.assertTrue((1 / array(0)).mask) - self.assertTrue((1 + xm).mask) - self.assertTrue((-xm).mask) - self.assertTrue((-xm).mask) - self.assertTrue(maximum(xm, xm).mask) - self.assertTrue(minimum(xm, xm).mask) - self.assertTrue(xm.filled().dtype is xm._data.dtype) + assert_((1 / array(0)).mask) + assert_((1 + xm).mask) + assert_((-xm).mask) + assert_((-xm).mask) + assert_(maximum(xm, xm).mask) + assert_(minimum(xm, xm).mask) + assert_(xm.filled().dtype is xm._data.dtype) x = array(0, mask=0) - self.assertTrue(x.filled() == x._data) - self.assertEqual(str(xm), str(masked_print_option)) + assert_(x.filled() == x._data) + assert_equal(str(xm), str(masked_print_option)) def test_testArrayMethods(self): a = array([1, 3, 2]) - self.assertTrue(eq(a.any(), a._data.any())) - self.assertTrue(eq(a.all(), a._data.all())) - self.assertTrue(eq(a.argmax(), a._data.argmax())) - self.assertTrue(eq(a.argmin(), a._data.argmin())) - self.assertTrue(eq(a.choose(0, 1, 2, 3, 4), + assert_(eq(a.any(), a._data.any())) + assert_(eq(a.all(), a._data.all())) + assert_(eq(a.argmax(), a._data.argmax())) + assert_(eq(a.argmin(), a._data.argmin())) + assert_(eq(a.choose(0, 1, 2, 3, 4), a._data.choose(0, 1, 2, 3, 4))) - self.assertTrue(eq(a.compress([1, 0, 1]), a._data.compress([1, 0, 1]))) - self.assertTrue(eq(a.conj(), a._data.conj())) - self.assertTrue(eq(a.conjugate(), a._data.conjugate())) + assert_(eq(a.compress([1, 0, 1]), a._data.compress([1, 0, 1]))) + assert_(eq(a.conj(), a._data.conj())) + assert_(eq(a.conjugate(), a._data.conjugate())) m = array([[1, 2], [3, 4]]) - self.assertTrue(eq(m.diagonal(), m._data.diagonal())) - self.assertTrue(eq(a.sum(), a._data.sum())) - self.assertTrue(eq(a.take([1, 2]), a._data.take([1, 2]))) - self.assertTrue(eq(m.transpose(), m._data.transpose())) + assert_(eq(m.diagonal(), m._data.diagonal())) + assert_(eq(a.sum(), a._data.sum())) + assert_(eq(a.take([1, 2]), a._data.take([1, 2]))) + assert_(eq(m.transpose(), m._data.transpose())) def test_testArrayAttributes(self): a = array([1, 3, 2]) - self.assertEqual(a.ndim, 1) + assert_equal(a.ndim, 1) def test_testAPI(self): - self.assertFalse([m for m in dir(np.ndarray) - if m not in dir(MaskedArray) and - not m.startswith('_')]) + assert_(not [m for m in dir(np.ndarray) + if m not in dir(MaskedArray) and + not m.startswith('_')]) def test_testSingleElementSubscript(self): a = array([1, 3, 2]) b = array([1, 3, 2], mask=[1, 0, 1]) - self.assertEqual(a[0].shape, ()) - self.assertEqual(b[0].shape, ()) - self.assertEqual(b[1].shape, ()) + assert_equal(a[0].shape, ()) + assert_equal(b[0].shape, ()) + assert_equal(b[1].shape, ()) -class TestUfuncs(TestCase): - def setUp(self): +class TestUfuncs(object): + 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),) @@ -733,35 +735,35 @@ class TestUfuncs(TestCase): np.seterr(divide='ignore') ur = uf(*args) mr = mf(*args) - self.assertTrue(eq(ur.filled(0), mr.filled(0), f)) - self.assertTrue(eqmask(ur.mask, mr.mask)) + assert_(eq(ur.filled(0), mr.filled(0), f)) + assert_(eqmask(ur.mask, mr.mask)) def test_reduce(self): a = self.d[0] - self.assertFalse(alltrue(a, axis=0)) - self.assertTrue(sometrue(a, axis=0)) - self.assertEqual(sum(a[:3], axis=0), 0) - self.assertEqual(product(a, axis=0), 0) + assert_(not alltrue(a, axis=0)) + assert_(sometrue(a, axis=0)) + assert_equal(sum(a[:3], axis=0), 0) + assert_equal(product(a, axis=0), 0) def test_minmax(self): a = arange(1, 13).reshape(3, 4) amask = masked_where(a < 5, a) - self.assertEqual(amask.max(), a.max()) - self.assertEqual(amask.min(), 5) - self.assertTrue((amask.max(0) == a.max(0)).all()) - self.assertTrue((amask.min(0) == [5, 6, 7, 8]).all()) - self.assertTrue(amask.max(1)[0].mask) - self.assertTrue(amask.min(1)[0].mask) + assert_equal(amask.max(), a.max()) + assert_equal(amask.min(), 5) + assert_((amask.max(0) == a.max(0)).all()) + assert_((amask.min(0) == [5, 6, 7, 8]).all()) + assert_(amask.max(1)[0].mask) + assert_(amask.min(1)[0].mask) def test_nonzero(self): for t in "?bhilqpBHILQPfdgFDGO": x = array([1, 0, 2, 0], mask=[0, 0, 1, 1]) - self.assertTrue(eq(nonzero(x), [0])) + assert_(eq(nonzero(x), [0])) -class TestArrayMethods(TestCase): +class TestArrayMethods(object): - def setUp(self): + def setup(self): x = np.array([8.375, 7.545, 8.828, 8.5, 1.757, 5.928, 8.43, 7.78, 9.865, 5.878, 8.979, 4.732, 3.012, 6.022, 5.095, 3.116, 5.238, 3.957, @@ -786,63 +788,63 @@ class TestArrayMethods(TestCase): def test_trace(self): (x, X, XX, m, mx, mX, mXX,) = self.d mXdiag = mX.diagonal() - self.assertEqual(mX.trace(), mX.diagonal().compressed().sum()) - self.assertTrue(eq(mX.trace(), + assert_equal(mX.trace(), mX.diagonal().compressed().sum()) + assert_(eq(mX.trace(), X.trace() - sum(mXdiag.mask * X.diagonal(), axis=0))) def test_clip(self): (x, X, XX, m, mx, mX, mXX,) = self.d clipped = mx.clip(2, 8) - self.assertTrue(eq(clipped.mask, mx.mask)) - self.assertTrue(eq(clipped._data, x.clip(2, 8))) - self.assertTrue(eq(clipped._data, mx._data.clip(2, 8))) + assert_(eq(clipped.mask, mx.mask)) + assert_(eq(clipped._data, x.clip(2, 8))) + assert_(eq(clipped._data, mx._data.clip(2, 8))) def test_ptp(self): (x, X, XX, m, mx, mX, mXX,) = self.d (n, m) = X.shape - self.assertEqual(mx.ptp(), mx.compressed().ptp()) + assert_equal(mx.ptp(), mx.compressed().ptp()) rows = np.zeros(n, np.float_) cols = np.zeros(m, np.float_) for k in range(m): cols[k] = mX[:, k].compressed().ptp() for k in range(n): rows[k] = mX[k].compressed().ptp() - self.assertTrue(eq(mX.ptp(0), cols)) - self.assertTrue(eq(mX.ptp(1), rows)) + assert_(eq(mX.ptp(0), cols)) + assert_(eq(mX.ptp(1), rows)) def test_swapaxes(self): (x, X, XX, m, mx, mX, mXX,) = self.d mXswapped = mX.swapaxes(0, 1) - self.assertTrue(eq(mXswapped[-1], mX[:, -1])) + assert_(eq(mXswapped[-1], mX[:, -1])) mXXswapped = mXX.swapaxes(0, 2) - self.assertEqual(mXXswapped.shape, (2, 2, 3, 3)) + assert_equal(mXXswapped.shape, (2, 2, 3, 3)) def test_cumprod(self): (x, X, XX, m, mx, mX, mXX,) = self.d mXcp = mX.cumprod(0) - self.assertTrue(eq(mXcp._data, mX.filled(1).cumprod(0))) + assert_(eq(mXcp._data, mX.filled(1).cumprod(0))) mXcp = mX.cumprod(1) - self.assertTrue(eq(mXcp._data, mX.filled(1).cumprod(1))) + assert_(eq(mXcp._data, mX.filled(1).cumprod(1))) def test_cumsum(self): (x, X, XX, m, mx, mX, mXX,) = self.d mXcp = mX.cumsum(0) - self.assertTrue(eq(mXcp._data, mX.filled(0).cumsum(0))) + assert_(eq(mXcp._data, mX.filled(0).cumsum(0))) mXcp = mX.cumsum(1) - self.assertTrue(eq(mXcp._data, mX.filled(0).cumsum(1))) + assert_(eq(mXcp._data, mX.filled(0).cumsum(1))) def test_varstd(self): (x, X, XX, m, mx, mX, mXX,) = self.d - self.assertTrue(eq(mX.var(axis=None), mX.compressed().var())) - self.assertTrue(eq(mX.std(axis=None), mX.compressed().std())) - self.assertTrue(eq(mXX.var(axis=3).shape, XX.var(axis=3).shape)) - self.assertTrue(eq(mX.var().shape, X.var().shape)) + assert_(eq(mX.var(axis=None), mX.compressed().var())) + assert_(eq(mX.std(axis=None), mX.compressed().std())) + assert_(eq(mXX.var(axis=3).shape, XX.var(axis=3).shape)) + assert_(eq(mX.var().shape, X.var().shape)) (mXvar0, mXvar1) = (mX.var(axis=0), mX.var(axis=1)) for k in range(6): - self.assertTrue(eq(mXvar1[k], mX[k].compressed().var())) - self.assertTrue(eq(mXvar0[k], mX[:, k].compressed().var())) - self.assertTrue(eq(np.sqrt(mXvar0[k]), + assert_(eq(mXvar1[k], mX[k].compressed().var())) + assert_(eq(mXvar0[k], mX[:, k].compressed().var())) + assert_(eq(np.sqrt(mXvar0[k]), mX[:, k].compressed().std())) diff --git a/numpy/ma/tests/test_regression.py b/numpy/ma/tests/test_regression.py index d1fb2bb2b..34dd29d92 100644 --- a/numpy/ma/tests/test_regression.py +++ b/numpy/ma/tests/test_regression.py @@ -3,14 +3,15 @@ from __future__ import division, absolute_import, print_function import warnings import numpy as np -from numpy.testing import (assert_, TestCase, assert_array_equal, - assert_allclose, run_module_suite, - suppress_warnings) +from numpy.testing import ( + assert_, assert_array_equal, assert_allclose, run_module_suite, + suppress_warnings + ) rlevel = 1 -class TestRegression(TestCase): +class TestRegression(object): def test_masked_array_create(self,level=rlevel): # Ticket #17 x = np.ma.masked_array([0, 1, 2, 3, 0, 4, 5, 6], diff --git a/numpy/ma/tests/test_subclassing.py b/numpy/ma/tests/test_subclassing.py index b2995fd57..e59dd4656 100644 --- a/numpy/ma/tests/test_subclassing.py +++ b/numpy/ma/tests/test_subclassing.py @@ -9,7 +9,7 @@ from __future__ import division, absolute_import, print_function import numpy as np -from numpy.testing import TestCase, run_module_suite, assert_raises, dec +from numpy.testing import run_module_suite, assert_, assert_raises, dec from numpy.ma.testutils import assert_equal from numpy.ma.core import ( array, arange, masked, MaskedArray, masked_array, log, add, hypot, @@ -172,10 +172,10 @@ class ComplicatedSubArray(SubArray): return obj -class TestSubclassing(TestCase): +class TestSubclassing(object): # Test suite for masked subclasses of ndarray. - def setUp(self): + def setup(self): x = np.arange(5, dtype='float') mx = mmatrix(x, mask=[0, 1, 0, 0, 0]) self.data = (x, mx) @@ -186,41 +186,41 @@ class TestSubclassing(TestCase): m = [0, 0, 1, 0, 0] xsub = SubArray(x) xmsub = masked_array(xsub, mask=m) - self.assertTrue(isinstance(xmsub, MaskedArray)) + assert_(isinstance(xmsub, MaskedArray)) assert_equal(xmsub._data, xsub) - self.assertTrue(isinstance(xmsub._data, SubArray)) + assert_(isinstance(xmsub._data, SubArray)) def test_maskedarray_subclassing(self): # Tests subclassing MaskedArray (x, mx) = self.data - self.assertTrue(isinstance(mx._data, np.matrix)) + assert_(isinstance(mx._data, np.matrix)) def test_masked_unary_operations(self): # Tests masked_unary_operation (x, mx) = self.data with np.errstate(divide='ignore'): - self.assertTrue(isinstance(log(mx), mmatrix)) + assert_(isinstance(log(mx), mmatrix)) assert_equal(log(x), np.log(x)) def test_masked_binary_operations(self): # Tests masked_binary_operation (x, mx) = self.data # Result should be a mmatrix - self.assertTrue(isinstance(add(mx, mx), mmatrix)) - self.assertTrue(isinstance(add(mx, x), mmatrix)) + assert_(isinstance(add(mx, mx), mmatrix)) + assert_(isinstance(add(mx, x), mmatrix)) # Result should work assert_equal(add(mx, x), mx+x) - self.assertTrue(isinstance(add(mx, mx)._data, np.matrix)) - self.assertTrue(isinstance(add.outer(mx, mx), mmatrix)) - self.assertTrue(isinstance(hypot(mx, mx), mmatrix)) - self.assertTrue(isinstance(hypot(mx, x), mmatrix)) + assert_(isinstance(add(mx, mx)._data, np.matrix)) + assert_(isinstance(add.outer(mx, mx), mmatrix)) + assert_(isinstance(hypot(mx, mx), mmatrix)) + assert_(isinstance(hypot(mx, x), mmatrix)) def test_masked_binary_operations2(self): # Tests domained_masked_binary_operation (x, mx) = self.data xmx = masked_array(mx.data.__array__(), mask=mx.mask) - self.assertTrue(isinstance(divide(mx, mx), mmatrix)) - self.assertTrue(isinstance(divide(mx, x), mmatrix)) + assert_(isinstance(divide(mx, mx), mmatrix)) + assert_(isinstance(divide(mx, x), mmatrix)) assert_equal(divide(mx, mx), divide(xmx, xmx)) def test_attributepropagation(self): @@ -229,22 +229,22 @@ class TestSubclassing(TestCase): ym = msubarray(x) # z = (my+1) - self.assertTrue(isinstance(z, MaskedArray)) - self.assertTrue(not isinstance(z, MSubArray)) - self.assertTrue(isinstance(z._data, SubArray)) + assert_(isinstance(z, MaskedArray)) + assert_(not isinstance(z, MSubArray)) + assert_(isinstance(z._data, SubArray)) assert_equal(z._data.info, {}) # z = (ym+1) - self.assertTrue(isinstance(z, MaskedArray)) - self.assertTrue(isinstance(z, MSubArray)) - self.assertTrue(isinstance(z._data, SubArray)) - self.assertTrue(z._data.info['added'] > 0) + assert_(isinstance(z, MaskedArray)) + assert_(isinstance(z, MSubArray)) + assert_(isinstance(z._data, SubArray)) + assert_(z._data.info['added'] > 0) # Test that inplace methods from data get used (gh-4617) ym += 1 - self.assertTrue(isinstance(ym, MaskedArray)) - self.assertTrue(isinstance(ym, MSubArray)) - self.assertTrue(isinstance(ym._data, SubArray)) - self.assertTrue(ym._data.info['iadded'] > 0) + assert_(isinstance(ym, MaskedArray)) + assert_(isinstance(ym, MSubArray)) + assert_(isinstance(ym._data, SubArray)) + assert_(ym._data.info['iadded'] > 0) # ym._set_mask([1, 0, 0, 0, 1]) assert_equal(ym._mask, [1, 0, 0, 0, 1]) @@ -253,7 +253,7 @@ class TestSubclassing(TestCase): # xsub = subarray(x, info={'name':'x'}) mxsub = masked_array(xsub) - self.assertTrue(hasattr(mxsub, 'info')) + assert_(hasattr(mxsub, 'info')) assert_equal(mxsub.info, xsub.info) def test_subclasspreservation(self): @@ -264,22 +264,22 @@ class TestSubclassing(TestCase): xsub = MSubArray(x, mask=m, info={'xsub':xinfo}) # mxsub = masked_array(xsub, subok=False) - self.assertTrue(not isinstance(mxsub, MSubArray)) - self.assertTrue(isinstance(mxsub, MaskedArray)) + assert_(not isinstance(mxsub, MSubArray)) + assert_(isinstance(mxsub, MaskedArray)) assert_equal(mxsub._mask, m) # mxsub = asarray(xsub) - self.assertTrue(not isinstance(mxsub, MSubArray)) - self.assertTrue(isinstance(mxsub, MaskedArray)) + assert_(not isinstance(mxsub, MSubArray)) + assert_(isinstance(mxsub, MaskedArray)) assert_equal(mxsub._mask, m) # mxsub = masked_array(xsub, subok=True) - self.assertTrue(isinstance(mxsub, MSubArray)) + assert_(isinstance(mxsub, MSubArray)) assert_equal(mxsub.info, xsub.info) assert_equal(mxsub._mask, xsub._mask) # mxsub = asanyarray(xsub) - self.assertTrue(isinstance(mxsub, MSubArray)) + assert_(isinstance(mxsub, MSubArray)) assert_equal(mxsub.info, xsub.info) assert_equal(mxsub._mask, m) @@ -290,21 +290,21 @@ class TestSubclassing(TestCase): mxcsub = masked_array(xcsub, mask=[True, False, True, False, False]) # getter should return a ComplicatedSubArray, even for single item # first check we wrote ComplicatedSubArray correctly - self.assertTrue(isinstance(xcsub[1], ComplicatedSubArray)) - self.assertTrue(isinstance(xcsub[1,...], ComplicatedSubArray)) - self.assertTrue(isinstance(xcsub[1:4], ComplicatedSubArray)) + assert_(isinstance(xcsub[1], ComplicatedSubArray)) + assert_(isinstance(xcsub[1,...], ComplicatedSubArray)) + assert_(isinstance(xcsub[1:4], ComplicatedSubArray)) # now that it propagates inside the MaskedArray - self.assertTrue(isinstance(mxcsub[1], ComplicatedSubArray)) - self.assertTrue(isinstance(mxcsub[1,...].data, ComplicatedSubArray)) - self.assertTrue(mxcsub[0] is masked) - self.assertTrue(isinstance(mxcsub[0,...].data, ComplicatedSubArray)) - self.assertTrue(isinstance(mxcsub[1:4].data, ComplicatedSubArray)) + assert_(isinstance(mxcsub[1], ComplicatedSubArray)) + assert_(isinstance(mxcsub[1,...].data, ComplicatedSubArray)) + assert_(mxcsub[0] is masked) + assert_(isinstance(mxcsub[0,...].data, ComplicatedSubArray)) + assert_(isinstance(mxcsub[1:4].data, ComplicatedSubArray)) # also for flattened version (which goes via MaskedIterator) - self.assertTrue(isinstance(mxcsub.flat[1].data, ComplicatedSubArray)) - self.assertTrue(mxcsub.flat[0] is masked) - self.assertTrue(isinstance(mxcsub.flat[1:4].base, ComplicatedSubArray)) + assert_(isinstance(mxcsub.flat[1].data, ComplicatedSubArray)) + assert_(mxcsub.flat[0] is masked) + assert_(isinstance(mxcsub.flat[1:4].base, ComplicatedSubArray)) # setter should only work with ComplicatedSubArray input # first check we wrote ComplicatedSubArray correctly @@ -325,21 +325,21 @@ class TestSubclassing(TestCase): xcsub = ComplicatedSubArray(x) mxcsub_nomask = masked_array(xcsub) - self.assertTrue(isinstance(mxcsub_nomask[1,...].data, ComplicatedSubArray)) - self.assertTrue(isinstance(mxcsub_nomask[0,...].data, ComplicatedSubArray)) + assert_(isinstance(mxcsub_nomask[1,...].data, ComplicatedSubArray)) + assert_(isinstance(mxcsub_nomask[0,...].data, ComplicatedSubArray)) - self.assertTrue(isinstance(mxcsub_nomask[1], ComplicatedSubArray)) - self.assertTrue(isinstance(mxcsub_nomask[0], ComplicatedSubArray)) + assert_(isinstance(mxcsub_nomask[1], ComplicatedSubArray)) + assert_(isinstance(mxcsub_nomask[0], ComplicatedSubArray)) def test_subclass_repr(self): """test that repr uses the name of the subclass and 'array' for np.ndarray""" x = np.arange(5) mx = masked_array(x, mask=[True, False, True, False, False]) - self.assertTrue(repr(mx).startswith('masked_array')) + assert_(repr(mx).startswith('masked_array')) xsub = SubArray(x) mxsub = masked_array(xsub, mask=[True, False, True, False, False]) - self.assertTrue(repr(mxsub).startswith( + assert_(repr(mxsub).startswith( 'masked_{0}(data = [-- 1 -- 3 4]'.format(SubArray.__name__))) def test_subclass_str(self): @@ -348,13 +348,13 @@ class TestSubclassing(TestCase): x = np.arange(5) xsub = SubArray(x) mxsub = masked_array(xsub, mask=[True, False, True, False, False]) - self.assertTrue(str(mxsub) == '[-- 1 -- 3 4]') + assert_(str(mxsub) == '[-- 1 -- 3 4]') xcsub = ComplicatedSubArray(x) assert_raises(ValueError, xcsub.__setitem__, 0, np.ma.core.masked_print_option) mxcsub = masked_array(xcsub, mask=[True, False, True, False, False]) - self.assertTrue(str(mxcsub) == 'myprefix [-- 1 -- 3 4] mypostfix') + assert_(str(mxcsub) == 'myprefix [-- 1 -- 3 4] mypostfix') def test_pure_subclass_info_preservation(self): # Test that ufuncs and methods conserve extra information consistently; @@ -362,11 +362,11 @@ class TestSubclassing(TestCase): arr1 = SubMaskedArray('test', data=[1,2,3,4,5,6]) arr2 = SubMaskedArray(data=[0,1,2,3,4,5]) diff1 = np.subtract(arr1, arr2) - self.assertTrue('info' in diff1._optinfo) - self.assertTrue(diff1._optinfo['info'] == 'test') + assert_('info' in diff1._optinfo) + assert_(diff1._optinfo['info'] == 'test') diff2 = arr1 - arr2 - self.assertTrue('info' in diff2._optinfo) - self.assertTrue(diff2._optinfo['info'] == 'test') + assert_('info' in diff2._optinfo) + assert_(diff2._optinfo['info'] == 'test') ############################################################################### |