TST: Remove unittest dependencies in numpy/lib/tests.

17 files changed, 327 insertions, 328 deletions

diff --git a/numpy/lib/tests/test__datasource.py b/numpy/lib/tests/test__datasource.py
index f2ad0344a..a9cb157f3 100644
--- a/numpy/lib/tests/test__datasource.py
+++ b/numpy/lib/tests/test__datasource.py
@@ -6,7 +6,7 @@ from tempfile import mkdtemp, mkstemp, NamedTemporaryFile
 from shutil import rmtree
 
 from numpy.testing import (
-    run_module_suite, TestCase, assert_, SkipTest
+    run_module_suite, assert_, assert_equal, assert_raises, SkipTest,
     )
 import numpy.lib._datasource as datasource
 
@@ -55,7 +55,7 @@ malicious_files = ['/etc/shadow', '../../shadow',
 magic_line = b'three is the magic number'
 
 
-# Utility functions used by many TestCases
+# Utility functions used by many tests
 def valid_textfile(filedir):
     # Generate and return a valid temporary file.
     fd, path = mkstemp(suffix='.txt', prefix='dstmp_', dir=filedir, text=True)
@@ -95,12 +95,12 @@ def invalid_httpfile():
     return http_fakefile
 
 
-class TestDataSourceOpen(TestCase):
-    def setUp(self):
+class TestDataSourceOpen(object):
+    def setup(self):
         self.tmpdir = mkdtemp()
         self.ds = datasource.DataSource(self.tmpdir)
 
-    def tearDown(self):
+    def teardown(self):
         rmtree(self.tmpdir)
         del self.ds
 
@@ -111,7 +111,7 @@ class TestDataSourceOpen(TestCase):
 
     def test_InvalidHTTP(self):
         url = invalid_httpurl()
-        self.assertRaises(IOError, self.ds.open, url)
+        assert_raises(IOError, self.ds.open, url)
         try:
             self.ds.open(url)
         except IOError as e:
@@ -119,7 +119,7 @@ class TestDataSourceOpen(TestCase):
             assert_(e.errno is None)
 
     def test_InvalidHTTPCacheURLError(self):
-        self.assertRaises(URLError, self.ds._cache, invalid_httpurl())
+        assert_raises(URLError, self.ds._cache, invalid_httpurl())
 
     def test_ValidFile(self):
         local_file = valid_textfile(self.tmpdir)
@@ -129,7 +129,7 @@ class TestDataSourceOpen(TestCase):
 
     def test_InvalidFile(self):
         invalid_file = invalid_textfile(self.tmpdir)
-        self.assertRaises(IOError, self.ds.open, invalid_file)
+        assert_raises(IOError, self.ds.open, invalid_file)
 
     def test_ValidGzipFile(self):
         try:
@@ -145,7 +145,7 @@ class TestDataSourceOpen(TestCase):
         fp = self.ds.open(filepath)
         result = fp.readline()
         fp.close()
-        self.assertEqual(magic_line, result)
+        assert_equal(magic_line, result)
 
     def test_ValidBz2File(self):
         try:
@@ -161,15 +161,15 @@ class TestDataSourceOpen(TestCase):
         fp = self.ds.open(filepath)
         result = fp.readline()
         fp.close()
-        self.assertEqual(magic_line, result)
+        assert_equal(magic_line, result)
 
 
-class TestDataSourceExists(TestCase):
-    def setUp(self):
+class TestDataSourceExists(object):
+    def setup(self):
         self.tmpdir = mkdtemp()
         self.ds = datasource.DataSource(self.tmpdir)
 
-    def tearDown(self):
+    def teardown(self):
         rmtree(self.tmpdir)
         del self.ds
 
@@ -177,7 +177,7 @@ class TestDataSourceExists(TestCase):
         assert_(self.ds.exists(valid_httpurl()))
 
     def test_InvalidHTTP(self):
-        self.assertEqual(self.ds.exists(invalid_httpurl()), False)
+        assert_equal(self.ds.exists(invalid_httpurl()), False)
 
     def test_ValidFile(self):
         # Test valid file in destpath
@@ -191,15 +191,15 @@ class TestDataSourceExists(TestCase):
 
     def test_InvalidFile(self):
         tmpfile = invalid_textfile(self.tmpdir)
-        self.assertEqual(self.ds.exists(tmpfile), False)
+        assert_equal(self.ds.exists(tmpfile), False)
 
 
-class TestDataSourceAbspath(TestCase):
-    def setUp(self):
+class TestDataSourceAbspath(object):
+    def setup(self):
         self.tmpdir = os.path.abspath(mkdtemp())
         self.ds = datasource.DataSource(self.tmpdir)
 
-    def tearDown(self):
+    def teardown(self):
         rmtree(self.tmpdir)
         del self.ds
 
@@ -207,30 +207,30 @@ class TestDataSourceAbspath(TestCase):
         scheme, netloc, upath, pms, qry, frg = urlparse(valid_httpurl())
         local_path = os.path.join(self.tmpdir, netloc,
                                   upath.strip(os.sep).strip('/'))
-        self.assertEqual(local_path, self.ds.abspath(valid_httpurl()))
+        assert_equal(local_path, self.ds.abspath(valid_httpurl()))
 
     def test_ValidFile(self):
         tmpfile = valid_textfile(self.tmpdir)
         tmpfilename = os.path.split(tmpfile)[-1]
         # Test with filename only
-        self.assertEqual(tmpfile, self.ds.abspath(tmpfilename))
+        assert_equal(tmpfile, self.ds.abspath(tmpfilename))
         # Test filename with complete path
-        self.assertEqual(tmpfile, self.ds.abspath(tmpfile))
+        assert_equal(tmpfile, self.ds.abspath(tmpfile))
 
     def test_InvalidHTTP(self):
         scheme, netloc, upath, pms, qry, frg = urlparse(invalid_httpurl())
         invalidhttp = os.path.join(self.tmpdir, netloc,
                                    upath.strip(os.sep).strip('/'))
-        self.assertNotEqual(invalidhttp, self.ds.abspath(valid_httpurl()))
+        assert_(invalidhttp != self.ds.abspath(valid_httpurl()))
 
     def test_InvalidFile(self):
         invalidfile = valid_textfile(self.tmpdir)
         tmpfile = valid_textfile(self.tmpdir)
         tmpfilename = os.path.split(tmpfile)[-1]
         # Test with filename only
-        self.assertNotEqual(invalidfile, self.ds.abspath(tmpfilename))
+        assert_(invalidfile != self.ds.abspath(tmpfilename))
         # Test filename with complete path
-        self.assertNotEqual(invalidfile, self.ds.abspath(tmpfile))
+        assert_(invalidfile != self.ds.abspath(tmpfile))
 
     def test_sandboxing(self):
         tmpfile = valid_textfile(self.tmpdir)
@@ -259,12 +259,12 @@ class TestDataSourceAbspath(TestCase):
             os.sep = orig_os_sep
 
 
-class TestRepositoryAbspath(TestCase):
-    def setUp(self):
+class TestRepositoryAbspath(object):
+    def setup(self):
         self.tmpdir = os.path.abspath(mkdtemp())
         self.repos = datasource.Repository(valid_baseurl(), self.tmpdir)
 
-    def tearDown(self):
+    def teardown(self):
         rmtree(self.tmpdir)
         del self.repos
 
@@ -273,7 +273,7 @@ class TestRepositoryAbspath(TestCase):
         local_path = os.path.join(self.repos._destpath, netloc,
                                   upath.strip(os.sep).strip('/'))
         filepath = self.repos.abspath(valid_httpfile())
-        self.assertEqual(local_path, filepath)
+        assert_equal(local_path, filepath)
 
     def test_sandboxing(self):
         tmp_path = lambda x: os.path.abspath(self.repos.abspath(x))
@@ -292,12 +292,12 @@ class TestRepositoryAbspath(TestCase):
             os.sep = orig_os_sep
 
 
-class TestRepositoryExists(TestCase):
-    def setUp(self):
+class TestRepositoryExists(object):
+    def setup(self):
         self.tmpdir = mkdtemp()
         self.repos = datasource.Repository(valid_baseurl(), self.tmpdir)
 
-    def tearDown(self):
+    def teardown(self):
         rmtree(self.tmpdir)
         del self.repos
 
@@ -308,7 +308,7 @@ class TestRepositoryExists(TestCase):
 
     def test_InvalidFile(self):
         tmpfile = invalid_textfile(self.tmpdir)
-        self.assertEqual(self.repos.exists(tmpfile), False)
+        assert_equal(self.repos.exists(tmpfile), False)
 
     def test_RemoveHTTPFile(self):
         assert_(self.repos.exists(valid_httpurl()))
@@ -325,11 +325,11 @@ class TestRepositoryExists(TestCase):
         assert_(self.repos.exists(tmpfile))
 
 
-class TestOpenFunc(TestCase):
-    def setUp(self):
+class TestOpenFunc(object):
+    def setup(self):
         self.tmpdir = mkdtemp()
 
-    def tearDown(self):
+    def teardown(self):
         rmtree(self.tmpdir)
 
     def test_DataSourceOpen(self):
diff --git a/numpy/lib/tests/test__iotools.py b/numpy/lib/tests/test__iotools.py
index 6c0b2c6db..a7ee9cbff 100644
--- a/numpy/lib/tests/test__iotools.py
+++ b/numpy/lib/tests/test__iotools.py
@@ -6,8 +6,7 @@ from datetime import date
 
 import numpy as np
 from numpy.testing import (
-    run_module_suite, TestCase, assert_, assert_equal, assert_allclose,
-    assert_raises
+    run_module_suite, assert_, assert_equal, assert_allclose, assert_raises,
     )
 from numpy.lib._iotools import (
     LineSplitter, NameValidator, StringConverter,
@@ -15,7 +14,7 @@ from numpy.lib._iotools import (
     )
 
 
-class TestLineSplitter(TestCase):
+class TestLineSplitter(object):
     "Tests the LineSplitter class."
 
     def test_no_delimiter(self):
@@ -79,7 +78,7 @@ class TestLineSplitter(TestCase):
 # -----------------------------------------------------------------------------
 
 
-class TestNameValidator(TestCase):
+class TestNameValidator(object):
 
     def test_case_sensitivity(self):
         "Test case sensitivity"
@@ -140,7 +139,7 @@ def _bytes_to_date(s):
         return date(*time.strptime(s, "%Y-%m-%d")[:3])
 
 
-class TestStringConverter(TestCase):
+class TestStringConverter(object):
     "Test StringConverter"
 
     def test_creation(self):
@@ -254,7 +253,7 @@ class TestStringConverter(TestCase):
         assert_(converter(val) == 9223372043271415339)
 
 
-class TestMiscFunctions(TestCase):
+class TestMiscFunctions(object):
 
     def test_has_nested_dtype(self):
         "Test has_nested_dtype"
diff --git a/numpy/lib/tests/test_arraypad.py b/numpy/lib/tests/test_arraypad.py
index 056aa4582..55cd24a14 100644
--- a/numpy/lib/tests/test_arraypad.py
+++ b/numpy/lib/tests/test_arraypad.py
@@ -4,12 +4,11 @@
 from __future__ import division, absolute_import, print_function
 
 import numpy as np
-from numpy.testing import (assert_array_equal, assert_raises, assert_allclose,
-                           TestCase)
+from numpy.testing import (assert_array_equal, assert_raises, assert_allclose,)
 from numpy.lib import pad
 
 
-class TestConditionalShortcuts(TestCase):
+class TestConditionalShortcuts(object):
     def test_zero_padding_shortcuts(self):
         test = np.arange(120).reshape(4, 5, 6)
         pad_amt = [(0, 0) for axis in test.shape]
@@ -52,7 +51,7 @@ class TestConditionalShortcuts(TestCase):
                                pad(test, pad_amt, mode=mode, stat_length=30))
 
 
-class TestStatistic(TestCase):
+class TestStatistic(object):
     def test_check_mean_stat_length(self):
         a = np.arange(100).astype('f')
         a = pad(a, ((25, 20), ), 'mean', stat_length=((2, 3), ))
@@ -346,7 +345,7 @@ class TestStatistic(TestCase):
         assert_array_equal(a, b)
 
 
-class TestConstant(TestCase):
+class TestConstant(object):
     def test_check_constant(self):
         a = np.arange(100)
         a = pad(a, (25, 20), 'constant', constant_values=(10, 20))
@@ -491,7 +490,7 @@ class TestConstant(TestCase):
         assert_allclose(test, expected)
 
 
-class TestLinearRamp(TestCase):
+class TestLinearRamp(object):
     def test_check_simple(self):
         a = np.arange(100).astype('f')
         a = pad(a, (25, 20), 'linear_ramp', end_values=(4, 5))
@@ -531,7 +530,7 @@ class TestLinearRamp(TestCase):
         assert_allclose(test, expected)
 
 
-class TestReflect(TestCase):
+class TestReflect(object):
     def test_check_simple(self):
         a = np.arange(100)
         a = pad(a, (25, 20), 'reflect')
@@ -641,7 +640,7 @@ class TestReflect(TestCase):
         assert_array_equal(a, b)
 
 
-class TestSymmetric(TestCase):
+class TestSymmetric(object):
     def test_check_simple(self):
         a = np.arange(100)
         a = pad(a, (25, 20), 'symmetric')
@@ -775,7 +774,7 @@ class TestSymmetric(TestCase):
         assert_array_equal(a, b)
 
 
-class TestWrap(TestCase):
+class TestWrap(object):
     def test_check_simple(self):
         a = np.arange(100)
         a = pad(a, (25, 20), 'wrap')
@@ -871,7 +870,7 @@ class TestWrap(TestCase):
         assert_array_equal(a, b)
 
 
-class TestStatLen(TestCase):
+class TestStatLen(object):
     def test_check_simple(self):
         a = np.arange(30)
         a = np.reshape(a, (6, 5))
@@ -894,7 +893,7 @@ class TestStatLen(TestCase):
         assert_array_equal(a, b)
 
 
-class TestEdge(TestCase):
+class TestEdge(object):
     def test_check_simple(self):
         a = np.arange(12)
         a = np.reshape(a, (4, 3))
@@ -933,7 +932,7 @@ class TestEdge(TestCase):
         assert_array_equal(padded, expected)
 
 
-class TestZeroPadWidth(TestCase):
+class TestZeroPadWidth(object):
     def test_zero_pad_width(self):
         arr = np.arange(30)
         arr = np.reshape(arr, (6, 5))
@@ -941,7 +940,7 @@ class TestZeroPadWidth(TestCase):
             assert_array_equal(arr, pad(arr, pad_width, mode='constant'))
 
 
-class TestLegacyVectorFunction(TestCase):
+class TestLegacyVectorFunction(object):
     def test_legacy_vector_functionality(self):
         def _padwithtens(vector, pad_width, iaxis, kwargs):
             vector[:pad_width[0]] = 10
@@ -963,7 +962,7 @@ class TestLegacyVectorFunction(TestCase):
         assert_array_equal(a, b)
 
 
-class TestNdarrayPadWidth(TestCase):
+class TestNdarrayPadWidth(object):
     def test_check_simple(self):
         a = np.arange(12)
         a = np.reshape(a, (4, 3))
@@ -984,7 +983,7 @@ class TestNdarrayPadWidth(TestCase):
         assert_array_equal(a, b)
 
 
-class TestUnicodeInput(TestCase):
+class TestUnicodeInput(object):
     def test_unicode_mode(self):
         constant_mode = u'constant'
         a = np.pad([1], 2, mode=constant_mode)
@@ -992,7 +991,7 @@ class TestUnicodeInput(TestCase):
         assert_array_equal(a, b)
 
 
-class ValueError1(TestCase):
+class TestValueError1(object):
     def test_check_simple(self):
         arr = np.arange(30)
         arr = np.reshape(arr, (6, 5))
@@ -1015,7 +1014,7 @@ class ValueError1(TestCase):
                       **kwargs)
 
 
-class ValueError2(TestCase):
+class TestValueError2(object):
     def test_check_negative_pad_amount(self):
         arr = np.arange(30)
         arr = np.reshape(arr, (6, 5))
@@ -1024,7 +1023,7 @@ class ValueError2(TestCase):
                       **kwargs)
 
 
-class ValueError3(TestCase):
+class TestValueError3(object):
     def test_check_kwarg_not_allowed(self):
         arr = np.arange(30).reshape(5, 6)
         assert_raises(ValueError, pad, arr, 4, mode='mean',
@@ -1052,7 +1051,7 @@ class ValueError3(TestCase):
                       mode='constant')
 
 
-class TypeError1(TestCase):
+class TestTypeError1(object):
     def test_float(self):
         arr = np.arange(30)
         assert_raises(TypeError, pad, arr, ((-2.1, 3), (3, 2)))
diff --git a/numpy/lib/tests/test_arraysetops.py b/numpy/lib/tests/test_arraysetops.py
index d47534f82..b8ced41e8 100644
--- a/numpy/lib/tests/test_arraysetops.py
+++ b/numpy/lib/tests/test_arraysetops.py
@@ -5,14 +5,14 @@ from __future__ import division, absolute_import, print_function
 
 import numpy as np
 from numpy.testing import (
-    run_module_suite, TestCase, assert_array_equal, assert_equal, assert_raises
+    run_module_suite, assert_array_equal, assert_equal, assert_raises,
     )
 from numpy.lib.arraysetops import (
     ediff1d, intersect1d, setxor1d, union1d, setdiff1d, unique, in1d, isin
     )
 
 
-class TestSetOps(TestCase):
+class TestSetOps(object):
 
     def test_intersect1d(self):
         # unique inputs
@@ -89,28 +89,28 @@ class TestSetOps(TestCase):
             x = isin(a, b)
             y = isin_slow(a, b)
             assert_array_equal(x, y)
-            
+
         #multidimensional arrays in both arguments
         a = np.arange(24).reshape([2, 3, 4])
         b = np.array([[10, 20, 30], [0, 1, 3], [11, 22, 33]])
         assert_isin_equal(a, b)
-        
+
         #array-likes as both arguments
         c = [(9, 8), (7, 6)]
         d = (9, 7)
         assert_isin_equal(c, d)
-        
+
         #zero-d array:
         f = np.array(3)
         assert_isin_equal(f, b)
         assert_isin_equal(a, f)
         assert_isin_equal(f, f)
-        
+
         #scalar:
         assert_isin_equal(5, b)
         assert_isin_equal(a, 6)
         assert_isin_equal(5, 6)
-        
+
         #empty array-like:
         x = []
         assert_isin_equal(x, b)
@@ -252,7 +252,7 @@ class TestSetOps(TestCase):
         assert_array_equal(c1, c2)
 
 
-class TestUnique(TestCase):
+class TestUnique(object):
 
     def test_unique_1d(self):
 
diff --git a/numpy/lib/tests/test_financial.py b/numpy/lib/tests/test_financial.py
index cc8ba55e5..4db364ad5 100644
--- a/numpy/lib/tests/test_financial.py
+++ b/numpy/lib/tests/test_financial.py
@@ -2,12 +2,12 @@ from __future__ import division, absolute_import, print_function
 
 import numpy as np
 from numpy.testing import (
-    run_module_suite, TestCase, assert_, assert_almost_equal,
-    assert_allclose, assert_equal
+    run_module_suite, assert_, assert_almost_equal, assert_allclose,
+    assert_equal
     )
 
 
-class TestFinancial(TestCase):
+class TestFinancial(object):
     def test_rate(self):
         assert_almost_equal(np.rate(10, 0, -3500, 10000),
                             0.1107, 4)
diff --git a/numpy/lib/tests/test_function_base.py b/numpy/lib/tests/test_function_base.py
index f6d4b6111..e26ea9440 100644
--- a/numpy/lib/tests/test_function_base.py
+++ b/numpy/lib/tests/test_function_base.py
@@ -7,10 +7,10 @@ import decimal
 
 import numpy as np
 from numpy.testing import (
-    run_module_suite, TestCase, assert_, assert_equal, assert_array_equal,
+    run_module_suite, assert_, assert_equal, assert_array_equal,
     assert_almost_equal, assert_array_almost_equal, assert_raises,
-    assert_allclose, assert_array_max_ulp, assert_warns,
-    assert_raises_regex, dec, suppress_warnings, HAS_REFCOUNT,
+    assert_allclose, assert_array_max_ulp, assert_warns, assert_raises_regex,
+    dec, suppress_warnings, HAS_REFCOUNT,
 )
 import numpy.lib.function_base as nfb
 from numpy.random import rand
@@ -31,9 +31,9 @@ def get_mat(n):
     return data
 
 
-class TestRot90(TestCase):
+class TestRot90(object):
     def test_basic(self):
-        self.assertRaises(ValueError, rot90, np.ones(4))
+        assert_raises(ValueError, rot90, np.ones(4))
         assert_raises(ValueError, rot90, np.ones((2,2,2)), axes=(0,1,2))
         assert_raises(ValueError, rot90, np.ones((2,2)), axes=(0,2))
         assert_raises(ValueError, rot90, np.ones((2,2)), axes=(1,1))
@@ -99,12 +99,12 @@ class TestRot90(TestCase):
                          rot90(a_rot90_20, k=k-1, axes=(2, 0)))
 
 
-class TestFlip(TestCase):
+class TestFlip(object):
 
     def test_axes(self):
-        self.assertRaises(ValueError, np.flip, np.ones(4), axis=1)
-        self.assertRaises(ValueError, np.flip, np.ones((4, 4)), axis=2)
-        self.assertRaises(ValueError, np.flip, np.ones((4, 4)), axis=-3)
+        assert_raises(ValueError, np.flip, np.ones(4), axis=1)
+        assert_raises(ValueError, np.flip, np.ones((4, 4)), axis=2)
+        assert_raises(ValueError, np.flip, np.ones((4, 4)), axis=-3)
 
     def test_basic_lr(self):
         a = get_mat(4)
@@ -172,7 +172,7 @@ class TestFlip(TestCase):
                          np.flipud(a.swapaxes(0, i)).swapaxes(i, 0))
 
 
-class TestAny(TestCase):
+class TestAny(object):
 
     def test_basic(self):
         y1 = [0, 0, 1, 0]
@@ -189,7 +189,7 @@ class TestAny(TestCase):
         assert_array_equal(np.sometrue(y1, axis=1), [0, 1, 1])
 
 
-class TestAll(TestCase):
+class TestAll(object):
 
     def test_basic(self):
         y1 = [0, 1, 1, 0]
@@ -207,7 +207,7 @@ class TestAll(TestCase):
         assert_array_equal(np.alltrue(y1, axis=1), [0, 0, 1])
 
 
-class TestCopy(TestCase):
+class TestCopy(object):
 
     def test_basic(self):
         a = np.array([[1, 2], [3, 4]])
@@ -235,7 +235,7 @@ class TestCopy(TestCase):
         assert_(a_fort_copy.flags.f_contiguous)
 
 
-class TestAverage(TestCase):
+class TestAverage(object):
 
     def test_basic(self):
         y1 = np.array([1, 2, 3])
@@ -345,9 +345,9 @@ class TestAverage(TestCase):
         a = np.array([decimal.Decimal(x) for x in range(10)])
         w = np.array([decimal.Decimal(1) for _ in range(10)])
         w /= w.sum()
-        assert_almost_equal(a.mean(0), average(a, weights=w)) 
+        assert_almost_equal(a.mean(0), average(a, weights=w))
 
-class TestSelect(TestCase):
+class TestSelect(object):
     choices = [np.array([1, 2, 3]),
                np.array([4, 5, 6]),
                np.array([7, 8, 9])]
@@ -419,7 +419,7 @@ class TestSelect(TestCase):
         select(conditions, choices)
 
 
-class TestInsert(TestCase):
+class TestInsert(object):
 
     def test_basic(self):
         a = [1, 2, 3]
@@ -520,7 +520,7 @@ class TestInsert(TestCase):
         assert_array_equal(b[[0, 3]], np.array(val, dtype=b.dtype))
 
 
-class TestAmax(TestCase):
+class TestAmax(object):
 
     def test_basic(self):
         a = [3, 4, 5, 10, -3, -5, 6.0]
@@ -532,7 +532,7 @@ class TestAmax(TestCase):
         assert_equal(np.amax(b, axis=1), [9.0, 10.0, 8.0])
 
 
-class TestAmin(TestCase):
+class TestAmin(object):
 
     def test_basic(self):
         a = [3, 4, 5, 10, -3, -5, 6.0]
@@ -544,7 +544,7 @@ class TestAmin(TestCase):
         assert_equal(np.amin(b, axis=1), [3.0, 4.0, 2.0])
 
 
-class TestPtp(TestCase):
+class TestPtp(object):
 
     def test_basic(self):
         a = np.array([3, 4, 5, 10, -3, -5, 6.0])
@@ -556,7 +556,7 @@ class TestPtp(TestCase):
         assert_equal(b.ptp(axis=-1), [6.0, 6.0, 6.0])
 
 
-class TestCumsum(TestCase):
+class TestCumsum(object):
 
     def test_basic(self):
         ba = [1, 2, 10, 11, 6, 5, 4]
@@ -579,7 +579,7 @@ class TestCumsum(TestCase):
             assert_array_equal(np.cumsum(a2, axis=1), tgt)
 
 
-class TestProd(TestCase):
+class TestProd(object):
 
     def test_basic(self):
         ba = [1, 2, 10, 11, 6, 5, 4]
@@ -589,8 +589,8 @@ class TestProd(TestCase):
             a = np.array(ba, ctype)
             a2 = np.array(ba2, ctype)
             if ctype in ['1', 'b']:
-                self.assertRaises(ArithmeticError, np.prod, a)
-                self.assertRaises(ArithmeticError, np.prod, a2, 1)
+                assert_raises(ArithmeticError, np.prod, a)
+                assert_raises(ArithmeticError, np.prod, a2, 1)
             else:
                 assert_equal(a.prod(axis=0), 26400)
                 assert_array_equal(a2.prod(axis=0),
@@ -599,7 +599,7 @@ class TestProd(TestCase):
                                    np.array([24, 1890, 600], ctype))
 
 
-class TestCumprod(TestCase):
+class TestCumprod(object):
 
     def test_basic(self):
         ba = [1, 2, 10, 11, 6, 5, 4]
@@ -609,9 +609,9 @@ class TestCumprod(TestCase):
             a = np.array(ba, ctype)
             a2 = np.array(ba2, ctype)
             if ctype in ['1', 'b']:
-                self.assertRaises(ArithmeticError, np.cumprod, a)
-                self.assertRaises(ArithmeticError, np.cumprod, a2, 1)
-                self.assertRaises(ArithmeticError, np.cumprod, a)
+                assert_raises(ArithmeticError, np.cumprod, a)
+                assert_raises(ArithmeticError, np.cumprod, a2, 1)
+                assert_raises(ArithmeticError, np.cumprod, a)
             else:
                 assert_array_equal(np.cumprod(a, axis=-1),
                                    np.array([1, 2, 20, 220,
@@ -626,7 +626,7 @@ class TestCumprod(TestCase):
                                              [10, 30, 120, 600]], ctype))
 
 
-class TestDiff(TestCase):
+class TestDiff(object):
 
     def test_basic(self):
         x = [1, 4, 6, 7, 12]
@@ -659,9 +659,9 @@ class TestDiff(TestCase):
         assert_array_equal(diff(x, n=2, axis=0), out4)
 
 
-class TestDelete(TestCase):
+class TestDelete(object):
 
-    def setUp(self):
+    def setup(self):
         self.a = np.arange(5)
         self.nd_a = np.arange(5).repeat(2).reshape(1, 5, 2)
 
@@ -734,7 +734,7 @@ class TestDelete(TestCase):
         assert_equal(m.flags.f_contiguous, k.flags.f_contiguous)
 
 
-class TestGradient(TestCase):
+class TestGradient(object):
 
     def test_basic(self):
         v = [[1, 1], [3, 4]]
@@ -744,7 +744,7 @@ class TestGradient(TestCase):
         assert_array_equal(gradient(x), dx)
         assert_array_equal(gradient(v), dx)
 
-    def test_args(self):    
+    def test_args(self):
         dx = np.cumsum(np.ones(5))
         dx_uneven = [1., 2., 5., 9., 11.]
         f_2d = np.arange(25).reshape(5, 5)
@@ -827,15 +827,15 @@ class TestGradient(TestCase):
 
     def test_spacing(self):
         f = np.array([0, 2., 3., 4., 5., 5.])
-        f = np.tile(f, (6,1)) + f.reshape(-1, 1) 
+        f = np.tile(f, (6,1)) + f.reshape(-1, 1)
         x_uneven = np.array([0., 0.5, 1., 3., 5., 7.])
         x_even = np.arange(6.)
-        
+
         fdx_even_ord1 = np.tile([2., 1.5, 1., 1., 0.5, 0.], (6,1))
         fdx_even_ord2 = np.tile([2.5, 1.5, 1., 1., 0.5, -0.5], (6,1))
         fdx_uneven_ord1 = np.tile([4., 3., 1.7, 0.5, 0.25, 0.], (6,1))
         fdx_uneven_ord2 = np.tile([5., 3., 1.7, 0.5, 0.25, -0.25], (6,1))
-        
+
         # evenly spaced
         for edge_order, exp_res in [(1, fdx_even_ord1), (2, fdx_even_ord2)]:
             res1 = gradient(f, 1., axis=(0,1), edge_order=edge_order)
@@ -845,19 +845,19 @@ class TestGradient(TestCase):
                             axis=None, edge_order=edge_order)
             assert_array_equal(res1, res2)
             assert_array_equal(res2, res3)
-            assert_almost_equal(res1[0], exp_res.T)    
-            assert_almost_equal(res1[1], exp_res)    
-            
+            assert_almost_equal(res1[0], exp_res.T)
+            assert_almost_equal(res1[1], exp_res)
+
             res1 = gradient(f, 1., axis=0, edge_order=edge_order)
             res2 = gradient(f, x_even, axis=0, edge_order=edge_order)
             assert_(res1.shape == res2.shape)
             assert_almost_equal(res2, exp_res.T)
-            
+
             res1 = gradient(f, 1., axis=1, edge_order=edge_order)
             res2 = gradient(f, x_even, axis=1, edge_order=edge_order)
             assert_(res1.shape == res2.shape)
             assert_array_equal(res2, exp_res)
-            
+
         # unevenly spaced
         for edge_order, exp_res in [(1, fdx_uneven_ord1), (2, fdx_uneven_ord2)]:
             res1 = gradient(f, x_uneven, x_uneven,
@@ -867,13 +867,13 @@ class TestGradient(TestCase):
             assert_array_equal(res1, res2)
             assert_almost_equal(res1[0], exp_res.T)
             assert_almost_equal(res1[1], exp_res)
-            
+
             res1 = gradient(f, x_uneven, axis=0, edge_order=edge_order)
             assert_almost_equal(res1, exp_res.T)
-            
+
             res1 = gradient(f, x_uneven, axis=1, edge_order=edge_order)
             assert_almost_equal(res1, exp_res)
-                
+
         # mixed
         res1 = gradient(f, x_even, x_uneven, axis=(0,1), edge_order=1)
         res2 = gradient(f, x_uneven, x_even, axis=(1,0), edge_order=1)
@@ -881,14 +881,14 @@ class TestGradient(TestCase):
         assert_array_equal(res1[1], res2[0])
         assert_almost_equal(res1[0], fdx_even_ord1.T)
         assert_almost_equal(res1[1], fdx_uneven_ord1)
-        
+
         res1 = gradient(f, x_even, x_uneven, axis=(0,1), edge_order=2)
         res2 = gradient(f, x_uneven, x_even, axis=(1,0), edge_order=2)
         assert_array_equal(res1[0], res2[1])
         assert_array_equal(res1[1], res2[0])
         assert_almost_equal(res1[0], fdx_even_ord2.T)
         assert_almost_equal(res1[1], fdx_uneven_ord2)
-        
+
     def test_specific_axes(self):
         # Testing that gradient can work on a given axis only
         v = [[1, 1], [3, 4]]
@@ -914,7 +914,7 @@ class TestGradient(TestCase):
         assert_raises(np.AxisError, gradient, x, axis=3)
         assert_raises(np.AxisError, gradient, x, axis=-3)
         # assert_raises(TypeError, gradient, x, axis=[1,])
-        
+
     def test_timedelta64(self):
         # Make sure gradient() can handle special types like timedelta64
         x = np.array(
@@ -931,7 +931,7 @@ class TestGradient(TestCase):
         gradient(np.arange(2), edge_order=1)
         # needs at least 3 points for edge_order ==1
         gradient(np.arange(3), edge_order=2)
-        
+
         assert_raises(ValueError, gradient, np.arange(0), edge_order=1)
         assert_raises(ValueError, gradient, np.arange(0), edge_order=2)
         assert_raises(ValueError, gradient, np.arange(1), edge_order=1)
@@ -939,7 +939,7 @@ class TestGradient(TestCase):
         assert_raises(ValueError, gradient, np.arange(2), edge_order=2)
 
 
-class TestAngle(TestCase):
+class TestAngle(object):
 
     def test_basic(self):
         x = [1 + 3j, np.sqrt(2) / 2.0 + 1j * np.sqrt(2) / 2,
@@ -955,7 +955,7 @@ class TestAngle(TestCase):
         assert_array_almost_equal(z, zo, 11)
 
 
-class TestTrimZeros(TestCase):
+class TestTrimZeros(object):
 
     """
     Only testing for integer splits.
@@ -978,7 +978,7 @@ class TestTrimZeros(TestCase):
         assert_array_equal(res, np.array([1, 0, 2, 3, 0, 4]))
 
 
-class TestExtins(TestCase):
+class TestExtins(object):
 
     def test_basic(self):
         a = np.array([1, 3, 2, 1, 2, 3, 3])
@@ -1017,7 +1017,7 @@ class TestExtins(TestCase):
         assert_array_equal(a, ac)
 
 
-class TestVectorize(TestCase):
+class TestVectorize(object):
 
     def test_simple(self):
         def addsubtract(a, b):
@@ -1349,7 +1349,7 @@ class TestVectorize(TestCase):
             f(x)
 
 
-class TestDigitize(TestCase):
+class TestDigitize(object):
 
     def test_forward(self):
         x = np.arange(-6, 5)
@@ -1422,7 +1422,7 @@ class TestDigitize(TestCase):
         assert_(not isinstance(digitize(b, a, True), A))
 
 
-class TestUnwrap(TestCase):
+class TestUnwrap(object):
 
     def test_simple(self):
         # check that unwrap removes jumps greather that 2*pi
@@ -1431,7 +1431,7 @@ class TestUnwrap(TestCase):
         assert_(np.all(diff(unwrap(rand(10) * 100)) < np.pi))
 
 
-class TestFilterwindows(TestCase):
+class TestFilterwindows(object):
 
     def test_hanning(self):
         # check symmetry
@@ -1462,7 +1462,7 @@ class TestFilterwindows(TestCase):
         assert_almost_equal(np.sum(w, axis=0), 3.7800, 4)
 
 
-class TestTrapz(TestCase):
+class TestTrapz(object):
 
     def test_simple(self):
         x = np.arange(-10, 10, .1)
@@ -1534,7 +1534,7 @@ class TestTrapz(TestCase):
         assert_almost_equal(mr, r)
 
 
-class TestSinc(TestCase):
+class TestSinc(object):
 
     def test_simple(self):
         assert_(sinc(0) == 1)
@@ -1551,12 +1551,12 @@ class TestSinc(TestCase):
         assert_array_equal(y1, y3)
 
 
-class TestHistogram(TestCase):
+class TestHistogram(object):
 
-    def setUp(self):
+    def setup(self):
         pass
 
-    def tearDown(self):
+    def teardown(self):
         pass
 
     def test_simple(self):
@@ -1762,16 +1762,16 @@ class TestHistogram(TestCase):
         left_edges = edges[:-1][mask]
         right_edges = edges[1:][mask]
         for x, left, right in zip(arr, left_edges, right_edges):
-            self.assertGreaterEqual(x, left)
-            self.assertLess(x, right)
+            assert_(x >= left)
+            assert_(x < right)
 
     def test_last_bin_inclusive_range(self):
         arr = np.array([0.,  0.,  0.,  1.,  2.,  3.,  3.,  4.,  5.])
         hist, edges = np.histogram(arr, bins=30, range=(-0.5, 5))
-        self.assertEqual(hist[-1], 1)
+        assert_equal(hist[-1], 1)
 
 
-class TestHistogramOptimBinNums(TestCase):
+class TestHistogramOptimBinNums(object):
     """
     Provide test coverage when using provided estimators for optimal number of
     bins
@@ -1881,7 +1881,7 @@ class TestHistogramOptimBinNums(TestCase):
         completely ignored. All test values have been precomputed and
         the shouldn't change.
         """
-        # some basic sanity checking, with some fixed data. 
+        # some basic sanity checking, with some fixed data.
         # Checking for the correct number of bins
         basic_test = {
                       50:   {'fd': 8,  'scott': 8,  'rice': 15,
@@ -1893,7 +1893,7 @@ class TestHistogramOptimBinNums(TestCase):
                      }
 
         for testlen, expectedResults in basic_test.items():
-            # create some sort of non uniform data to test with 
+            # create some sort of non uniform data to test with
             # (3 peak uniform mixture)
             x1 = np.linspace(-10, -1, testlen // 5 * 2)
             x2 = np.linspace(1, 10, testlen // 5 * 3)
@@ -1911,11 +1911,11 @@ class TestHistogramOptimBinNums(TestCase):
         """
         estimator_list = ['fd', 'scott', 'rice', 'sturges', 'auto']
         for estimator in estimator_list:
-            assert_raises(TypeError, histogram, [1, 2, 3], 
+            assert_raises(TypeError, histogram, [1, 2, 3],
                           estimator, weights=[1, 2, 3])
 
 
-class TestHistogramdd(TestCase):
+class TestHistogramdd(object):
 
     def test_simple(self):
         x = np.array([[-.5, .5, 1.5], [-.5, 1.5, 2.5], [-.5, 2.5, .5],
@@ -2055,7 +2055,7 @@ class TestHistogramdd(TestCase):
                       range=[[0.0, 1.0], [np.nan, 0.75], [0.25, 0.5]])
 
 
-class TestUnique(TestCase):
+class TestUnique(object):
 
     def test_simple(self):
         x = np.array([4, 3, 2, 1, 1, 2, 3, 4, 0])
@@ -2067,7 +2067,7 @@ class TestUnique(TestCase):
         assert_(np.all(unique(x) == [1 + 1j, 1 + 10j, 5 + 6j, 10]))
 
 
-class TestCheckFinite(TestCase):
+class TestCheckFinite(object):
 
     def test_simple(self):
         a = [1, 2, 3]
@@ -2084,7 +2084,7 @@ class TestCheckFinite(TestCase):
         assert_(a.dtype == np.float64)
 
 
-class TestCorrCoef(TestCase):
+class TestCorrCoef(object):
     A = np.array(
         [[0.15391142, 0.18045767, 0.14197213],
          [0.70461506, 0.96474128, 0.27906989],
@@ -2169,7 +2169,7 @@ class TestCorrCoef(TestCase):
         assert_(np.all(np.abs(c) <= 1.0))
 
 
-class TestCov(TestCase):
+class TestCov(object):
     x1 = np.array([[0, 2], [1, 1], [2, 0]]).T
     res1 = np.array([[1., -1.], [-1., 1.]])
     x2 = np.array([0.0, 1.0, 2.0], ndmin=2)
@@ -2267,7 +2267,7 @@ class TestCov(TestCase):
                         self.res1)
 
 
-class Test_I0(TestCase):
+class Test_I0(object):
 
     def test_simple(self):
         assert_almost_equal(
@@ -2293,7 +2293,7 @@ class Test_I0(TestCase):
                       [1.05884290, 1.06432317]]))
 
 
-class TestKaiser(TestCase):
+class TestKaiser(object):
 
     def test_simple(self):
         assert_(np.isfinite(kaiser(1, 1.0)))
@@ -2312,7 +2312,7 @@ class TestKaiser(TestCase):
         kaiser(3, 4)
 
 
-class TestMsort(TestCase):
+class TestMsort(object):
 
     def test_simple(self):
         A = np.array([[0.44567325, 0.79115165, 0.54900530],
@@ -2325,7 +2325,7 @@ class TestMsort(TestCase):
                       [0.64864341, 0.79115165, 0.96098397]]))
 
 
-class TestMeshgrid(TestCase):
+class TestMeshgrid(object):
 
     def test_simple(self):
         [X, Y] = meshgrid([1, 2, 3], [4, 5, 6, 7])
@@ -2414,7 +2414,7 @@ class TestMeshgrid(TestCase):
         assert_equal(x[1, :], X)
 
 
-class TestPiecewise(TestCase):
+class TestPiecewise(object):
 
     def test_simple(self):
         # Condition is single bool list
@@ -2490,7 +2490,7 @@ class TestPiecewise(TestCase):
                                         [3., 3., 1.]]))
 
 
-class TestBincount(TestCase):
+class TestBincount(object):
 
     def test_simple(self):
         y = np.bincount(np.arange(4))
@@ -2577,7 +2577,7 @@ class TestBincount(TestCase):
         assert_equal(sys.getrefcount(np.dtype(np.double)), double_refcount)
 
 
-class TestInterp(TestCase):
+class TestInterp(object):
 
     def test_exceptions(self):
         assert_raises(ValueError, interp, 0, [], [])
@@ -2695,7 +2695,7 @@ def compare_results(res, desired):
         assert_array_equal(res[i], desired[i])
 
 
-class TestPercentile(TestCase):
+class TestPercentile(object):
 
     def test_basic(self):
         x = np.arange(8) * 0.5
@@ -2799,7 +2799,7 @@ class TestPercentile(TestCase):
         # test for no empty dimensions for compatibility with old percentile
         x = np.arange(12).reshape(3, 4)
         assert_equal(np.percentile(x, 50), 5.5)
-        self.assertTrue(np.isscalar(np.percentile(x, 50)))
+        assert_(np.isscalar(np.percentile(x, 50)))
         r0 = np.array([4.,  5.,  6.,  7.])
         assert_equal(np.percentile(x, 50, axis=0), r0)
         assert_equal(np.percentile(x, 50, axis=0).shape, r0.shape)
@@ -2820,7 +2820,7 @@ class TestPercentile(TestCase):
         # test for no empty dimensions for compatibility with old percentile
         x = np.arange(12).reshape(3, 4)
         assert_equal(np.percentile(x, 50, interpolation='lower'), 5.)
-        self.assertTrue(np.isscalar(np.percentile(x, 50)))
+        assert_(np.isscalar(np.percentile(x, 50)))
         r0 = np.array([4.,  5.,  6.,  7.])
         c0 = np.percentile(x, 50, interpolation='lower', axis=0)
         assert_equal(c0, r0)
@@ -3126,7 +3126,7 @@ class TestPercentile(TestCase):
                 a, [0.3, 0.6], (0, 2), interpolation='nearest'), b)
 
 
-class TestMedian(TestCase):
+class TestMedian(object):
 
     def test_basic(self):
         a0 = np.array(1)
@@ -3383,7 +3383,7 @@ class TestMedian(TestCase):
                      (1, 1, 7, 1))
 
 
-class TestAdd_newdoc_ufunc(TestCase):
+class TestAdd_newdoc_ufunc(object):
 
     def test_ufunc_arg(self):
         assert_raises(TypeError, add_newdoc_ufunc, 2, "blah")
@@ -3393,15 +3393,15 @@ class TestAdd_newdoc_ufunc(TestCase):
         assert_raises(TypeError, add_newdoc_ufunc, np.add, 3)
 
 
-class TestAdd_newdoc(TestCase):
+class TestAdd_newdoc(object):
 
     @dec.skipif(sys.flags.optimize == 2)
     def test_add_doc(self):
         # test np.add_newdoc
         tgt = "Current flat index into the array."
-        self.assertEqual(np.core.flatiter.index.__doc__[:len(tgt)], tgt)
-        self.assertTrue(len(np.core.ufunc.identity.__doc__) > 300)
-        self.assertTrue(len(np.lib.index_tricks.mgrid.__doc__) > 300)
+        assert_equal(np.core.flatiter.index.__doc__[:len(tgt)], tgt)
+        assert_(len(np.core.ufunc.identity.__doc__) > 300)
+        assert_(len(np.lib.index_tricks.mgrid.__doc__) > 300)
 
 
 if __name__ == "__main__":
diff --git a/numpy/lib/tests/test_index_tricks.py b/numpy/lib/tests/test_index_tricks.py
index 5b791026b..f06406c9e 100644
--- a/numpy/lib/tests/test_index_tricks.py
+++ b/numpy/lib/tests/test_index_tricks.py
@@ -2,7 +2,7 @@ from __future__ import division, absolute_import, print_function
 
 import numpy as np
 from numpy.testing import (
-    run_module_suite, TestCase, assert_, assert_equal, assert_array_equal,
+    run_module_suite, assert_, assert_equal, assert_array_equal,
     assert_almost_equal, assert_array_almost_equal, assert_raises
     )
 from numpy.lib.index_tricks import (
@@ -11,7 +11,7 @@ from numpy.lib.index_tricks import (
     )
 
 
-class TestRavelUnravelIndex(TestCase):
+class TestRavelUnravelIndex(object):
     def test_basic(self):
         assert_equal(np.unravel_index(2, (2, 2)), (1, 0))
         assert_equal(np.ravel_multi_index((1, 0), (2, 2)), 2)
@@ -110,11 +110,11 @@ class TestRavelUnravelIndex(TestCase):
     def test_writeability(self):
         # See gh-7269
         x, y = np.unravel_index([1, 2, 3], (4, 5))
-        self.assertTrue(x.flags.writeable)
-        self.assertTrue(y.flags.writeable)
+        assert_(x.flags.writeable)
+        assert_(y.flags.writeable)
 
 
-class TestGrid(TestCase):
+class TestGrid(object):
     def test_basic(self):
         a = mgrid[-1:1:10j]
         b = mgrid[-1:1:0.1]
@@ -147,7 +147,7 @@ class TestGrid(TestCase):
                                   0.2*np.ones(20, 'd'), 11)
 
 
-class TestConcatenator(TestCase):
+class TestConcatenator(object):
     def test_1d(self):
         assert_array_equal(r_[1, 2, 3, 4, 5, 6], np.array([1, 2, 3, 4, 5, 6]))
         b = np.ones(5)
@@ -206,14 +206,14 @@ class TestConcatenator(TestCase):
         assert_equal(type(actual), type(expected))
 
 
-class TestNdenumerate(TestCase):
+class TestNdenumerate(object):
     def test_basic(self):
         a = np.array([[1, 2], [3, 4]])
         assert_equal(list(ndenumerate(a)),
                      [((0, 0), 1), ((0, 1), 2), ((1, 0), 3), ((1, 1), 4)])
 
 
-class TestIndexExpression(TestCase):
+class TestIndexExpression(object):
     def test_regression_1(self):
         # ticket #1196
         a = np.arange(2)
@@ -227,7 +227,7 @@ class TestIndexExpression(TestCase):
         assert_equal(a[:, :3, [1, 2]], a[s_[:, :3, [1, 2]]])
 
 
-class TestIx_(TestCase):
+class TestIx_(object):
     def test_regression_1(self):
         # Test empty inputs create ouputs of indexing type, gh-5804
         # Test both lists and arrays
diff --git a/numpy/lib/tests/test_io.py b/numpy/lib/tests/test_io.py
index 868089551..4bc2a1b1b 100644
--- a/numpy/lib/tests/test_io.py
+++ b/numpy/lib/tests/test_io.py
@@ -17,9 +17,9 @@ from numpy.lib._iotools import ConverterError, ConversionWarning
 from numpy.compat import asbytes, bytes, unicode, Path
 from numpy.ma.testutils import assert_equal
 from numpy.testing import (
-    TestCase, run_module_suite, assert_warns, assert_,
-    assert_raises_regex, assert_raises, assert_allclose,
-    assert_array_equal, temppath, dec, IS_PYPY, suppress_warnings
+    run_module_suite, assert_warns, assert_, assert_raises_regex,
+    assert_raises, assert_allclose, assert_array_equal, temppath, dec, IS_PYPY,
+    suppress_warnings
 )
 
 
@@ -165,7 +165,7 @@ class RoundtripTest(object):
             self.check_roundtrips(a)
 
 
-class TestSaveLoad(RoundtripTest, TestCase):
+class TestSaveLoad(RoundtripTest):
     def roundtrip(self, *args, **kwargs):
         RoundtripTest.roundtrip(self, np.save, *args, **kwargs)
         assert_equal(self.arr[0], self.arr_reloaded)
@@ -173,7 +173,7 @@ class TestSaveLoad(RoundtripTest, TestCase):
         assert_equal(self.arr[0].flags.fnc, self.arr_reloaded.flags.fnc)
 
 
-class TestSavezLoad(RoundtripTest, TestCase):
+class TestSavezLoad(RoundtripTest):
     def roundtrip(self, *args, **kwargs):
         RoundtripTest.roundtrip(self, np.savez, *args, **kwargs)
         try:
@@ -304,7 +304,7 @@ class TestSavezLoad(RoundtripTest, TestCase):
             assert_(fp.closed)
 
 
-class TestSaveTxt(TestCase):
+class TestSaveTxt(object):
     def test_array(self):
         a = np.array([[1, 2], [3, 4]], float)
         fmt = "%.18e"
@@ -461,7 +461,7 @@ class TestSaveTxt(TestCase):
         assert_array_equal(a, b)
 
 
-class TestLoadTxt(TestCase):
+class TestLoadTxt(object):
     def test_record(self):
         c = TextIO()
         c.write('1 2\n3 4')
@@ -864,7 +864,7 @@ class TestLoadTxt(TestCase):
         np.loadtxt(c, delimiter=',', dtype=dt, comments=None)  # Should succeed
 
 
-class Testfromregex(TestCase):
+class Testfromregex(object):
     # np.fromregex expects files opened in binary mode.
     def test_record(self):
         c = TextIO()
@@ -902,7 +902,7 @@ class Testfromregex(TestCase):
 #####--------------------------------------------------------------------------
 
 
-class TestFromTxt(TestCase):
+class TestFromTxt(object):
     #
     def test_record(self):
         # Test w/ explicit dtype
@@ -1683,7 +1683,7 @@ M   33  21.99
         test = np.recfromtxt(data, **kwargs)
         control = np.array([(0, 1), (2, 3)],
                            dtype=[('A', np.int), ('B', np.int)])
-        self.assertTrue(isinstance(test, np.recarray))
+        assert_(isinstance(test, np.recarray))
         assert_equal(test, control)
         #
         data = TextIO('A,B\n0,1\n2,N/A')
@@ -1702,7 +1702,7 @@ M   33  21.99
         test = np.recfromcsv(data, dtype=None, **kwargs)
         control = np.array([(0, 1), (2, 3)],
                            dtype=[('A', np.int), ('B', np.int)])
-        self.assertTrue(isinstance(test, np.recarray))
+        assert_(isinstance(test, np.recarray))
         assert_equal(test, control)
         #
         data = TextIO('A,B\n0,1\n2,N/A')
@@ -1718,7 +1718,7 @@ M   33  21.99
         test = np.recfromcsv(data, missing_values='N/A',)
         control = np.array([(0, 1), (2, 3)],
                            dtype=[('a', np.int), ('b', np.int)])
-        self.assertTrue(isinstance(test, np.recarray))
+        assert_(isinstance(test, np.recarray))
         assert_equal(test, control)
         #
         data = TextIO('A,B\n0,1\n2,3')
@@ -1726,7 +1726,7 @@ M   33  21.99
         test = np.recfromcsv(data, missing_values='N/A', dtype=dtype)
         control = np.array([(0, 1), (2, 3)],
                            dtype=dtype)
-        self.assertTrue(isinstance(test, np.recarray))
+        assert_(isinstance(test, np.recarray))
         assert_equal(test, control)
 
     def test_max_rows(self):
@@ -1836,7 +1836,7 @@ M   33  21.99
         assert_equal(test['f2'], 1024)
 
 
-class TestPathUsage(TestCase):
+class TestPathUsage(object):
     # Test that pathlib.Path can be used
     @np.testing.dec.skipif(Path is None, "No pathlib.Path")
     def test_loadtxt(self):
@@ -1920,7 +1920,7 @@ class TestPathUsage(TestCase):
             test = np.recfromtxt(path, **kwargs)
             control = np.array([(0, 1), (2, 3)],
                                dtype=[('A', np.int), ('B', np.int)])
-            self.assertTrue(isinstance(test, np.recarray))
+            assert_(isinstance(test, np.recarray))
             assert_equal(test, control)
 
     @np.testing.dec.skipif(Path is None, "No pathlib.Path")
@@ -1934,7 +1934,7 @@ class TestPathUsage(TestCase):
             test = np.recfromcsv(path, dtype=None, **kwargs)
             control = np.array([(0, 1), (2, 3)],
                                dtype=[('A', np.int), ('B', np.int)])
-            self.assertTrue(isinstance(test, np.recarray))
+            assert_(isinstance(test, np.recarray))
             assert_equal(test, control)
 
 
diff --git a/numpy/lib/tests/test_mixins.py b/numpy/lib/tests/test_mixins.py
index db38bdfd6..94f06c336 100644
--- a/numpy/lib/tests/test_mixins.py
+++ b/numpy/lib/tests/test_mixins.py
@@ -6,7 +6,8 @@ import sys
 
 import numpy as np
 from numpy.testing import (
-    TestCase, run_module_suite, assert_, assert_equal, assert_raises)
+    run_module_suite, assert_, assert_equal, assert_raises
+    )
 
 
 PY2 = sys.version_info.major < 3
@@ -99,7 +100,7 @@ _ALL_BINARY_OPERATORS = [
 ]
 
 
-class TestNDArrayOperatorsMixin(TestCase):
+class TestNDArrayOperatorsMixin(object):
 
     def test_array_like_add(self):
 
diff --git a/numpy/lib/tests/test_nanfunctions.py b/numpy/lib/tests/test_nanfunctions.py
index 466ceefb5..3d362fc6e 100644
--- a/numpy/lib/tests/test_nanfunctions.py
+++ b/numpy/lib/tests/test_nanfunctions.py
@@ -4,7 +4,7 @@ import warnings
 
 import numpy as np
 from numpy.testing import (
-    run_module_suite, TestCase, assert_, assert_equal, assert_almost_equal,
+    run_module_suite, assert_, assert_equal, assert_almost_equal,
     assert_no_warnings, assert_raises, assert_array_equal, suppress_warnings
     )
 
@@ -35,7 +35,7 @@ _ndat_zeros = np.array([[0.6244, 0.0, 0.2692, 0.0116, 0.0, 0.1170],
                         [0.1610, 0.0, 0.0, 0.1859, 0.3146, 0.0]])
 
 
-class TestNanFunctions_MinMax(TestCase):
+class TestNanFunctions_MinMax(object):
 
     nanfuncs = [np.nanmin, np.nanmax]
     stdfuncs = [np.min, np.max]
@@ -165,7 +165,7 @@ class TestNanFunctions_MinMax(TestCase):
             assert_(issubclass(w[0].category, RuntimeWarning))
 
 
-class TestNanFunctions_ArgminArgmax(TestCase):
+class TestNanFunctions_ArgminArgmax(object):
 
     nanfuncs = [np.nanargmin, np.nanargmax]
 
@@ -224,7 +224,7 @@ class TestNanFunctions_ArgminArgmax(TestCase):
             assert_(np.isscalar(res))
 
 
-class TestNanFunctions_IntTypes(TestCase):
+class TestNanFunctions_IntTypes(object):
 
     int_types = (np.int8, np.int16, np.int32, np.int64, np.uint8,
                  np.uint16, np.uint32, np.uint64)
@@ -396,7 +396,7 @@ class SharedNanFunctionsTestsMixin(object):
             assert_(np.isscalar(res))
 
 
-class TestNanFunctions_SumProd(TestCase, SharedNanFunctionsTestsMixin):
+class TestNanFunctions_SumProd(SharedNanFunctionsTestsMixin):
 
     nanfuncs = [np.nansum, np.nanprod]
     stdfuncs = [np.sum, np.prod]
@@ -430,7 +430,7 @@ class TestNanFunctions_SumProd(TestCase, SharedNanFunctionsTestsMixin):
             assert_equal(res, tgt)
 
 
-class TestNanFunctions_CumSumProd(TestCase, SharedNanFunctionsTestsMixin):
+class TestNanFunctions_CumSumProd(SharedNanFunctionsTestsMixin):
 
     nanfuncs = [np.nancumsum, np.nancumprod]
     stdfuncs = [np.cumsum, np.cumprod]
@@ -513,7 +513,7 @@ class TestNanFunctions_CumSumProd(TestCase, SharedNanFunctionsTestsMixin):
                 assert_almost_equal(res, tgt)
 
 
-class TestNanFunctions_MeanVarStd(TestCase, SharedNanFunctionsTestsMixin):
+class TestNanFunctions_MeanVarStd(SharedNanFunctionsTestsMixin):
 
     nanfuncs = [np.nanmean, np.nanvar, np.nanstd]
     stdfuncs = [np.mean, np.var, np.std]
@@ -585,7 +585,7 @@ class TestNanFunctions_MeanVarStd(TestCase, SharedNanFunctionsTestsMixin):
                     assert_(len(w) == 0)
 
 
-class TestNanFunctions_Median(TestCase):
+class TestNanFunctions_Median(object):
 
     def test_mutation(self):
         # Check that passed array is not modified.
@@ -749,7 +749,7 @@ class TestNanFunctions_Median(TestCase):
                                      ([np.nan] * i) + [-inf] * j)
 
 
-class TestNanFunctions_Percentile(TestCase):
+class TestNanFunctions_Percentile(object):
 
     def test_mutation(self):
         # Check that passed array is not modified.
diff --git a/numpy/lib/tests/test_polynomial.py b/numpy/lib/tests/test_polynomial.py
index 0725c186d..9a4650825 100644
--- a/numpy/lib/tests/test_polynomial.py
+++ b/numpy/lib/tests/test_polynomial.py
@@ -80,12 +80,12 @@ poly1d([ 2.])
 '''
 import numpy as np
 from numpy.testing import (
-    run_module_suite, TestCase, assert_, assert_equal, assert_array_equal,
+    run_module_suite, assert_, assert_equal, assert_array_equal,
     assert_almost_equal, assert_array_almost_equal, assert_raises, rundocs
     )
 
 
-class TestDocs(TestCase):
+class TestDocs(object):
     def test_doctests(self):
         return rundocs()
 
diff --git a/numpy/lib/tests/test_recfunctions.py b/numpy/lib/tests/test_recfunctions.py
index 7cf93d67f..bc9f8d7b6 100644
--- a/numpy/lib/tests/test_recfunctions.py
+++ b/numpy/lib/tests/test_recfunctions.py
@@ -5,8 +5,8 @@ import numpy.ma as ma
 from numpy.ma.mrecords import MaskedRecords
 from numpy.ma.testutils import assert_equal
 from numpy.testing import (
-    TestCase, run_module_suite, assert_, assert_raises, dec
-)
+    run_module_suite, assert_, assert_raises, dec
+    )
 from numpy.lib.recfunctions import (
     drop_fields, rename_fields, get_fieldstructure, recursive_fill_fields,
     find_duplicates, merge_arrays, append_fields, stack_arrays, join_by
@@ -16,10 +16,10 @@ get_names_flat = np.lib.recfunctions.get_names_flat
 zip_descr = np.lib.recfunctions.zip_descr
 
 
-class TestRecFunctions(TestCase):
+class TestRecFunctions(object):
     # Misc tests
 
-    def setUp(self):
+    def setup(self):
         x = np.array([1, 2, ])
         y = np.array([10, 20, 30])
         z = np.array([('A', 1.), ('B', 2.)],
@@ -193,7 +193,7 @@ class TestRecFunctions(TestCase):
         assert_equal(test[0], a[test[-1]])
 
 
-class TestRecursiveFillFields(TestCase):
+class TestRecursiveFillFields(object):
     # Test recursive_fill_fields.
     def test_simple_flexible(self):
         # Test recursive_fill_fields on flexible-array
@@ -216,10 +216,10 @@ class TestRecursiveFillFields(TestCase):
         assert_equal(test, control)
 
 
-class TestMergeArrays(TestCase):
+class TestMergeArrays(object):
     # Test merge_arrays
 
-    def setUp(self):
+    def setup(self):
         x = np.array([1, 2, ])
         y = np.array([10, 20, 30])
         z = np.array(
@@ -349,10 +349,10 @@ class TestMergeArrays(TestCase):
         assert_equal(test, control)
 
 
-class TestAppendFields(TestCase):
+class TestAppendFields(object):
     # Test append_fields
 
-    def setUp(self):
+    def setup(self):
         x = np.array([1, 2, ])
         y = np.array([10, 20, 30])
         z = np.array(
@@ -403,9 +403,9 @@ class TestAppendFields(TestCase):
         assert_equal(test, control)
 
 
-class TestStackArrays(TestCase):
+class TestStackArrays(object):
     # Test stack_arrays
-    def setUp(self):
+    def setup(self):
         x = np.array([1, 2, ])
         y = np.array([10, 20, 30])
         z = np.array(
@@ -419,11 +419,11 @@ class TestStackArrays(TestCase):
         (_, x, _, _) = self.data
         test = stack_arrays((x,))
         assert_equal(test, x)
-        self.assertTrue(test is x)
+        assert_(test is x)
 
         test = stack_arrays(x)
         assert_equal(test, x)
-        self.assertTrue(test is x)
+        assert_(test is x)
 
     def test_unnamed_fields(self):
         # Tests combinations of arrays w/o named fields
@@ -578,8 +578,8 @@ class TestStackArrays(TestCase):
         assert_equal(res.mask, expected.mask)
 
 
-class TestJoinBy(TestCase):
-    def setUp(self):
+class TestJoinBy(object):
+    def setup(self):
         self.a = np.array(list(zip(np.arange(10), np.arange(50, 60),
                                    np.arange(100, 110))),
                           dtype=[('a', int), ('b', int), ('c', int)])
@@ -744,9 +744,9 @@ class TestJoinBy(TestCase):
         assert_equal(res.dtype, expected_dtype)
 
 
-class TestJoinBy2(TestCase):
+class TestJoinBy2(object):
     @classmethod
-    def setUp(cls):
+    def setup(cls):
         cls.a = np.array(list(zip(np.arange(10), np.arange(50, 60),
                                   np.arange(100, 110))),
                          dtype=[('a', int), ('b', int), ('c', int)])
@@ -770,8 +770,8 @@ class TestJoinBy2(TestCase):
         assert_equal(test, control)
 
     def test_no_postfix(self):
-        self.assertRaises(ValueError, join_by, 'a', self.a, self.b,
-                          r1postfix='', r2postfix='')
+        assert_raises(ValueError, join_by, 'a', self.a, self.b,
+                      r1postfix='', r2postfix='')
 
     def test_no_r2postfix(self):
         # Basic test of join_by no_r2postfix
@@ -809,13 +809,13 @@ class TestJoinBy2(TestCase):
         assert_equal(test.dtype, control.dtype)
         assert_equal(test, control)
 
-class TestAppendFieldsObj(TestCase):
+class TestAppendFieldsObj(object):
     """
     Test append_fields with arrays containing objects
     """
     # https://github.com/numpy/numpy/issues/2346
 
-    def setUp(self):
+    def setup(self):
         from datetime import date
         self.data = dict(obj=date(2000, 1, 1))
 
diff --git a/numpy/lib/tests/test_regression.py b/numpy/lib/tests/test_regression.py
index 6095ac4ba..1567219d6 100644
--- a/numpy/lib/tests/test_regression.py
+++ b/numpy/lib/tests/test_regression.py
@@ -5,7 +5,7 @@ import sys
 
 import numpy as np
 from numpy.testing import (
-    run_module_suite, TestCase, assert_, assert_equal, assert_array_equal,
+    run_module_suite, assert_, assert_equal, assert_array_equal,
     assert_array_almost_equal, assert_raises, _assert_valid_refcount,
     )
 from numpy.compat import unicode
@@ -13,7 +13,7 @@ from numpy.compat import unicode
 rlevel = 1
 
 
-class TestRegression(TestCase):
+class TestRegression(object):
     def test_poly1d(self, level=rlevel):
         # Ticket #28
         assert_equal(np.poly1d([1]) - np.poly1d([1, 0]),
@@ -59,7 +59,7 @@ class TestRegression(TestCase):
     def test_poly1d_nan_roots(self, level=rlevel):
         # Ticket #396
         p = np.poly1d([np.nan, np.nan, 1], r=0)
-        self.assertRaises(np.linalg.LinAlgError, getattr, p, "r")
+        assert_raises(np.linalg.LinAlgError, getattr, p, "r")
 
     def test_mem_polymul(self, level=rlevel):
         # Ticket #448
@@ -155,8 +155,8 @@ class TestRegression(TestCase):
             i = np.random.randint(0, n, size=thesize)
             a[np.ix_(i, i, i, i, i)]
 
-        self.assertRaises(ValueError, dp)
-        self.assertRaises(ValueError, dp2)
+        assert_raises(ValueError, dp)
+        assert_raises(ValueError, dp2)
 
     def test_void_coercion(self, level=rlevel):
         dt = np.dtype([('a', 'f4'), ('b', 'i4')])
diff --git a/numpy/lib/tests/test_shape_base.py b/numpy/lib/tests/test_shape_base.py
index 14406fe21..9e739ea63 100644
--- a/numpy/lib/tests/test_shape_base.py
+++ b/numpy/lib/tests/test_shape_base.py
@@ -8,12 +8,12 @@ from numpy.lib.shape_base import (
     vsplit, dstack, column_stack, kron, tile, expand_dims,
     )
 from numpy.testing import (
-    run_module_suite, TestCase, assert_, assert_equal, assert_array_equal,
-    assert_raises, assert_warns
+    run_module_suite, assert_, assert_equal, assert_array_equal, assert_raises,
+    assert_warns
     )
 
 
-class TestApplyAlongAxis(TestCase):
+class TestApplyAlongAxis(object):
     def test_simple(self):
         a = np.ones((20, 10), 'd')
         assert_array_equal(
@@ -177,14 +177,14 @@ class TestApplyAlongAxis(TestCase):
             assert_equal(type(actual[i]), type(expected[i]))
 
 
-class TestApplyOverAxes(TestCase):
+class TestApplyOverAxes(object):
     def test_simple(self):
         a = np.arange(24).reshape(2, 3, 4)
         aoa_a = apply_over_axes(np.sum, a, [0, 2])
         assert_array_equal(aoa_a, np.array([[[60], [92], [124]]]))
 
 
-class TestExpandDims(TestCase):
+class TestExpandDims(object):
     def test_functionality(self):
         s = (2, 3, 4, 5)
         a = np.empty(s)
@@ -203,7 +203,7 @@ class TestExpandDims(TestCase):
             assert_warns(DeprecationWarning, expand_dims, a, 5)
 
 
-class TestArraySplit(TestCase):
+class TestArraySplit(object):
     def test_integer_0_split(self):
         a = np.arange(10)
         assert_raises(ValueError, array_split, a, 0)
@@ -328,7 +328,7 @@ class TestArraySplit(TestCase):
         compare_results(res, desired)
 
 
-class TestSplit(TestCase):
+class TestSplit(object):
     # The split 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.
@@ -343,12 +343,12 @@ class TestSplit(TestCase):
         a = np.arange(10)
         assert_raises(ValueError, split, a, 3)
 
-class TestColumnStack(TestCase):
+class TestColumnStack(object):
     def test_non_iterable(self):
         assert_raises(TypeError, column_stack, 1)
 
 
-class TestDstack(TestCase):
+class TestDstack(object):
     def test_non_iterable(self):
         assert_raises(TypeError, dstack, 1)
 
@@ -383,7 +383,7 @@ class TestDstack(TestCase):
 
 # array_split has more comprehensive test of splitting.
 # only do simple test on hsplit, vsplit, and dsplit
-class TestHsplit(TestCase):
+class TestHsplit(object):
     """Only testing for integer splits.
 
     """
@@ -412,7 +412,7 @@ class TestHsplit(TestCase):
         compare_results(res, desired)
 
 
-class TestVsplit(TestCase):
+class TestVsplit(object):
     """Only testing for integer splits.
 
     """
@@ -439,7 +439,7 @@ class TestVsplit(TestCase):
         compare_results(res, desired)
 
 
-class TestDsplit(TestCase):
+class TestDsplit(object):
     # Only testing for integer splits.
     def test_non_iterable(self):
         assert_raises(ValueError, dsplit, 1, 1)
@@ -472,7 +472,7 @@ class TestDsplit(TestCase):
         compare_results(res, desired)
 
 
-class TestSqueeze(TestCase):
+class TestSqueeze(object):
     def test_basic(self):
         from numpy.random import rand
 
@@ -491,7 +491,7 @@ class TestSqueeze(TestCase):
         assert_equal(type(res), np.ndarray)
 
 
-class TestKron(TestCase):
+class TestKron(object):
     def test_return_type(self):
         a = np.ones([2, 2])
         m = np.asmatrix(a)
@@ -510,7 +510,7 @@ class TestKron(TestCase):
         assert_equal(type(kron(ma, a)), myarray)
 
 
-class TestTile(TestCase):
+class TestTile(object):
     def test_basic(self):
         a = np.array([0, 1, 2])
         b = [[1, 2], [3, 4]]
@@ -550,19 +550,19 @@ class TestTile(TestCase):
                 assert_equal(large, klarge)
 
 
-class TestMayShareMemory(TestCase):
+class TestMayShareMemory(object):
     def test_basic(self):
         d = np.ones((50, 60))
         d2 = np.ones((30, 60, 6))
-        self.assertTrue(np.may_share_memory(d, d))
-        self.assertTrue(np.may_share_memory(d, d[::-1]))
-        self.assertTrue(np.may_share_memory(d, d[::2]))
-        self.assertTrue(np.may_share_memory(d, d[1:, ::-1]))
-
-        self.assertFalse(np.may_share_memory(d[::-1], d2))
-        self.assertFalse(np.may_share_memory(d[::2], d2))
-        self.assertFalse(np.may_share_memory(d[1:, ::-1], d2))
-        self.assertTrue(np.may_share_memory(d2[1:, ::-1], d2))
+        assert_(np.may_share_memory(d, d))
+        assert_(np.may_share_memory(d, d[::-1]))
+        assert_(np.may_share_memory(d, d[::2]))
+        assert_(np.may_share_memory(d, d[1:, ::-1]))
+
+        assert_(not np.may_share_memory(d[::-1], d2))
+        assert_(not np.may_share_memory(d[::2], d2))
+        assert_(not np.may_share_memory(d[1:, ::-1], d2))
+        assert_(np.may_share_memory(d2[1:, ::-1], d2))
 
 
 # Utility
diff --git a/numpy/lib/tests/test_twodim_base.py b/numpy/lib/tests/test_twodim_base.py
index d57791e34..6bf668dee 100644
--- a/numpy/lib/tests/test_twodim_base.py
+++ b/numpy/lib/tests/test_twodim_base.py
@@ -4,8 +4,8 @@
 from __future__ import division, absolute_import, print_function
 
 from numpy.testing import (
-    TestCase, run_module_suite, assert_equal, assert_array_equal,
-    assert_array_max_ulp, assert_array_almost_equal, assert_raises,
+    run_module_suite, assert_equal, assert_array_equal, assert_array_max_ulp,
+    assert_array_almost_equal, assert_raises,
     )
 
 from numpy import (
@@ -23,7 +23,7 @@ def get_mat(n):
     return data
 
 
-class TestEye(TestCase):
+class TestEye(object):
     def test_basic(self):
         assert_equal(eye(4),
                      array([[1, 0, 0, 0],
@@ -96,7 +96,7 @@ class TestEye(TestCase):
         assert_equal(eye(2, 2, dtype=bool), [[True, False], [False, True]])
 
 
-class TestDiag(TestCase):
+class TestDiag(object):
     def test_vector(self):
         vals = (100 * arange(5)).astype('l')
         b = zeros((5, 5))
@@ -140,12 +140,12 @@ class TestDiag(TestCase):
         assert_equal(diag(A, k=-3), [])
 
     def test_failure(self):
-        self.assertRaises(ValueError, diag, [[[1]]])
+        assert_raises(ValueError, diag, [[[1]]])
 
 
-class TestFliplr(TestCase):
+class TestFliplr(object):
     def test_basic(self):
-        self.assertRaises(ValueError, fliplr, ones(4))
+        assert_raises(ValueError, fliplr, ones(4))
         a = get_mat(4)
         b = a[:, ::-1]
         assert_equal(fliplr(a), b)
@@ -156,7 +156,7 @@ class TestFliplr(TestCase):
         assert_equal(fliplr(a), b)
 
 
-class TestFlipud(TestCase):
+class TestFlipud(object):
     def test_basic(self):
         a = get_mat(4)
         b = a[::-1, :]
@@ -168,7 +168,7 @@ class TestFlipud(TestCase):
         assert_equal(flipud(a), b)
 
 
-class TestHistogram2d(TestCase):
+class TestHistogram2d(object):
     def test_simple(self):
         x = array(
             [0.41702200, 0.72032449, 1.1437481e-4, 0.302332573, 0.146755891])
@@ -265,7 +265,7 @@ class TestHistogram2d(TestCase):
         assert_array_equal(xe, array([0., 0.25, 0.5, 0.75, 1]))
 
 
-class TestTri(TestCase):
+class TestTri(object):
     def test_dtype(self):
         out = array([[1, 0, 0],
                      [1, 1, 0],
@@ -349,10 +349,10 @@ def test_mask_indices():
     # simple test without offset
     iu = mask_indices(3, np.triu)
     a = np.arange(9).reshape(3, 3)
-    yield (assert_array_equal, a[iu], array([0, 1, 2, 4, 5, 8]))
+    assert_array_equal(a[iu], array([0, 1, 2, 4, 5, 8]))
     # Now with an offset
     iu1 = mask_indices(3, np.triu, 1)
-    yield (assert_array_equal, a[iu1], array([1, 2, 5]))
+    assert_array_equal(a[iu1], array([1, 2, 5]))
 
 
 def test_tril_indices():
@@ -369,37 +369,37 @@ def test_tril_indices():
     b = np.arange(1, 21).reshape(4, 5)
 
     # indexing:
-    yield (assert_array_equal, a[il1],
-           array([1, 5, 6, 9, 10, 11, 13, 14, 15, 16]))
-    yield (assert_array_equal, b[il3],
-           array([1, 6, 7, 11, 12, 13, 16, 17, 18, 19]))
+    assert_array_equal(a[il1],
+                       array([1, 5, 6, 9, 10, 11, 13, 14, 15, 16]))
+    assert_array_equal(b[il3],
+                       array([1, 6, 7, 11, 12, 13, 16, 17, 18, 19]))
 
     # And for assigning values:
     a[il1] = -1
-    yield (assert_array_equal, a,
-           array([[-1, 2, 3, 4],
-                  [-1, -1, 7, 8],
-                  [-1, -1, -1, 12],
-                  [-1, -1, -1, -1]]))
+    assert_array_equal(a,
+                       array([[-1, 2, 3, 4],
+                              [-1, -1, 7, 8],
+                              [-1, -1, -1, 12],
+                              [-1, -1, -1, -1]]))
     b[il3] = -1
-    yield (assert_array_equal, b,
-           array([[-1, 2, 3, 4, 5],
-                  [-1, -1, 8, 9, 10],
-                  [-1, -1, -1, 14, 15],
-                  [-1, -1, -1, -1, 20]]))
+    assert_array_equal(b,
+                       array([[-1, 2, 3, 4, 5],
+                              [-1, -1, 8, 9, 10],
+                              [-1, -1, -1, 14, 15],
+                              [-1, -1, -1, -1, 20]]))
     # These cover almost the whole array (two diagonals right of the main one):
     a[il2] = -10
-    yield (assert_array_equal, a,
-           array([[-10, -10, -10, 4],
-                  [-10, -10, -10, -10],
-                  [-10, -10, -10, -10],
-                  [-10, -10, -10, -10]]))
+    assert_array_equal(a,
+                       array([[-10, -10, -10, 4],
+                              [-10, -10, -10, -10],
+                              [-10, -10, -10, -10],
+                              [-10, -10, -10, -10]]))
     b[il4] = -10
-    yield (assert_array_equal, b,
-           array([[-10, -10, -10, 4, 5],
-                  [-10, -10, -10, -10, 10],
-                  [-10, -10, -10, -10, -10],
-                  [-10, -10, -10, -10, -10]]))
+    assert_array_equal(b,
+                       array([[-10, -10, -10, 4, 5],
+                              [-10, -10, -10, -10, 10],
+                              [-10, -10, -10, -10, -10],
+                              [-10, -10, -10, -10, -10]]))
 
 
 class TestTriuIndices(object):
@@ -416,39 +416,40 @@ class TestTriuIndices(object):
         b = np.arange(1, 21).reshape(4, 5)
 
         # Both for indexing:
-        yield (assert_array_equal, a[iu1],
-               array([1, 2, 3, 4, 6, 7, 8, 11, 12, 16]))
-        yield (assert_array_equal, b[iu3],
-               array([1, 2, 3, 4, 5, 7, 8, 9, 10, 13, 14, 15, 19, 20]))
+        assert_array_equal(a[iu1],
+                           array([1, 2, 3, 4, 6, 7, 8, 11, 12, 16]))
+        assert_array_equal(b[iu3],
+                           array([1, 2, 3, 4, 5, 7, 8, 9,
+                                  10, 13, 14, 15, 19, 20]))
 
         # And for assigning values:
         a[iu1] = -1
-        yield (assert_array_equal, a,
-               array([[-1, -1, -1, -1],
-                      [5, -1, -1, -1],
-                      [9, 10, -1, -1],
-                      [13, 14, 15, -1]]))
+        assert_array_equal(a,
+                           array([[-1, -1, -1, -1],
+                                  [5, -1, -1, -1],
+                                  [9, 10, -1, -1],
+                                  [13, 14, 15, -1]]))
         b[iu3] = -1
-        yield (assert_array_equal, b,
-               array([[-1, -1, -1, -1, -1],
-                      [6, -1, -1, -1, -1],
-                      [11, 12, -1, -1, -1],
-                      [16, 17, 18, -1, -1]]))
+        assert_array_equal(b,
+                           array([[-1, -1, -1, -1, -1],
+                                  [6, -1, -1, -1, -1],
+                                  [11, 12, -1, -1, -1],
+                                  [16, 17, 18, -1, -1]]))
 
         # These cover almost the whole array (two diagonals right of the
         # main one):
         a[iu2] = -10
-        yield (assert_array_equal, a,
-               array([[-1, -1, -10, -10],
-                      [5, -1, -1, -10],
-                      [9, 10, -1, -1],
-                      [13, 14, 15, -1]]))
+        assert_array_equal(a,
+                           array([[-1, -1, -10, -10],
+                                  [5, -1, -1, -10],
+                                  [9, 10, -1, -1],
+                                  [13, 14, 15, -1]]))
         b[iu4] = -10
-        yield (assert_array_equal, b,
-               array([[-1, -1, -10, -10, -10],
-                      [6, -1, -1, -10, -10],
-                      [11, 12, -1, -1, -10],
-                      [16, 17, 18, -1, -1]]))
+        assert_array_equal(b,
+                           array([[-1, -1, -10, -10, -10],
+                                  [6, -1, -1, -10, -10],
+                                  [11, 12, -1, -1, -10],
+                                  [16, 17, 18, -1, -1]]))
 
 
 class TestTrilIndicesFrom(object):
diff --git a/numpy/lib/tests/test_type_check.py b/numpy/lib/tests/test_type_check.py
index 383ffa55c..259fcd4e5 100644
--- a/numpy/lib/tests/test_type_check.py
+++ b/numpy/lib/tests/test_type_check.py
@@ -3,7 +3,7 @@ from __future__ import division, absolute_import, print_function
 import numpy as np
 from numpy.compat import long
 from numpy.testing import (
-    TestCase, assert_, assert_equal, assert_array_equal, run_module_suite
+    assert_, assert_equal, assert_array_equal, run_module_suite
     )
 from numpy.lib.type_check import (
     common_type, mintypecode, isreal, iscomplex, isposinf, isneginf,
@@ -15,7 +15,7 @@ def assert_all(x):
     assert_(np.all(x), x)
 
 
-class TestCommonType(TestCase):
+class TestCommonType(object):
     def test_basic(self):
         ai32 = np.array([[1, 2], [3, 4]], dtype=np.int32)
         af16 = np.array([[1, 2], [3, 4]], dtype=np.float16)
@@ -31,7 +31,7 @@ class TestCommonType(TestCase):
         assert_(common_type(acd) == np.cdouble)
 
 
-class TestMintypecode(TestCase):
+class TestMintypecode(object):
 
     def test_default_1(self):
         for itype in '1bcsuwil':
@@ -81,7 +81,7 @@ class TestMintypecode(TestCase):
         assert_equal(mintypecode('idD'), 'D')
 
 
-class TestIsscalar(TestCase):
+class TestIsscalar(object):
 
     def test_basic(self):
         assert_(np.isscalar(3))
@@ -92,7 +92,7 @@ class TestIsscalar(TestCase):
         assert_(np.isscalar(4.0))
 
 
-class TestReal(TestCase):
+class TestReal(object):
 
     def test_real(self):
         y = np.random.rand(10,)
@@ -123,7 +123,7 @@ class TestReal(TestCase):
         assert_(not isinstance(out, np.ndarray))
 
 
-class TestImag(TestCase):
+class TestImag(object):
 
     def test_real(self):
         y = np.random.rand(10,)
@@ -154,7 +154,7 @@ class TestImag(TestCase):
         assert_(not isinstance(out, np.ndarray))
 
 
-class TestIscomplex(TestCase):
+class TestIscomplex(object):
 
     def test_fail(self):
         z = np.array([-1, 0, 1])
@@ -167,7 +167,7 @@ class TestIscomplex(TestCase):
         assert_array_equal(res, [1, 0, 0])
 
 
-class TestIsreal(TestCase):
+class TestIsreal(object):
 
     def test_pass(self):
         z = np.array([-1, 0, 1j])
@@ -180,7 +180,7 @@ class TestIsreal(TestCase):
         assert_array_equal(res, [0, 1, 1])
 
 
-class TestIscomplexobj(TestCase):
+class TestIscomplexobj(object):
 
     def test_basic(self):
         z = np.array([-1, 0, 1])
@@ -233,7 +233,7 @@ class TestIscomplexobj(TestCase):
         assert_(iscomplexobj(a))
 
 
-class TestIsrealobj(TestCase):
+class TestIsrealobj(object):
     def test_basic(self):
         z = np.array([-1, 0, 1])
         assert_(isrealobj(z))
@@ -241,7 +241,7 @@ class TestIsrealobj(TestCase):
         assert_(not isrealobj(z))
 
 
-class TestIsnan(TestCase):
+class TestIsnan(object):
 
     def test_goodvalues(self):
         z = np.array((-1., 0., 1.))
@@ -271,7 +271,7 @@ class TestIsnan(TestCase):
             assert_all(np.isnan(np.array(0+0j)/0.) == 1)
 
 
-class TestIsfinite(TestCase):
+class TestIsfinite(object):
     # Fixme, wrong place, isfinite now ufunc
 
     def test_goodvalues(self):
@@ -302,7 +302,7 @@ class TestIsfinite(TestCase):
             assert_all(np.isfinite(np.array(1+1j)/0.) == 0)
 
 
-class TestIsinf(TestCase):
+class TestIsinf(object):
     # Fixme, wrong place, isinf now ufunc
 
     def test_goodvalues(self):
@@ -331,7 +331,7 @@ class TestIsinf(TestCase):
             assert_all(np.isinf(np.array((0.,))/0.) == 0)
 
 
-class TestIsposinf(TestCase):
+class TestIsposinf(object):
 
     def test_generic(self):
         with np.errstate(divide='ignore', invalid='ignore'):
@@ -341,7 +341,7 @@ class TestIsposinf(TestCase):
         assert_(vals[2] == 1)
 
 
-class TestIsneginf(TestCase):
+class TestIsneginf(object):
 
     def test_generic(self):
         with np.errstate(divide='ignore', invalid='ignore'):
@@ -351,7 +351,7 @@ class TestIsneginf(TestCase):
         assert_(vals[2] == 0)
 
 
-class TestNanToNum(TestCase):
+class TestNanToNum(object):
 
     def test_generic(self):
         with np.errstate(divide='ignore', invalid='ignore'):
@@ -402,7 +402,7 @@ class TestNanToNum(TestCase):
         #assert_all(vals.real < -1e10) and assert_all(np.isfinite(vals))
 
 
-class TestRealIfClose(TestCase):
+class TestRealIfClose(object):
 
     def test_basic(self):
         a = np.random.rand(10)
@@ -415,7 +415,7 @@ class TestRealIfClose(TestCase):
         assert_all(isrealobj(b))
 
 
-class TestArrayConversion(TestCase):
+class TestArrayConversion(object):
 
     def test_asfarray(self):
         a = asfarray(np.array([1, 2, 3]))
diff --git a/numpy/lib/tests/test_ufunclike.py b/numpy/lib/tests/test_ufunclike.py
index 0b152540f..128ce37ab 100644
--- a/numpy/lib/tests/test_ufunclike.py
+++ b/numpy/lib/tests/test_ufunclike.py
@@ -4,12 +4,11 @@ import numpy as np
 import numpy.core as nx
 import numpy.lib.ufunclike as ufl
 from numpy.testing import (
-    run_module_suite, TestCase, assert_, assert_equal, assert_array_equal,
-    assert_warns
+    run_module_suite, assert_, assert_equal, assert_array_equal, assert_warns
     )
 
 
-class TestUfunclike(TestCase):
+class TestUfunclike(object):
 
     def test_isposinf(self):
         a = nx.array([nx.inf, -nx.inf, nx.nan, 0.0, 3.0, -3.0])