MAINT: Fix problems noted by pyflakes in numpy/lib/tests.

15 files changed, 426 insertions, 378 deletions

diff --git a/numpy/lib/tests/test__datasource.py b/numpy/lib/tests/test__datasource.py
index f61d3086b..89198f2bf 100644
--- a/numpy/lib/tests/test__datasource.py
+++ b/numpy/lib/tests/test__datasource.py
@@ -2,11 +2,14 @@ from __future__ import division, absolute_import, print_function
 
 import os
 import sys
-import numpy.lib._datasource as datasource
 from tempfile import mkdtemp, mkstemp, NamedTemporaryFile
 from shutil import rmtree
+
 from numpy.compat import asbytes
-from numpy.testing import *
+from numpy.testing import (
+    run_module_suite, TestCase, assert_
+    )
+import numpy.lib._datasource as datasource
 
 if sys.version_info[0] >= 3:
     import urllib.request as urllib_request
@@ -213,7 +216,7 @@ class TestDataSourceAbspath(TestCase):
         tmpfile = valid_textfile(self.tmpdir)
         tmpfilename = os.path.split(tmpfile)[-1]
         # Test with filename only
-        self.assertEqual(tmpfile, self.ds.abspath(os.path.split(tmpfile)[-1]))
+        self.assertEqual(tmpfile, self.ds.abspath(tmpfilename))
         # Test filename with complete path
         self.assertEqual(tmpfile, self.ds.abspath(tmpfile))
 
diff --git a/numpy/lib/tests/test__iotools.py b/numpy/lib/tests/test__iotools.py
index d564121d1..e19cf488f 100644
--- a/numpy/lib/tests/test__iotools.py
+++ b/numpy/lib/tests/test__iotools.py
@@ -5,12 +5,14 @@ import time
 from datetime import date
 
 import numpy as np
+from numpy.compat import asbytes, asbytes_nested
+from numpy.testing import (
+    run_module_suite, TestCase, assert_, assert_equal
+    )
 from numpy.lib._iotools import (
     LineSplitter, NameValidator, StringConverter,
     has_nested_fields, easy_dtype, flatten_dtype
     )
-from numpy.testing import *
-from numpy.compat import asbytes, asbytes_nested
 
 
 class TestLineSplitter(TestCase):
diff --git a/numpy/lib/tests/test_arraysetops.py b/numpy/lib/tests/test_arraysetops.py
index 271943abc..d2638e4b9 100644
--- a/numpy/lib/tests/test_arraysetops.py
+++ b/numpy/lib/tests/test_arraysetops.py
@@ -3,11 +3,13 @@
 """
 from __future__ import division, absolute_import, print_function
 
-from numpy.testing import *
 import numpy as np
-from numpy.lib.arraysetops import *
-
-import warnings
+from numpy.testing import (
+    run_module_suite, TestCase, assert_array_equal
+    )
+from numpy.lib.arraysetops import (
+    ediff1d, intersect1d, setxor1d, union1d, setdiff1d, unique, in1d
+    )
 
 
 class TestSetOps(TestCase):
diff --git a/numpy/lib/tests/test_financial.py b/numpy/lib/tests/test_financial.py
index 41a060a3f..f02cfb36a 100644
--- a/numpy/lib/tests/test_financial.py
+++ b/numpy/lib/tests/test_financial.py
@@ -1,7 +1,9 @@
 from __future__ import division, absolute_import, print_function
 
-from numpy.testing import *
 import numpy as np
+from numpy.testing import (
+    run_module_suite, TestCase, assert_, assert_almost_equal
+    )
 
 
 class TestFinancial(TestCase):
diff --git a/numpy/lib/tests/test_format.py b/numpy/lib/tests/test_format.py
index 1034b5125..eea6f1e5c 100644
--- a/numpy/lib/tests/test_format.py
+++ b/numpy/lib/tests/test_format.py
@@ -284,9 +284,12 @@ import warnings
 from io import BytesIO
 
 import numpy as np
-from numpy.testing import *
-from numpy.lib import format
 from numpy.compat import asbytes, asbytes_nested
+from numpy.testing import (
+    run_module_suite, assert_, assert_array_equal, assert_raises, raises,
+    dec
+    )
+from numpy.lib import format
 
 
 tempdir = None
@@ -445,7 +448,7 @@ def roundtrip_truncated(arr):
     return arr2
 
 
-def assert_equal(o1, o2):
+def assert_equal_(o1, o2):
     assert_(o1 == o2)
 
 
@@ -477,7 +480,7 @@ def test_long_str():
 
 @dec.slow
 def test_memmap_roundtrip():
-    # XXX: test crashes nose on windows. Fix this
+    # Fixme: test crashes nose on windows.
     if not (sys.platform == 'win32' or sys.platform == 'cygwin'):
         for arr in basic_arrays + record_arrays:
             if arr.dtype.hasobject:
@@ -506,11 +509,10 @@ def test_memmap_roundtrip():
             fp = open(mfn, 'rb')
             memmap_bytes = fp.read()
             fp.close()
-            yield assert_equal, normal_bytes, memmap_bytes
+            yield assert_equal_, normal_bytes, memmap_bytes
 
             # Check that reading the file using memmap works.
             ma = format.open_memmap(nfn, mode='r')
-            #yield assert_array_equal, ma, arr
             del ma
 
 
diff --git a/numpy/lib/tests/test_index_tricks.py b/numpy/lib/tests/test_index_tricks.py
index 6b01464a7..375fd9517 100644
--- a/numpy/lib/tests/test_index_tricks.py
+++ b/numpy/lib/tests/test_index_tricks.py
@@ -1,10 +1,14 @@
 from __future__ import division, absolute_import, print_function
 
-from numpy.testing import *
 import numpy as np
-from numpy import (array, ones, r_, mgrid, unravel_index, zeros, where,
-                   ndenumerate, fill_diagonal, diag_indices,
-                   diag_indices_from, s_, index_exp, ndindex)
+from numpy.testing import (
+    run_module_suite, TestCase, assert_, assert_equal, assert_array_equal,
+    assert_almost_equal, assert_array_almost_equal, assert_raises
+    )
+from numpy.lib.index_tricks import (
+    mgrid, ndenumerate, fill_diagonal, diag_indices, diag_indices_from,
+    index_exp, ndindex, r_, s_
+    )
 
 
 class TestRavelUnravelIndex(TestCase):
@@ -106,18 +110,20 @@ class TestGrid(TestCase):
         d = mgrid[-1:1:0.1, -2:2:0.2]
         assert_(c.shape == (2, 10, 10))
         assert_(d.shape == (2, 20, 20))
-        assert_array_equal(c[0][0, :], -ones(10, 'd'))
-        assert_array_equal(c[1][:, 0], -2*ones(10, 'd'))
-        assert_array_almost_equal(c[0][-1, :], ones(10, 'd'), 11)
-        assert_array_almost_equal(c[1][:, -1], 2*ones(10, 'd'), 11)
-        assert_array_almost_equal(d[0, 1, :]-d[0, 0, :], 0.1*ones(20, 'd'), 11)
-        assert_array_almost_equal(d[1, :, 1]-d[1, :, 0], 0.2*ones(20, 'd'), 11)
+        assert_array_equal(c[0][0, :], -np.ones(10, 'd'))
+        assert_array_equal(c[1][:, 0], -2*np.ones(10, 'd'))
+        assert_array_almost_equal(c[0][-1, :], np.ones(10, 'd'), 11)
+        assert_array_almost_equal(c[1][:, -1], 2*np.ones(10, 'd'), 11)
+        assert_array_almost_equal(d[0, 1, :] - d[0, 0, :],
+                                  0.1*np.ones(20, 'd'), 11)
+        assert_array_almost_equal(d[1, :, 1] - d[1, :, 0],
+                                  0.2*np.ones(20, 'd'), 11)
 
 
 class TestConcatenator(TestCase):
     def test_1d(self):
-        assert_array_equal(r_[1, 2, 3, 4, 5, 6], array([1, 2, 3, 4, 5, 6]))
-        b = ones(5)
+        assert_array_equal(r_[1, 2, 3, 4, 5, 6], np.array([1, 2, 3, 4, 5, 6]))
+        b = np.ones(5)
         c = r_[b, 0, 0, b]
         assert_array_equal(c, [1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1])
 
@@ -126,12 +132,12 @@ class TestConcatenator(TestCase):
         assert_(g.dtype == 'f8')
 
     def test_more_mixed_type(self):
-        g = r_[-10.1, array([1]), array([2, 3, 4]), 10.0]
+        g = r_[-10.1, np.array([1]), np.array([2, 3, 4]), 10.0]
         assert_(g.dtype == 'f8')
 
     def test_2d(self):
-        b = rand(5, 5)
-        c = rand(5, 5)
+        b = np.random.rand(5, 5)
+        c = np.random.rand(5, 5)
         d = r_['1', b, c]  # append columns
         assert_(d.shape == (5, 10))
         assert_array_equal(d[:, :5], b)
@@ -144,7 +150,7 @@ class TestConcatenator(TestCase):
 
 class TestNdenumerate(TestCase):
     def test_basic(self):
-        a = array([[1, 2], [3, 4]])
+        a = np.array([[1, 2], [3, 4]])
         assert_equal(list(ndenumerate(a)),
                      [((0, 0), 1), ((0, 1), 2), ((1, 0), 3), ((1, 1), 4)])
 
@@ -169,18 +175,18 @@ def test_c_():
 
 
 def test_fill_diagonal():
-    a = zeros((3, 3), int)
+    a = np.zeros((3, 3), int)
     fill_diagonal(a, 5)
     yield (assert_array_equal, a,
-           array([[5, 0, 0],
+           np.array([[5, 0, 0],
                   [0, 5, 0],
                   [0, 0, 5]]))
 
     #Test tall matrix
-    a = zeros((10, 3), int)
+    a = np.zeros((10, 3), int)
     fill_diagonal(a, 5)
     yield (assert_array_equal, a,
-           array([[5, 0, 0],
+           np.array([[5, 0, 0],
                   [0, 5, 0],
                   [0, 0, 5],
                   [0, 0, 0],
@@ -192,10 +198,10 @@ def test_fill_diagonal():
                   [0, 0, 0]]))
 
     #Test tall matrix wrap
-    a = zeros((10, 3), int)
+    a = np.zeros((10, 3), int)
     fill_diagonal(a, 5, True)
     yield (assert_array_equal, a,
-           array([[5, 0, 0],
+           np.array([[5, 0, 0],
                   [0, 5, 0],
                   [0, 0, 5],
                   [0, 0, 0],
@@ -207,29 +213,29 @@ def test_fill_diagonal():
                   [0, 5, 0]]))
 
     #Test wide matrix
-    a = zeros((3, 10), int)
+    a = np.zeros((3, 10), int)
     fill_diagonal(a, 5)
     yield (assert_array_equal, a,
-           array([[5, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+           np.array([[5, 0, 0, 0, 0, 0, 0, 0, 0, 0],
                   [0, 5, 0, 0, 0, 0, 0, 0, 0, 0],
                   [0, 0, 5, 0, 0, 0, 0, 0, 0, 0]]))
 
     # The same function can operate on a 4-d array:
-    a = zeros((3, 3, 3, 3), int)
+    a = np.zeros((3, 3, 3, 3), int)
     fill_diagonal(a, 4)
-    i = array([0, 1, 2])
-    yield (assert_equal, where(a != 0), (i, i, i, i))
+    i = np.array([0, 1, 2])
+    yield (assert_equal, np.where(a != 0), (i, i, i, i))
 
 
 def test_diag_indices():
     di = diag_indices(4)
-    a = array([[1,  2,  3,  4],
+    a = np.array([[1,  2,  3,  4],
                [5,  6,  7,  8],
                [9,  10, 11, 12],
                [13, 14, 15, 16]])
     a[di] = 100
     yield (assert_array_equal, a,
-           array([[100, 2,   3,   4],
+           np.array([[100, 2,   3,   4],
                   [5,   100, 7,   8],
                   [9,   10,  100, 12],
                   [13,  14,  15,  100]]))
@@ -238,10 +244,10 @@ def test_diag_indices():
     d3 = diag_indices(2, 3)
 
     # And use it to set the diagonal of a zeros array to 1:
-    a = zeros((2, 2, 2), int)
+    a = np.zeros((2, 2, 2), int)
     a[d3] = 1
     yield (assert_array_equal, a,
-           array([[[1, 0],
+           np.array([[[1, 0],
                    [0, 0]],
 
                   [[0, 0],
@@ -256,26 +262,26 @@ def test_diag_indices_from():
 
 
 def test_ndindex():
-    x = list(np.ndindex(1, 2, 3))
-    expected = [ix for ix, e in np.ndenumerate(np.zeros((1, 2, 3)))]
+    x = list(ndindex(1, 2, 3))
+    expected = [ix for ix, e in ndenumerate(np.zeros((1, 2, 3)))]
     assert_array_equal(x, expected)
 
-    x = list(np.ndindex((1, 2, 3)))
+    x = list(ndindex((1, 2, 3)))
     assert_array_equal(x, expected)
 
     # Test use of scalars and tuples
-    x = list(np.ndindex((3,)))
-    assert_array_equal(x, list(np.ndindex(3)))
+    x = list(ndindex((3,)))
+    assert_array_equal(x, list(ndindex(3)))
 
     # Make sure size argument is optional
-    x = list(np.ndindex())
+    x = list(ndindex())
     assert_equal(x, [()])
 
-    x = list(np.ndindex(()))
+    x = list(ndindex(()))
     assert_equal(x, [()])
 
     # Make sure 0-sized ndindex works correctly
-    x = list(np.ndindex(*[0]))
+    x = list(ndindex(*[0]))
     assert_equal(x, [])
 
 
diff --git a/numpy/lib/tests/test_polynomial.py b/numpy/lib/tests/test_polynomial.py
index 4adc6aed8..12d800e2e 100644
--- a/numpy/lib/tests/test_polynomial.py
+++ b/numpy/lib/tests/test_polynomial.py
@@ -78,8 +78,11 @@ poly1d([ 2.])
 (poly1d([ 1., -1.]), poly1d([ 0.]))
 
 '''
-from numpy.testing import *
 import numpy as np
+from numpy.testing import (
+    run_module_suite, TestCase, assert_, assert_equal, assert_array_equal,
+    assert_almost_equal, rundocs
+    )
 
 
 class TestDocs(TestCase):
diff --git a/numpy/lib/tests/test_recfunctions.py b/numpy/lib/tests/test_recfunctions.py
index d0eda50ce..51a2077eb 100644
--- a/numpy/lib/tests/test_recfunctions.py
+++ b/numpy/lib/tests/test_recfunctions.py
@@ -1,14 +1,15 @@
 from __future__ import division, absolute_import, print_function
 
-import sys
-
 import numpy as np
 import numpy.ma as ma
-from numpy.ma.testutils import *
-
 from numpy.ma.mrecords import MaskedRecords
-
-from numpy.lib.recfunctions import *
+from numpy.ma.testutils import (
+    run_module_suite, TestCase, assert_, assert_equal
+    )
+from numpy.lib.recfunctions import (
+    drop_fields, rename_fields, get_fieldstructure, recursive_fill_fields,
+    find_duplicates, merge_arrays, append_fields, stack_arrays, join_by
+    )
 get_names = np.lib.recfunctions.get_names
 get_names_flat = np.lib.recfunctions.get_names_flat
 zip_descr = np.lib.recfunctions.zip_descr
@@ -293,11 +294,12 @@ class TestMergeArrays(TestCase):
         assert_equal(test, control)
 
         test = merge_arrays((x, w), flatten=False)
-        controldtype = dtype = [('f0', int),
+        controldtype = [('f0', int),
                                 ('f1', [('a', int),
                                         ('b', [('ba', float), ('bb', int)])])]
         control = np.array([(1., (1, (2, 3.0))), (2, (4, (5, 6.0)))],
                            dtype=controldtype)
+        assert_equal(test, control)
 
     def test_wmasked_arrays(self):
         # Test merge_arrays masked arrays
@@ -324,9 +326,17 @@ class TestMergeArrays(TestCase):
     def test_w_shorter_flex(self):
         # Test merge_arrays w/ a shorter flexndarray.
         z = self.data[-1]
-        test = merge_arrays((z, np.array([10, 20, 30]).view([('C', int)])))
-        control = np.array([('A', 1., 10), ('B', 2., 20), ('-1', -1, 20)],
-                           dtype=[('A', '|S3'), ('B', float), ('C', int)])
+
+        # Fixme, this test looks incomplete and broken
+        #test = merge_arrays((z, np.array([10, 20, 30]).view([('C', int)])))
+        #control = np.array([('A', 1., 10), ('B', 2., 20), ('-1', -1, 20)],
+        #                   dtype=[('A', '|S3'), ('B', float), ('C', int)])
+        #assert_equal(test, control)
+
+        # Hack to avoid pyflakes warnings about unused variables
+        merge_arrays((z, np.array([10, 20, 30]).view([('C', int)])))
+        np.array([('A', 1., 10), ('B', 2., 20), ('-1', -1, 20)],
+                 dtype=[('A', '|S3'), ('B', float), ('C', int)])
 
     def test_singlerecord(self):
         (_, x, y, z) = self.data
@@ -562,12 +572,22 @@ class TestJoinBy(TestCase):
     def test_join(self):
         a, b = self.a, self.b
 
-        test = join_by(('a', 'b'), a, b)
-        control = np.array([(5, 55, 105, 100), (6, 56, 106, 101),
-                            (7, 57, 107, 102), (8, 58, 108, 103),
-                            (9, 59, 109, 104)],
-                           dtype=[('a', int), ('b', int),
-                                  ('c', int), ('d', int)])
+        # Fixme, this test is broken
+        #test = join_by(('a', 'b'), a, b)
+        #control = np.array([(5, 55, 105, 100), (6, 56, 106, 101),
+        #                    (7, 57, 107, 102), (8, 58, 108, 103),
+        #                    (9, 59, 109, 104)],
+        #                   dtype=[('a', int), ('b', int),
+        #                          ('c', int), ('d', int)])
+        #assert_equal(test, control)
+
+        # Hack to avoid pyflakes unused variable warnings
+        join_by(('a', 'b'), a, b)
+        np.array([(5, 55, 105, 100), (6, 56, 106, 101),
+                  (7, 57, 107, 102), (8, 58, 108, 103),
+                  (9, 59, 109, 104)],
+                  dtype=[('a', int), ('b', int),
+                         ('c', int), ('d', int)])
 
     def test_outer_join(self):
         a, b = self.a, self.b
@@ -612,6 +632,7 @@ class TestJoinBy(TestCase):
                                  (0, 0, 0, 1), (0, 0, 0, 1),
                                  (0, 0, 0, 1), (0, 0, 0, 1)],
                            dtype=[('a', int), ('b', int), ('c', int), ('d', int)])
+        assert_equal(test, control)
 
 
 class TestJoinBy2(TestCase):
diff --git a/numpy/lib/tests/test_regression.py b/numpy/lib/tests/test_regression.py
index eb991eeb0..00fa3f195 100644
--- a/numpy/lib/tests/test_regression.py
+++ b/numpy/lib/tests/test_regression.py
@@ -4,7 +4,10 @@ import os
 import sys
 
 import numpy as np
-from numpy.testing import *
+from numpy.testing import (
+    run_module_suite, TestCase, assert_, assert_equal, assert_array_equal,
+    assert_array_almost_equal, assert_raises
+    )
 from numpy.testing.utils import _assert_valid_refcount
 from numpy.compat import unicode
 
@@ -13,12 +16,12 @@ rlevel = 1
 
 class TestRegression(TestCase):
     def test_poly1d(self, level=rlevel):
-        """Ticket #28"""
+        # Ticket #28
         assert_equal(np.poly1d([1]) - np.poly1d([1, 0]),
                      np.poly1d([-1, 1]))
 
     def test_cov_parameters(self, level=rlevel):
-        """Ticket #91"""
+        # Ticket #91
         x = np.random.random((3, 3))
         y = x.copy()
         np.cov(x, rowvar=1)
@@ -26,68 +29,68 @@ class TestRegression(TestCase):
         assert_array_equal(x, y)
 
     def test_mem_digitize(self, level=rlevel):
-        """Ticket #95"""
+        # Ticket #95
         for i in range(100):
             np.digitize([1, 2, 3, 4], [1, 3])
             np.digitize([0, 1, 2, 3, 4], [1, 3])
 
     def test_unique_zero_sized(self, level=rlevel):
-        """Ticket #205"""
+        # Ticket #205
         assert_array_equal([], np.unique(np.array([])))
 
     def test_mem_vectorise(self, level=rlevel):
-        """Ticket #325"""
+        # Ticket #325
         vt = np.vectorize(lambda *args: args)
         vt(np.zeros((1, 2, 1)), np.zeros((2, 1, 1)), np.zeros((1, 1, 2)))
         vt(np.zeros((1, 2, 1)), np.zeros((2, 1, 1)), np.zeros((1,
            1, 2)), np.zeros((2, 2)))
 
     def test_mgrid_single_element(self, level=rlevel):
-        """Ticket #339"""
+        # Ticket #339
         assert_array_equal(np.mgrid[0:0:1j], [0])
         assert_array_equal(np.mgrid[0:0], [])
 
     def test_refcount_vectorize(self, level=rlevel):
-        """Ticket #378"""
+        # Ticket #378
         def p(x, y):
             return 123
         v = np.vectorize(p)
         _assert_valid_refcount(v)
 
     def test_poly1d_nan_roots(self, level=rlevel):
-        """Ticket #396"""
+        # Ticket #396
         p = np.poly1d([np.nan, np.nan, 1], r=0)
         self.assertRaises(np.linalg.LinAlgError, getattr, p, "r")
 
     def test_mem_polymul(self, level=rlevel):
-        """Ticket #448"""
+        # Ticket #448
         np.polymul([], [1.])
 
     def test_mem_string_concat(self, level=rlevel):
-        """Ticket #469"""
+        # Ticket #469
         x = np.array([])
         np.append(x, 'asdasd\tasdasd')
 
     def test_poly_div(self, level=rlevel):
-        """Ticket #553"""
+        # Ticket #553
         u = np.poly1d([1, 2, 3])
         v = np.poly1d([1, 2, 3, 4, 5])
         q, r = np.polydiv(u, v)
         assert_equal(q*v + r, u)
 
     def test_poly_eq(self, level=rlevel):
-        """Ticket #554"""
+        # Ticket #554
         x = np.poly1d([1, 2, 3])
         y = np.poly1d([3, 4])
         assert_(x != y)
         assert_(x == x)
 
     def test_mem_insert(self, level=rlevel):
-        """Ticket #572"""
+        # Ticket #572
         np.lib.place(1, 1, 1)
 
     def test_polyfit_build(self):
-        """Ticket #628"""
+        # Ticket #628
         ref = [-1.06123820e-06, 5.70886914e-04, -1.13822012e-01,
                9.95368241e+00, -3.14526520e+02]
         x = [90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103,
@@ -108,7 +111,7 @@ class TestRegression(TestCase):
         assert_array_almost_equal(ref, tested)
 
     def test_polydiv_type(self):
-        """Make polydiv work for complex types"""
+        # Make polydiv work for complex types
         msg = "Wrong type, should be complex"
         x = np.ones(3, dtype=np.complex)
         q, r = np.polydiv(x, x)
@@ -119,11 +122,11 @@ class TestRegression(TestCase):
         assert_(q.dtype == np.float, msg)
 
     def test_histogramdd_too_many_bins(self):
-        """Ticket 928."""
+        # Ticket 928.
         assert_raises(ValueError, np.histogramdd, np.ones((1, 10)), bins=2**10)
 
     def test_polyint_type(self):
-        """Ticket #944"""
+        # Ticket #944
         msg = "Wrong type, should be complex"
         x = np.ones(3, dtype=np.complex)
         assert_(np.polyint(x).dtype == np.complex, msg)
@@ -132,12 +135,12 @@ class TestRegression(TestCase):
         assert_(np.polyint(x).dtype == np.float, msg)
 
     def test_ndenumerate_crash(self):
-        """Ticket 1140"""
+        # Ticket 1140
         # Shouldn't crash:
         list(np.ndenumerate(np.array([[]])))
 
     def test_asfarray_none(self, level=rlevel):
-        """Test for changeset r5065"""
+        # Test for changeset r5065
         assert_array_equal(np.array([np.nan]), np.asfarray([None]))
 
     def test_large_fancy_indexing(self, level=rlevel):
@@ -155,7 +158,8 @@ class TestRegression(TestCase):
             n = 3
             a = np.ones((n,)*5)
             i = np.random.randint(0, n, size=thesize)
-            g = a[np.ix_(i, i, i, i, i)]
+            a[np.ix_(i, i, i, i, i)]
+
         self.assertRaises(ValueError, dp)
         self.assertRaises(ValueError, dp2)
 
@@ -165,7 +169,7 @@ class TestRegression(TestCase):
         assert_(np.r_[x, x].dtype == dt)
 
     def test_who_with_0dim_array(self, level=rlevel):
-        """ticket #1243"""
+        # ticket #1243
         import os
         import sys
 
@@ -173,7 +177,7 @@ class TestRegression(TestCase):
         sys.stdout = open(os.devnull, 'w')
         try:
             try:
-                tmp = np.who({'foo': np.array(1)})
+                np.who({'foo': np.array(1)})
             except:
                 raise AssertionError("ticket #1243")
         finally:
@@ -183,29 +187,29 @@ class TestRegression(TestCase):
     def test_include_dirs(self):
         # As a sanity check, just test that get_include
         # includes something reasonable.  Somewhat
-        # related to ticket #1405."""
+        # related to ticket #1405.
         include_dirs = [np.get_include()]
         for path in include_dirs:
             assert_(isinstance(path, (str, unicode)))
             assert_(path != '')
 
     def test_polyder_return_type(self):
-        """Ticket #1249"""
+        # Ticket #1249
         assert_(isinstance(np.polyder(np.poly1d([1]), 0), np.poly1d))
         assert_(isinstance(np.polyder([1], 0), np.ndarray))
         assert_(isinstance(np.polyder(np.poly1d([1]), 1), np.poly1d))
         assert_(isinstance(np.polyder([1], 1), np.ndarray))
 
     def test_append_fields_dtype_list(self):
-        """Ticket #1676"""
+        # Ticket #1676
         from numpy.lib.recfunctions import append_fields
-        F = False
+
         base = np.array([1, 2, 3], dtype=np.int32)
-        data = np.eye(3).astype(np.int32)
         names = ['a', 'b', 'c']
+        data = np.eye(3).astype(np.int32)
         dlist = [np.float64, np.int32, np.int32]
         try:
-            a = append_fields(base, names, data, dlist)
+            append_fields(base, names, data, dlist)
         except:
             raise AssertionError()
 
diff --git a/numpy/lib/tests/test_shape_base.py b/numpy/lib/tests/test_shape_base.py
index d6d01ba99..23f3edfbe 100644
--- a/numpy/lib/tests/test_shape_base.py
+++ b/numpy/lib/tests/test_shape_base.py
@@ -1,214 +1,216 @@
 from __future__ import division, absolute_import, print_function
 
-from numpy.testing import *
-from numpy.lib import *
-from numpy.core import *
-from numpy import matrix, asmatrix
+import numpy as np
+from numpy.lib.shape_base import (
+    apply_along_axis, apply_over_axes, array_split, split, hsplit, dsplit,
+    vsplit, dstack, kron, tile
+    )
+from numpy.testing import (
+    run_module_suite, TestCase, assert_, assert_equal, assert_array_equal,
+    assert_raises, assert_warns
+    )
 
 
 class TestApplyAlongAxis(TestCase):
     def test_simple(self):
-        a = ones((20, 10), 'd')
+        a = np.ones((20, 10), 'd')
         assert_array_equal(
-            apply_along_axis(len, 0, a), len(a)*ones(shape(a)[1]))
+            apply_along_axis(len, 0, a), len(a)*np.ones(a.shape[1]))
 
     def test_simple101(self, level=11):
-        a = ones((10, 101), 'd')
+        a = np.ones((10, 101), 'd')
         assert_array_equal(
-            apply_along_axis(len, 0, a), len(a)*ones(shape(a)[1]))
+            apply_along_axis(len, 0, a), len(a)*np.ones(a.shape[1]))
 
     def test_3d(self):
-        a = arange(27).reshape((3, 3, 3))
-        assert_array_equal(apply_along_axis(sum, 0, a),
+        a = np.arange(27).reshape((3, 3, 3))
+        assert_array_equal(apply_along_axis(np.sum, 0, a),
                            [[27, 30, 33], [36, 39, 42], [45, 48, 51]])
 
 
 class TestApplyOverAxes(TestCase):
     def test_simple(self):
-        a = arange(24).reshape(2, 3, 4)
-        aoa_a = apply_over_axes(sum, a, [0, 2])
-        assert_array_equal(aoa_a, array([[[60], [92], [124]]]))
+        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 TestArraySplit(TestCase):
     def test_integer_0_split(self):
-        a = arange(10)
-        try:
-            res = array_split(a, 0)
-            assert_(0)  # it should have thrown a value error
-        except ValueError:
-            pass
+        a = np.arange(10)
+        assert_raises(ValueError, array_split, a, 0)
 
     def test_integer_split(self):
-        a = arange(10)
+        a = np.arange(10)
         res = array_split(a, 1)
-        desired = [arange(10)]
+        desired = [np.arange(10)]
         compare_results(res, desired)
 
         res = array_split(a, 2)
-        desired = [arange(5), arange(5, 10)]
+        desired = [np.arange(5), np.arange(5, 10)]
         compare_results(res, desired)
 
         res = array_split(a, 3)
-        desired = [arange(4), arange(4, 7), arange(7, 10)]
+        desired = [np.arange(4), np.arange(4, 7), np.arange(7, 10)]
         compare_results(res, desired)
 
         res = array_split(a, 4)
-        desired = [arange(3), arange(3, 6), arange(6, 8), arange(8, 10)]
+        desired = [np.arange(3), np.arange(3, 6), np.arange(6, 8),
+                   np.arange(8, 10)]
         compare_results(res, desired)
 
         res = array_split(a, 5)
-        desired = [arange(
-            2), arange(2, 4), arange(4, 6), arange(6, 8), arange(8, 10)]
+        desired = [np.arange(2), np.arange(2, 4), np.arange(4, 6),
+                   np.arange(6, 8), np.arange(8, 10)]
         compare_results(res, desired)
 
         res = array_split(a, 6)
-        desired = [arange(
-            2), arange(2, 4), arange(4, 6), arange(6, 8), arange(8, 9),
-            arange(9, 10)]
+        desired = [np.arange(2), np.arange(2, 4), np.arange(4, 6),
+                   np.arange(6, 8), np.arange(8, 9), np.arange(9, 10)]
         compare_results(res, desired)
 
         res = array_split(a, 7)
-        desired = [arange(
-            2), arange(2, 4), arange(4, 6), arange(6, 7), arange(7, 8),
-            arange(8, 9), arange(9, 10)]
+        desired = [np.arange(2), np.arange(2, 4), np.arange(4, 6),
+                   np.arange(6, 7), np.arange(7, 8), np.arange(8, 9),
+                   np.arange(9, 10)]
         compare_results(res, desired)
 
         res = array_split(a, 8)
-        desired = [arange(
-            2), arange(2, 4), arange(4, 5), arange(5, 6), arange(6, 7),
-            arange(7, 8), arange(8, 9), arange(9, 10)]
+        desired = [np.arange(2), np.arange(2, 4), np.arange(4, 5),
+                   np.arange(5, 6), np.arange(6, 7), np.arange(7, 8),
+                   np.arange(8, 9), np.arange(9, 10)]
         compare_results(res, desired)
 
         res = array_split(a, 9)
-        desired = [arange(
-            2), arange(2, 3), arange(3, 4), arange(4, 5), arange(5, 6),
-            arange(6, 7), arange(7, 8), arange(8, 9), arange(9, 10)]
+        desired = [np.arange(2), np.arange(2, 3), np.arange(3, 4),
+                   np.arange(4, 5), np.arange(5, 6), np.arange(6, 7),
+                   np.arange(7, 8), np.arange(8, 9), np.arange(9, 10)]
         compare_results(res, desired)
 
         res = array_split(a, 10)
-        desired = [arange(1), arange(1, 2), arange(2, 3), arange(3, 4),
-                   arange(4, 5), arange(5, 6), arange(6, 7), arange(7, 8),
-                   arange(8, 9), arange(9, 10)]
+        desired = [np.arange(1), np.arange(1, 2), np.arange(2, 3),
+                   np.arange(3, 4), np.arange(4, 5), np.arange(5, 6),
+                   np.arange(6, 7), np.arange(7, 8), np.arange(8, 9),
+                   np.arange(9, 10)]
         compare_results(res, desired)
 
         res = array_split(a, 11)
-        desired = [arange(1), arange(1, 2), arange(2, 3), arange(3, 4),
-                   arange(4, 5), arange(5, 6), arange(6, 7), arange(7, 8),
-                   arange(8, 9), arange(9, 10), array([])]
+        desired = [np.arange(1), np.arange(1, 2), np.arange(2, 3),
+                   np.arange(3, 4), np.arange(4, 5), np.arange(5, 6),
+                   np.arange(6, 7), np.arange(7, 8), np.arange(8, 9),
+                   np.arange(9, 10), np.array([])]
         compare_results(res, desired)
 
     def test_integer_split_2D_rows(self):
-        a = array([arange(10), arange(10)])
+        a = np.array([np.arange(10), np.arange(10)])
         res = assert_warns(FutureWarning, array_split, a, 3, axis=0)
 
         # After removing the FutureWarning, the last should be zeros((0, 10))
-        desired = [array([arange(10)]), array([arange(10)]), array([])]
+        desired = [np.array([np.arange(10)]), np.array([np.arange(10)]),
+                   np.array([])]
         compare_results(res, desired)
         assert_(a.dtype.type is res[-1].dtype.type)
 
     def test_integer_split_2D_cols(self):
-        a = array([arange(10), arange(10)])
+        a = np.array([np.arange(10), np.arange(10)])
         res = array_split(a, 3, axis=-1)
-        desired = [array([arange(4), arange(4)]),
-                   array([arange(4, 7), arange(4, 7)]),
-                   array([arange(7, 10), arange(7, 10)])]
+        desired = [np.array([np.arange(4), np.arange(4)]),
+                   np.array([np.arange(4, 7), np.arange(4, 7)]),
+                   np.array([np.arange(7, 10), np.arange(7, 10)])]
         compare_results(res, desired)
 
     def test_integer_split_2D_default(self):
         """ This will fail if we change default axis
         """
-        a = array([arange(10), arange(10)])
+        a = np.array([np.arange(10), np.arange(10)])
         res = assert_warns(FutureWarning, array_split, a, 3)
 
         # After removing the FutureWarning, the last should be zeros((0, 10))
-        desired = [array([arange(10)]), array([arange(10)]), array([])]
+        desired = [np.array([np.arange(10)]), np.array([np.arange(10)]),
+                   np.array([])]
         compare_results(res, desired)
         assert_(a.dtype.type is res[-1].dtype.type)
-    #perhaps should check higher dimensions
+        # perhaps should check higher dimensions
 
     def test_index_split_simple(self):
-        a = arange(10)
+        a = np.arange(10)
         indices = [1, 5, 7]
         res = array_split(a, indices, axis=-1)
-        desired = [arange(0, 1), arange(1, 5), arange(5, 7), arange(7, 10)]
+        desired = [np.arange(0, 1), np.arange(1, 5), np.arange(5, 7),
+                   np.arange(7, 10)]
         compare_results(res, desired)
 
     def test_index_split_low_bound(self):
-        a = arange(10)
+        a = np.arange(10)
         indices = [0, 5, 7]
         res = array_split(a, indices, axis=-1)
-        desired = [array([]), arange(0, 5), arange(5, 7), arange(7, 10)]
+        desired = [np.array([]), np.arange(0, 5), np.arange(5, 7),
+                   np.arange(7, 10)]
         compare_results(res, desired)
 
     def test_index_split_high_bound(self):
-        a = arange(10)
+        a = np.arange(10)
         indices = [0, 5, 7, 10, 12]
         res = array_split(a, indices, axis=-1)
-        desired = [array([]), arange(0, 5), arange(5, 7), arange(7, 10),
-                   array([]), array([])]
+        desired = [np.array([]), np.arange(0, 5), np.arange(5, 7),
+                   np.arange(7, 10), np.array([]), np.array([])]
         compare_results(res, desired)
 
 
 class TestSplit(TestCase):
-    """* This function is essentially the same as array_split,
-         except that it test if splitting will result in an
-         equal split.  Only test for this case.
-    *"""
+    # 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.
+
     def test_equal_split(self):
-        a = arange(10)
+        a = np.arange(10)
         res = split(a, 2)
-        desired = [arange(5), arange(5, 10)]
+        desired = [np.arange(5), np.arange(5, 10)]
         compare_results(res, desired)
 
     def test_unequal_split(self):
-        a = arange(10)
-        try:
-            res = split(a, 3)
-            assert_(0)  # should raise an error
-        except ValueError:
-            pass
+        a = np.arange(10)
+        assert_raises(ValueError, split, a, 3)
 
 
 class TestDstack(TestCase):
     def test_0D_array(self):
-        a = array(1)
-        b = array(2)
+        a = np.array(1)
+        b = np.array(2)
         res = dstack([a, b])
-        desired = array([[[1, 2]]])
+        desired = np.array([[[1, 2]]])
         assert_array_equal(res, desired)
 
     def test_1D_array(self):
-        a = array([1])
-        b = array([2])
+        a = np.array([1])
+        b = np.array([2])
         res = dstack([a, b])
-        desired = array([[[1, 2]]])
+        desired = np.array([[[1, 2]]])
         assert_array_equal(res, desired)
 
     def test_2D_array(self):
-        a = array([[1], [2]])
-        b = array([[1], [2]])
+        a = np.array([[1], [2]])
+        b = np.array([[1], [2]])
         res = dstack([a, b])
-        desired = array([[[1, 1]], [[2, 2, ]]])
+        desired = np.array([[[1, 1]], [[2, 2, ]]])
         assert_array_equal(res, desired)
 
     def test_2D_array2(self):
-        a = array([1, 2])
-        b = array([1, 2])
+        a = np.array([1, 2])
+        b = np.array([1, 2])
         res = dstack([a, b])
-        desired = array([[[1, 1], [2, 2]]])
+        desired = np.array([[[1, 1], [2, 2]]])
         assert_array_equal(res, desired)
 
-""" array_split has more comprehensive test of splitting.
-    only do simple test on hsplit, vsplit, and dsplit
-"""
-
 
+# array_split has more comprehensive test of splitting.
+# only do simple test on hsplit, vsplit, and dsplit
 class TestHsplit(TestCase):
-    """ only testing for integer splits.
+    """Only testing for integer splits.
+
     """
     def test_0D_array(self):
-        a = array(1)
+        a = np.array(1)
         try:
             hsplit(a, 2)
             assert_(0)
@@ -216,24 +218,25 @@ class TestHsplit(TestCase):
             pass
 
     def test_1D_array(self):
-        a = array([1, 2, 3, 4])
+        a = np.array([1, 2, 3, 4])
         res = hsplit(a, 2)
-        desired = [array([1, 2]), array([3, 4])]
+        desired = [np.array([1, 2]), np.array([3, 4])]
         compare_results(res, desired)
 
     def test_2D_array(self):
-        a = array([[1, 2, 3, 4],
+        a = np.array([[1, 2, 3, 4],
                   [1, 2, 3, 4]])
         res = hsplit(a, 2)
-        desired = [array([[1, 2], [1, 2]]), array([[3, 4], [3, 4]])]
+        desired = [np.array([[1, 2], [1, 2]]), np.array([[3, 4], [3, 4]])]
         compare_results(res, desired)
 
 
 class TestVsplit(TestCase):
-    """ only testing for integer splits.
+    """Only testing for integer splits.
+
     """
     def test_1D_array(self):
-        a = array([1, 2, 3, 4])
+        a = np.array([1, 2, 3, 4])
         try:
             vsplit(a, 2)
             assert_(0)
@@ -241,18 +244,18 @@ class TestVsplit(TestCase):
             pass
 
     def test_2D_array(self):
-        a = array([[1, 2, 3, 4],
+        a = np.array([[1, 2, 3, 4],
                   [1, 2, 3, 4]])
         res = vsplit(a, 2)
-        desired = [array([[1, 2, 3, 4]]), array([[1, 2, 3, 4]])]
+        desired = [np.array([[1, 2, 3, 4]]), np.array([[1, 2, 3, 4]])]
         compare_results(res, desired)
 
 
 class TestDsplit(TestCase):
-    """ only testing for integer splits.
-    """
+    # Only testing for integer splits.
+
     def test_2D_array(self):
-        a = array([[1, 2, 3, 4],
+        a = np.array([[1, 2, 3, 4],
                   [1, 2, 3, 4]])
         try:
             dsplit(a, 2)
@@ -261,54 +264,57 @@ class TestDsplit(TestCase):
             pass
 
     def test_3D_array(self):
-        a = array([[[1, 2, 3, 4],
+        a = np.array([[[1, 2, 3, 4],
                    [1, 2, 3, 4]],
                   [[1, 2, 3, 4],
                    [1, 2, 3, 4]]])
         res = dsplit(a, 2)
-        desired = [array([[[1, 2], [1, 2]], [[1, 2], [1, 2]]]),
-                   array([[[3, 4], [3, 4]], [[3, 4], [3, 4]]])]
+        desired = [np.array([[[1, 2], [1, 2]], [[1, 2], [1, 2]]]),
+                   np.array([[[3, 4], [3, 4]], [[3, 4], [3, 4]]])]
         compare_results(res, desired)
 
 
 class TestSqueeze(TestCase):
     def test_basic(self):
+        from numpy.random import rand
+
         a = rand(20, 10, 10, 1, 1)
         b = rand(20, 1, 10, 1, 20)
         c = rand(1, 1, 20, 10)
-        assert_array_equal(squeeze(a), reshape(a, (20, 10, 10)))
-        assert_array_equal(squeeze(b), reshape(b, (20, 10, 20)))
-        assert_array_equal(squeeze(c), reshape(c, (20, 10)))
+        assert_array_equal(np.squeeze(a), np.reshape(a, (20, 10, 10)))
+        assert_array_equal(np.squeeze(b), np.reshape(b, (20, 10, 20)))
+        assert_array_equal(np.squeeze(c), np.reshape(c, (20, 10)))
 
         # Squeezing to 0-dim should still give an ndarray
         a = [[[1.5]]]
-        res = squeeze(a)
+        res = np.squeeze(a)
         assert_equal(res, 1.5)
         assert_equal(res.ndim, 0)
-        assert_equal(type(res), ndarray)
+        assert_equal(type(res), np.ndarray)
 
 
 class TestKron(TestCase):
     def test_return_type(self):
-        a = ones([2, 2])
-        m = asmatrix(a)
-        assert_equal(type(kron(a, a)), ndarray)
-        assert_equal(type(kron(m, m)), matrix)
-        assert_equal(type(kron(a, m)), matrix)
-        assert_equal(type(kron(m, a)), matrix)
-
-        class myarray(ndarray):
+        a = np.ones([2, 2])
+        m = np.asmatrix(a)
+        assert_equal(type(kron(a, a)), np.ndarray)
+        assert_equal(type(kron(m, m)), np.matrix)
+        assert_equal(type(kron(a, m)), np.matrix)
+        assert_equal(type(kron(m, a)), np.matrix)
+
+        class myarray(np.ndarray):
             __array_priority__ = 0.0
+
         ma = myarray(a.shape, a.dtype, a.data)
-        assert_equal(type(kron(a, a)), ndarray)
+        assert_equal(type(kron(a, a)), np.ndarray)
         assert_equal(type(kron(ma, ma)), myarray)
-        assert_equal(type(kron(a, ma)), ndarray)
+        assert_equal(type(kron(a, ma)), np.ndarray)
         assert_equal(type(kron(ma, a)), myarray)
 
 
 class TestTile(TestCase):
     def test_basic(self):
-        a = array([0, 1, 2])
+        a = np.array([0, 1, 2])
         b = [[1, 2], [3, 4]]
         assert_equal(tile(a, 2), [0, 1, 2, 0, 1, 2])
         assert_equal(tile(a, (2, 2)), [[0, 1, 2, 0, 1, 2], [0, 1, 2, 0, 1, 2]])
@@ -319,18 +325,19 @@ class TestTile(TestCase):
                                        [1, 2, 1, 2], [3, 4, 3, 4]])
 
     def test_empty(self):
-        a = array([[[]]])
+        a = np.array([[[]]])
         d = tile(a, (3, 2, 5)).shape
         assert_equal(d, (3, 2, 0))
 
     def test_kroncompare(self):
-        import numpy.random as nr
+        from numpy.random import randint
+
         reps = [(2,), (1, 2), (2, 1), (2, 2), (2, 3, 2), (3, 2)]
         shape = [(3,), (2, 3), (3, 4, 3), (3, 2, 3), (4, 3, 2, 4), (2, 2)]
         for s in shape:
-            b = nr.randint(0, 10, size=s)
+            b = randint(0, 10, size=s)
             for r in reps:
-                a = ones(r, b.dtype)
+                a = np.ones(r, b.dtype)
                 large = tile(b, r)
                 klarge = kron(a, b)
                 assert_equal(large, klarge)
@@ -338,17 +345,17 @@ class TestTile(TestCase):
 
 class TestMayShareMemory(TestCase):
     def test_basic(self):
-        d = ones((50, 60))
-        d2 = ones((30, 60, 6))
-        self.assertTrue(may_share_memory(d, d))
-        self.assertTrue(may_share_memory(d, d[::-1]))
-        self.assertTrue(may_share_memory(d, d[::2]))
-        self.assertTrue(may_share_memory(d, d[1:, ::-1]))
-
-        self.assertFalse(may_share_memory(d[::-1], d2))
-        self.assertFalse(may_share_memory(d[::2], d2))
-        self.assertFalse(may_share_memory(d[1:, ::-1], d2))
-        self.assertTrue(may_share_memory(d2[1:, ::-1], d2))
+        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))
 
 
 # Utility
diff --git a/numpy/lib/tests/test_stride_tricks.py b/numpy/lib/tests/test_stride_tricks.py
index 3adcf0b41..cd0973300 100644
--- a/numpy/lib/tests/test_stride_tricks.py
+++ b/numpy/lib/tests/test_stride_tricks.py
@@ -1,15 +1,17 @@
 from __future__ import division, absolute_import, print_function
 
 import numpy as np
-from numpy.testing import *
-from numpy.lib.stride_tricks import broadcast_arrays
-from numpy.lib.stride_tricks import as_strided
+from numpy.testing import (
+    run_module_suite, assert_equal, assert_array_equal,
+    assert_raises
+    )
+from numpy.lib.stride_tricks import as_strided, broadcast_arrays
 
 
 def assert_shapes_correct(input_shapes, expected_shape):
-    """ Broadcast a list of arrays with the given input shapes and check the
-    common output shape.
-    """
+    # Broadcast a list of arrays with the given input shapes and check the
+    # common output shape.
+
     inarrays = [np.zeros(s) for s in input_shapes]
     outarrays = broadcast_arrays(*inarrays)
     outshapes = [a.shape for a in outarrays]
@@ -18,17 +20,17 @@ def assert_shapes_correct(input_shapes, expected_shape):
 
 
 def assert_incompatible_shapes_raise(input_shapes):
-    """ Broadcast a list of arrays with the given (incompatible) input shapes
-    and check that they raise a ValueError.
-    """
+    # Broadcast a list of arrays with the given (incompatible) input shapes
+    # and check that they raise a ValueError.
+
     inarrays = [np.zeros(s) for s in input_shapes]
     assert_raises(ValueError, broadcast_arrays, *inarrays)
 
 
 def assert_same_as_ufunc(shape0, shape1, transposed=False, flipped=False):
-    """ Broadcast two shapes against each other and check that the data layout
-    is the same as if a ufunc did the broadcasting.
-    """
+    # Broadcast two shapes against each other and check that the data layout
+    # is the same as if a ufunc did the broadcasting.
+
     x0 = np.zeros(shape0, dtype=int)
     # Note that multiply.reduce's identity element is 1.0, so when shape1==(),
     # this gives the desired n==1.
@@ -66,8 +68,8 @@ def test_one_off():
 
 
 def test_same_input_shapes():
-    """ Check that the final shape is just the input shape.
-    """
+    # Check that the final shape is just the input shape.
+
     data = [
         (),
         (1,),
@@ -93,9 +95,9 @@ def test_same_input_shapes():
 
 
 def test_two_compatible_by_ones_input_shapes():
-    """ Check that two different input shapes (of the same length but some have
-    1s) broadcast to the correct shape.
-    """
+    # Check that two different input shapes of the same length, but some have
+    # ones, broadcast to the correct shape.
+
     data = [
         [[(1,), (3,)], (3,)],
         [[(1, 3), (3, 3)], (3, 3)],
@@ -118,9 +120,9 @@ def test_two_compatible_by_ones_input_shapes():
 
 
 def test_two_compatible_by_prepending_ones_input_shapes():
-    """ Check that two different input shapes (of different lengths) broadcast
-    to the correct shape.
-    """
+    # Check that two different input shapes (of different lengths) broadcast
+    # to the correct shape.
+
     data = [
         [[(), (3,)], (3,)],
         [[(3,), (3, 3)], (3, 3)],
@@ -150,8 +152,8 @@ def test_two_compatible_by_prepending_ones_input_shapes():
 
 
 def test_incompatible_shapes_raise_valueerror():
-    """ Check that a ValueError is raised for incompatible shapes.
-    """
+    # Check that a ValueError is raised for incompatible shapes.
+
     data = [
         [(3,), (4,)],
         [(2, 3), (2,)],
@@ -165,8 +167,8 @@ def test_incompatible_shapes_raise_valueerror():
 
 
 def test_same_as_ufunc():
-    """ Check that the data layout is the same as if a ufunc did the operation.
-    """
+    # Check that the data layout is the same as if a ufunc did the operation.
+
     data = [
         [[(1,), (3,)], (3,)],
         [[(1, 3), (3, 3)], (3, 3)],
diff --git a/numpy/lib/tests/test_twodim_base.py b/numpy/lib/tests/test_twodim_base.py
index f5b8fab4a..786993e91 100644
--- a/numpy/lib/tests/test_twodim_base.py
+++ b/numpy/lib/tests/test_twodim_base.py
@@ -15,7 +15,7 @@ from numpy import (
     )
 
 import numpy as np
-from numpy.compat import asbytes, asbytes_nested
+from numpy.compat import asbytes_nested
 
 
 def get_mat(n):
diff --git a/numpy/lib/tests/test_type_check.py b/numpy/lib/tests/test_type_check.py
index eac8134e5..3931f95e5 100644
--- a/numpy/lib/tests/test_type_check.py
+++ b/numpy/lib/tests/test_type_check.py
@@ -1,34 +1,32 @@
 from __future__ import division, absolute_import, print_function
 
-from numpy.lib import *
-from numpy.core import *
-from numpy.random import rand
-from numpy.compat import asbytes, long
+import numpy as np
+from numpy.compat import long
 from numpy.testing import (
-    TestCase, assert_, assert_equal, assert_array_equal, run_module_suite)
-
-try:
-    import ctypes
-    _HAS_CTYPE = True
-except ImportError:
-    _HAS_CTYPE = False
+    TestCase, assert_, assert_equal, assert_array_equal, run_module_suite
+    )
+from numpy.lib.type_check import (
+    common_type, mintypecode, isreal, iscomplex, isposinf, isneginf,
+    nan_to_num, isrealobj, iscomplexobj, asfarray, real_if_close
+    )
 
 
 def assert_all(x):
-    assert_(all(x), x)
+    assert_(np.all(x), x)
 
 
 class TestCommonType(TestCase):
     def test_basic(self):
-        ai32 = array([[1, 2], [3, 4]], dtype=int32)
-        af32 = array([[1, 2], [3, 4]], dtype=float32)
-        af64 = array([[1, 2], [3, 4]], dtype=float64)
-        acs = array([[1+5j, 2+6j], [3+7j, 4+8j]], dtype=csingle)
-        acd = array([[1+5j, 2+6j], [3+7j, 4+8j]], dtype=cdouble)
-        assert_(common_type(af32) == float32)
-        assert_(common_type(af64) == float64)
-        assert_(common_type(acs) == csingle)
-        assert_(common_type(acd) == cdouble)
+        ai32 = np.array([[1, 2], [3, 4]], dtype=np.int32)
+        af32 = np.array([[1, 2], [3, 4]], dtype=np.float32)
+        af64 = np.array([[1, 2], [3, 4]], dtype=np.float64)
+        acs = np.array([[1+5j, 2+6j], [3+7j, 4+8j]], dtype=np.csingle)
+        acd = np.array([[1+5j, 2+6j], [3+7j, 4+8j]], dtype=np.cdouble)
+        assert_(common_type(ai32) == np.float64)
+        assert_(common_type(af32) == np.float32)
+        assert_(common_type(af64) == np.float64)
+        assert_(common_type(acs) == np.csingle)
+        assert_(common_type(acd) == np.cdouble)
 
 
 class TestMintypecode(TestCase):
@@ -84,45 +82,45 @@ class TestMintypecode(TestCase):
 class TestIsscalar(TestCase):
 
     def test_basic(self):
-        assert_(isscalar(3))
-        assert_(not isscalar([3]))
-        assert_(not isscalar((3,)))
-        assert_(isscalar(3j))
-        assert_(isscalar(long(10)))
-        assert_(isscalar(4.0))
+        assert_(np.isscalar(3))
+        assert_(not np.isscalar([3]))
+        assert_(not np.isscalar((3,)))
+        assert_(np.isscalar(3j))
+        assert_(np.isscalar(long(10)))
+        assert_(np.isscalar(4.0))
 
 
 class TestReal(TestCase):
 
     def test_real(self):
-        y = rand(10,)
-        assert_array_equal(y, real(y))
+        y = np.random.rand(10,)
+        assert_array_equal(y, np.real(y))
 
     def test_cmplx(self):
-        y = rand(10,)+1j*rand(10,)
-        assert_array_equal(y.real, real(y))
+        y = np.random.rand(10,)+1j*np.random.rand(10,)
+        assert_array_equal(y.real, np.real(y))
 
 
 class TestImag(TestCase):
 
     def test_real(self):
-        y = rand(10,)
-        assert_array_equal(0, imag(y))
+        y = np.random.rand(10,)
+        assert_array_equal(0, np.imag(y))
 
     def test_cmplx(self):
-        y = rand(10,)+1j*rand(10,)
-        assert_array_equal(y.imag, imag(y))
+        y = np.random.rand(10,)+1j*np.random.rand(10,)
+        assert_array_equal(y.imag, np.imag(y))
 
 
 class TestIscomplex(TestCase):
 
     def test_fail(self):
-        z = array([-1, 0, 1])
+        z = np.array([-1, 0, 1])
         res = iscomplex(z)
-        assert_(not sometrue(res, axis=0))
+        assert_(not np.sometrue(res, axis=0))
 
     def test_pass(self):
-        z = array([-1j, 1, 0])
+        z = np.array([-1j, 1, 0])
         res = iscomplex(z)
         assert_array_equal(res, [1, 0, 0])
 
@@ -130,12 +128,12 @@ class TestIscomplex(TestCase):
 class TestIsreal(TestCase):
 
     def test_pass(self):
-        z = array([-1, 0, 1j])
+        z = np.array([-1, 0, 1j])
         res = isreal(z)
         assert_array_equal(res, [1, 1, 0])
 
     def test_fail(self):
-        z = array([-1j, 1, 0])
+        z = np.array([-1j, 1, 0])
         res = isreal(z)
         assert_array_equal(res, [0, 1, 1])
 
@@ -143,123 +141,115 @@ class TestIsreal(TestCase):
 class TestIscomplexobj(TestCase):
 
     def test_basic(self):
-        z = array([-1, 0, 1])
+        z = np.array([-1, 0, 1])
         assert_(not iscomplexobj(z))
-        z = array([-1j, 0, -1])
+        z = np.array([-1j, 0, -1])
         assert_(iscomplexobj(z))
 
 
 class TestIsrealobj(TestCase):
     def test_basic(self):
-        z = array([-1, 0, 1])
+        z = np.array([-1, 0, 1])
         assert_(isrealobj(z))
-        z = array([-1j, 0, -1])
+        z = np.array([-1j, 0, -1])
         assert_(not isrealobj(z))
 
 
 class TestIsnan(TestCase):
 
     def test_goodvalues(self):
-        z = array((-1., 0., 1.))
-        res = isnan(z) == 0
-        assert_all(alltrue(res, axis=0))
+        z = np.array((-1., 0., 1.))
+        res = np.isnan(z) == 0
+        assert_all(np.all(res, axis=0))
 
     def test_posinf(self):
-        with errstate(divide='ignore'):
-            assert_all(isnan(array((1.,))/0.) == 0)
+        with np.errstate(divide='ignore'):
+            assert_all(np.isnan(np.array((1.,))/0.) == 0)
 
     def test_neginf(self):
-        with errstate(divide='ignore'):
-            assert_all(isnan(array((-1.,))/0.) == 0)
+        with np.errstate(divide='ignore'):
+            assert_all(np.isnan(np.array((-1.,))/0.) == 0)
 
     def test_ind(self):
-        with errstate(divide='ignore', invalid='ignore'):
-            assert_all(isnan(array((0.,))/0.) == 1)
-
-    #def test_qnan(self):             log(-1) return pi*j now
-    #    assert_all(isnan(log(-1.)) == 1)
+        with np.errstate(divide='ignore', invalid='ignore'):
+            assert_all(np.isnan(np.array((0.,))/0.) == 1)
 
     def test_integer(self):
-        assert_all(isnan(1) == 0)
+        assert_all(np.isnan(1) == 0)
 
     def test_complex(self):
-        assert_all(isnan(1+1j) == 0)
+        assert_all(np.isnan(1+1j) == 0)
 
     def test_complex1(self):
-        with errstate(divide='ignore', invalid='ignore'):
-            assert_all(isnan(array(0+0j)/0.) == 1)
+        with np.errstate(divide='ignore', invalid='ignore'):
+            assert_all(np.isnan(np.array(0+0j)/0.) == 1)
 
 
 class TestIsfinite(TestCase):
+    # Fixme, wrong place, isfinite now ufunc 
 
     def test_goodvalues(self):
-        z = array((-1., 0., 1.))
-        res = isfinite(z) == 1
-        assert_all(alltrue(res, axis=0))
+        z = np.array((-1., 0., 1.))
+        res = np.isfinite(z) == 1
+        assert_all(np.all(res, axis=0))
 
     def test_posinf(self):
-        with errstate(divide='ignore', invalid='ignore'):
-            assert_all(isfinite(array((1.,))/0.) == 0)
+        with np.errstate(divide='ignore', invalid='ignore'):
+            assert_all(np.isfinite(np.array((1.,))/0.) == 0)
 
     def test_neginf(self):
-        with errstate(divide='ignore', invalid='ignore'):
-            assert_all(isfinite(array((-1.,))/0.) == 0)
+        with np.errstate(divide='ignore', invalid='ignore'):
+            assert_all(np.isfinite(np.array((-1.,))/0.) == 0)
 
     def test_ind(self):
-        with errstate(divide='ignore', invalid='ignore'):
-            assert_all(isfinite(array((0.,))/0.) == 0)
-
-    #def test_qnan(self):
-    #    assert_all(isfinite(log(-1.)) == 0)
+        with np.errstate(divide='ignore', invalid='ignore'):
+            assert_all(np.isfinite(np.array((0.,))/0.) == 0)
 
     def test_integer(self):
-        assert_all(isfinite(1) == 1)
+        assert_all(np.isfinite(1) == 1)
 
     def test_complex(self):
-        assert_all(isfinite(1+1j) == 1)
+        assert_all(np.isfinite(1+1j) == 1)
 
     def test_complex1(self):
-        with errstate(divide='ignore', invalid='ignore'):
-            assert_all(isfinite(array(1+1j)/0.) == 0)
+        with np.errstate(divide='ignore', invalid='ignore'):
+            assert_all(np.isfinite(np.array(1+1j)/0.) == 0)
 
 
 class TestIsinf(TestCase):
+    # Fixme, wrong place, isinf now ufunc 
 
     def test_goodvalues(self):
-        z = array((-1., 0., 1.))
-        res = isinf(z) == 0
-        assert_all(alltrue(res, axis=0))
+        z = np.array((-1., 0., 1.))
+        res = np.isinf(z) == 0
+        assert_all(np.all(res, axis=0))
 
     def test_posinf(self):
-        with errstate(divide='ignore', invalid='ignore'):
-            assert_all(isinf(array((1.,))/0.) == 1)
+        with np.errstate(divide='ignore', invalid='ignore'):
+            assert_all(np.isinf(np.array((1.,))/0.) == 1)
 
     def test_posinf_scalar(self):
-        with errstate(divide='ignore', invalid='ignore'):
-            assert_all(isinf(array(1.,)/0.) == 1)
+        with np.errstate(divide='ignore', invalid='ignore'):
+            assert_all(np.isinf(np.array(1.,)/0.) == 1)
 
     def test_neginf(self):
-        with errstate(divide='ignore', invalid='ignore'):
-            assert_all(isinf(array((-1.,))/0.) == 1)
+        with np.errstate(divide='ignore', invalid='ignore'):
+            assert_all(np.isinf(np.array((-1.,))/0.) == 1)
 
     def test_neginf_scalar(self):
-        with errstate(divide='ignore', invalid='ignore'):
-            assert_all(isinf(array(-1.)/0.) == 1)
+        with np.errstate(divide='ignore', invalid='ignore'):
+            assert_all(np.isinf(np.array(-1.)/0.) == 1)
 
     def test_ind(self):
-        with errstate(divide='ignore', invalid='ignore'):
-            assert_all(isinf(array((0.,))/0.) == 0)
-
-    #def test_qnan(self):
-    #    assert_all(isinf(log(-1.)) == 0)
-    #    assert_all(isnan(log(-1.)) == 1)
+        with np.errstate(divide='ignore', invalid='ignore'):
+            assert_all(np.isinf(np.array((0.,))/0.) == 0)
 
 
 class TestIsposinf(TestCase):
 
     def test_generic(self):
-        with errstate(divide='ignore', invalid='ignore'):
-            vals = isposinf(array((-1., 0, 1))/0.)
+        with np.errstate(divide='ignore', invalid='ignore'):
+            vals = isposinf(np.array((-1., 0, 1))/0.)
         assert_(vals[0] == 0)
         assert_(vals[1] == 0)
         assert_(vals[2] == 1)
@@ -268,8 +258,8 @@ class TestIsposinf(TestCase):
 class TestIsneginf(TestCase):
 
     def test_generic(self):
-        with errstate(divide='ignore', invalid='ignore'):
-            vals = isneginf(array((-1., 0, 1))/0.)
+        with np.errstate(divide='ignore', invalid='ignore'):
+            vals = isneginf(np.array((-1., 0, 1))/0.)
         assert_(vals[0] == 1)
         assert_(vals[1] == 0)
         assert_(vals[2] == 0)
@@ -278,11 +268,11 @@ class TestIsneginf(TestCase):
 class TestNanToNum(TestCase):
 
     def test_generic(self):
-        with errstate(divide='ignore', invalid='ignore'):
-            vals = nan_to_num(array((-1., 0, 1))/0.)
-        assert_all(vals[0] < -1e10) and assert_all(isfinite(vals[0]))
+        with np.errstate(divide='ignore', invalid='ignore'):
+            vals = nan_to_num(np.array((-1., 0, 1))/0.)
+        assert_all(vals[0] < -1e10) and assert_all(np.isfinite(vals[0]))
         assert_(vals[1] == 0)
-        assert_all(vals[2] > 1e10) and assert_all(isfinite(vals[2]))
+        assert_all(vals[2] > 1e10) and assert_all(np.isfinite(vals[2]))
 
     def test_integer(self):
         vals = nan_to_num(1)
@@ -293,30 +283,31 @@ class TestNanToNum(TestCase):
         assert_all(vals == 1+1j)
 
     def test_complex_bad(self):
-        with errstate(divide='ignore', invalid='ignore'):
+        with np.errstate(divide='ignore', invalid='ignore'):
             v = 1 + 1j
-            v += array(0+1.j)/0.
+            v += np.array(0+1.j)/0.
         vals = nan_to_num(v)
         # !! This is actually (unexpectedly) zero
-        assert_all(isfinite(vals))
+        assert_all(np.isfinite(vals))
 
     def test_complex_bad2(self):
-        with errstate(divide='ignore', invalid='ignore'):
+        with np.errstate(divide='ignore', invalid='ignore'):
             v = 1 + 1j
-            v += array(-1+1.j)/0.
+            v += np.array(-1+1.j)/0.
         vals = nan_to_num(v)
-        assert_all(isfinite(vals))
-        #assert_all(vals.imag > 1e10)  and assert_all(isfinite(vals))
+        assert_all(np.isfinite(vals))
+        # Fixme
+        #assert_all(vals.imag > 1e10)  and assert_all(np.isfinite(vals))
         # !! This is actually (unexpectedly) positive
         # !! inf.  Comment out for now, and see if it
         # !! changes
-        #assert_all(vals.real < -1e10) and assert_all(isfinite(vals))
+        #assert_all(vals.real < -1e10) and assert_all(np.isfinite(vals))
 
 
 class TestRealIfClose(TestCase):
 
     def test_basic(self):
-        a = rand(10)
+        a = np.random.rand(10)
         b = real_if_close(a+1e-15j)
         assert_all(isrealobj(b))
         assert_array_equal(a, b)
@@ -329,9 +320,9 @@ class TestRealIfClose(TestCase):
 class TestArrayConversion(TestCase):
 
     def test_asfarray(self):
-        a = asfarray(array([1, 2, 3]))
-        assert_equal(a.__class__, ndarray)
-        assert_(issubdtype(a.dtype, float))
+        a = asfarray(np.array([1, 2, 3]))
+        assert_equal(a.__class__, np.ndarray)
+        assert_(np.issubdtype(a.dtype, np.float))
 
 if __name__ == "__main__":
     run_module_suite()
diff --git a/numpy/lib/tests/test_ufunclike.py b/numpy/lib/tests/test_ufunclike.py
index 2bedd9b40..97d608ecf 100644
--- a/numpy/lib/tests/test_ufunclike.py
+++ b/numpy/lib/tests/test_ufunclike.py
@@ -1,9 +1,10 @@
 from __future__ import division, absolute_import, print_function
 
-from numpy.testing import *
 import numpy.core as nx
 import numpy.lib.ufunclike as ufl
-from numpy.testing.decorators import deprecated
+from numpy.testing import (
+    run_module_suite, TestCase, assert_, assert_equal, assert_array_equal
+    )
 
 
 class TestUfunclike(TestCase):
diff --git a/numpy/lib/tests/test_utils.py b/numpy/lib/tests/test_utils.py
index 36d5d6428..fcb37f98a 100644
--- a/numpy/lib/tests/test_utils.py
+++ b/numpy/lib/tests/test_utils.py
@@ -2,9 +2,11 @@ from __future__ import division, absolute_import, print_function
 
 import sys
 from numpy.core import arange
-from numpy.testing import *
-import numpy.lib.utils as utils
+from numpy.testing import (
+    run_module_suite, assert_, assert_equal
+    )
 from numpy.lib import deprecate
+import numpy.lib.utils as utils
 
 if sys.version_info[0] >= 3:
     from io import StringIO