STY: PEP8 compliance for numpy/lib/tests.

The possibly controversial part of this is making the nested array
value lists PEP8 compliant, as there is something to be said aligning
the values for clarity. In the end, it seemed like the easiest thing
to do was to make them PEP8 compliant. The eye can get used to that.

9 files changed, 243 insertions, 243 deletions

diff --git a/numpy/lib/tests/test__datasource.py b/numpy/lib/tests/test__datasource.py
index 89198f2bf..090f71f67 100644
--- a/numpy/lib/tests/test__datasource.py
+++ b/numpy/lib/tests/test__datasource.py
@@ -66,7 +66,7 @@ def valid_textfile(filedir):
 
 def invalid_textfile(filedir):
     # Generate and return an invalid filename.
-    fd, path = mkstemp(suffix='.txt', prefix='dstmp_',  dir=filedir)
+    fd, path = mkstemp(suffix='.txt', prefix='dstmp_', dir=filedir)
     os.close(fd)
     os.remove(path)
     return path
diff --git a/numpy/lib/tests/test__iotools.py b/numpy/lib/tests/test__iotools.py
index e19cf488f..4db19382a 100644
--- a/numpy/lib/tests/test__iotools.py
+++ b/numpy/lib/tests/test__iotools.py
@@ -287,7 +287,7 @@ class TestMiscFunctions(TestCase):
         ndtype = (int, float, float)
         assert_equal(easy_dtype(ndtype),
                      np.dtype([('f0', int), ('f1', float), ('f2', float)]))
-                # As list of types w names
+        # As list of types w names
         ndtype = (int, float, float)
         assert_equal(easy_dtype(ndtype, names="a, b, c"),
                      np.dtype([('a', int), ('b', float), ('c', float)]))
diff --git a/numpy/lib/tests/test_arraypad.py b/numpy/lib/tests/test_arraypad.py
index e07f856bb..f8ba8643a 100644
--- a/numpy/lib/tests/test_arraypad.py
+++ b/numpy/lib/tests/test_arraypad.py
@@ -18,7 +18,7 @@ class TestStatistic(TestCase):
              0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5,
              0.5, 0.5, 0.5, 0.5, 0.5,
 
-             0.,  1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9.,
+             0., 1., 2., 3., 4., 5., 6., 7., 8., 9.,
              10., 11., 12., 13., 14., 15., 16., 17., 18., 19.,
              20., 21., 22., 23., 24., 25., 26., 27., 28., 29.,
              30., 31., 32., 33., 34., 35., 36., 37., 38., 39.,
@@ -42,7 +42,7 @@ class TestStatistic(TestCase):
              99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
              99, 99, 99, 99, 99,
 
-             0,   1,  2,  3,  4,  5,  6,  7,  8,  9,
+             0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
              10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
              20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
              30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
@@ -66,16 +66,16 @@ class TestStatistic(TestCase):
              100, 100, 100, 100, 100, 100, 100, 100, 100, 100,
              100, 100, 100, 100, 100,
 
-             1,   2,   3,   4,   5,   6,   7,   8,   9,  10,
-             11,  12,  13,  14,  15,  16,  17,  18,  19,  20,
-             21,  22,  23,  24,  25,  26,  27,  28,  29,  30,
-             31,  32,  33,  34,  35,  36,  37,  38,  39,  40,
-             41,  42,  43,  44,  45,  46,  47,  48,  49,  50,
-             51,  52,  53,  54,  55,  56,  57,  58,  59,  60,
-             61,  62,  63,  64,  65,  66,  67,  68,  69,  70,
-             71,  72,  73,  74,  75,  76,  77,  78,  79,  80,
-             81,  82,  83,  84,  85,  86,  87,  88,  89,  90,
-             91,  92,  93,  94,  95,  96,  97,  98,  99, 100,
+             1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
+             11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
+             21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
+             31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
+             41, 42, 43, 44, 45, 46, 47, 48, 49, 50,
+             51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
+             61, 62, 63, 64, 65, 66, 67, 68, 69, 70,
+             71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
+             81, 82, 83, 84, 85, 86, 87, 88, 89, 90,
+             91, 92, 93, 94, 95, 96, 97, 98, 99, 100,
 
              100, 100, 100, 100, 100, 100, 100, 100, 100, 100,
              100, 100, 100, 100, 100, 100, 100, 100, 100, 100]
@@ -86,11 +86,11 @@ class TestStatistic(TestCase):
         a = np.arange(100)
         a = pad(a, (25, 20), 'minimum')
         b = np.array(
-            [0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-             0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-             0,  0,  0,  0,  0,
+            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+             0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+             0, 0, 0, 0, 0,
 
-             0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
+             0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
              10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
              20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
              30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
@@ -101,8 +101,8 @@ class TestStatistic(TestCase):
              80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
              90, 91, 92, 93, 94, 95, 96, 97, 98, 99,
 
-             0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-             0,  0,  0,  0,  0,  0,  0,  0,  0,  0]
+             0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+             0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
             )
         assert_array_equal(a, b)
 
@@ -110,11 +110,11 @@ class TestStatistic(TestCase):
         a = np.arange(100) + 2
         a = pad(a, (25, 20), 'minimum')
         b = np.array(
-            [2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
-             2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
-             2,  2,  2,  2,  2,
+            [2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+             2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+             2, 2, 2, 2, 2,
 
-             2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
+             2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
              12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
              22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
              32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
@@ -125,8 +125,8 @@ class TestStatistic(TestCase):
              82, 83, 84, 85, 86, 87, 88, 89, 90, 91,
              92, 93, 94, 95, 96, 97, 98, 99, 100, 101,
 
-             2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
-             2,  2,  2,  2,  2,  2,  2,  2,  2,  2]
+             2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+             2, 2, 2, 2, 2, 2, 2, 2, 2, 2]
             )
         assert_array_equal(a, b)
 
@@ -138,16 +138,16 @@ class TestStatistic(TestCase):
              49.5, 49.5, 49.5, 49.5, 49.5, 49.5, 49.5, 49.5, 49.5, 49.5,
              49.5, 49.5, 49.5, 49.5, 49.5,
 
-             0.,   1.,   2.,   3.,   4.,   5.,   6.,   7.,   8.,   9.,
-             10.,  11.,  12.,  13.,  14.,  15.,  16.,  17.,  18.,  19.,
-             20.,  21.,  22.,  23.,  24.,  25.,  26.,  27.,  28.,  29.,
-             30.,  31.,  32.,  33.,  34.,  35.,  36.,  37.,  38.,  39.,
-             40.,  41.,  42.,  43.,  44.,  45.,  46.,  47.,  48.,  49.,
-             50.,  51.,  52.,  53.,  54.,  55.,  56.,  57.,  58.,  59.,
-             60.,  61.,  62.,  63.,  64.,  65.,  66.,  67.,  68.,  69.,
-             70.,  71.,  72.,  73.,  74.,  75.,  76.,  77.,  78.,  79.,
-             80.,  81.,  82.,  83.,  84.,  85.,  86.,  87.,  88.,  89.,
-             90.,  91.,  92.,  93.,  94.,  95.,  96.,  97.,  98.,  99.,
+             0., 1., 2., 3., 4., 5., 6., 7., 8., 9.,
+             10., 11., 12., 13., 14., 15., 16., 17., 18., 19.,
+             20., 21., 22., 23., 24., 25., 26., 27., 28., 29.,
+             30., 31., 32., 33., 34., 35., 36., 37., 38., 39.,
+             40., 41., 42., 43., 44., 45., 46., 47., 48., 49.,
+             50., 51., 52., 53., 54., 55., 56., 57., 58., 59.,
+             60., 61., 62., 63., 64., 65., 66., 67., 68., 69.,
+             70., 71., 72., 73., 74., 75., 76., 77., 78., 79.,
+             80., 81., 82., 83., 84., 85., 86., 87., 88., 89.,
+             90., 91., 92., 93., 94., 95., 96., 97., 98., 99.,
 
              49.5, 49.5, 49.5, 49.5, 49.5, 49.5, 49.5, 49.5, 49.5, 49.5,
              49.5, 49.5, 49.5, 49.5, 49.5, 49.5, 49.5, 49.5, 49.5, 49.5]
@@ -158,13 +158,13 @@ class TestStatistic(TestCase):
         a = np.array([[3, 1, 4], [4, 5, 9], [9, 8, 2]])
         a = pad(a, 1, 'median')
         b = np.array(
-            [[4,   4, 5, 4,   4],
+            [[4, 4, 5, 4, 4],
 
-             [3,   3, 1, 4,   3],
-             [5,   4, 5, 9,   5],
-             [8,   9, 8, 2,   8],
+             [3, 3, 1, 4, 3],
+             [5, 4, 5, 9, 5],
+             [8, 9, 8, 2, 8],
 
-             [4,   4, 5, 4,   4]]
+             [4, 4, 5, 4, 4]]
             )
         assert_array_equal(a, b)
 
@@ -172,13 +172,13 @@ class TestStatistic(TestCase):
         a = np.array([[3, 1, 4], [4, 5, 9], [9, 8, 2]])
         a = pad(a.T, 1, 'median').T
         b = np.array(
-            [[5,   4, 5, 4,   5],
+            [[5, 4, 5, 4, 5],
 
-             [3,   3, 1, 4,   3],
-             [5,   4, 5, 9,   5],
-             [8,   9, 8, 2,   8],
+             [3, 3, 1, 4, 3],
+             [5, 4, 5, 9, 5],
+             [8, 9, 8, 2, 8],
 
-             [5,   4, 5, 4,   5]]
+             [5, 4, 5, 4, 5]]
             )
         assert_array_equal(a, b)
 
@@ -186,21 +186,21 @@ class TestStatistic(TestCase):
         a = [[4, 5, 6]]
         a = pad(a, (5, 7), 'mean', stat_length=2)
         b = np.array(
-            [[4, 4, 4, 4, 4,   4, 5, 6,   6, 6, 6, 6, 6, 6, 6],
-             [4, 4, 4, 4, 4,   4, 5, 6,   6, 6, 6, 6, 6, 6, 6],
-             [4, 4, 4, 4, 4,   4, 5, 6,   6, 6, 6, 6, 6, 6, 6],
-             [4, 4, 4, 4, 4,   4, 5, 6,   6, 6, 6, 6, 6, 6, 6],
-             [4, 4, 4, 4, 4,   4, 5, 6,   6, 6, 6, 6, 6, 6, 6],
-
-             [4, 4, 4, 4, 4,   4, 5, 6,   6, 6, 6, 6, 6, 6, 6],
-
-             [4, 4, 4, 4, 4,   4, 5, 6,   6, 6, 6, 6, 6, 6, 6],
-             [4, 4, 4, 4, 4,   4, 5, 6,   6, 6, 6, 6, 6, 6, 6],
-             [4, 4, 4, 4, 4,   4, 5, 6,   6, 6, 6, 6, 6, 6, 6],
-             [4, 4, 4, 4, 4,   4, 5, 6,   6, 6, 6, 6, 6, 6, 6],
-             [4, 4, 4, 4, 4,   4, 5, 6,   6, 6, 6, 6, 6, 6, 6],
-             [4, 4, 4, 4, 4,   4, 5, 6,   6, 6, 6, 6, 6, 6, 6],
-             [4, 4, 4, 4, 4,   4, 5, 6,   6, 6, 6, 6, 6, 6, 6]]
+            [[4, 4, 4, 4, 4, 4, 5, 6, 6, 6, 6, 6, 6, 6, 6],
+             [4, 4, 4, 4, 4, 4, 5, 6, 6, 6, 6, 6, 6, 6, 6],
+             [4, 4, 4, 4, 4, 4, 5, 6, 6, 6, 6, 6, 6, 6, 6],
+             [4, 4, 4, 4, 4, 4, 5, 6, 6, 6, 6, 6, 6, 6, 6],
+             [4, 4, 4, 4, 4, 4, 5, 6, 6, 6, 6, 6, 6, 6, 6],
+
+             [4, 4, 4, 4, 4, 4, 5, 6, 6, 6, 6, 6, 6, 6, 6],
+
+             [4, 4, 4, 4, 4, 4, 5, 6, 6, 6, 6, 6, 6, 6, 6],
+             [4, 4, 4, 4, 4, 4, 5, 6, 6, 6, 6, 6, 6, 6, 6],
+             [4, 4, 4, 4, 4, 4, 5, 6, 6, 6, 6, 6, 6, 6, 6],
+             [4, 4, 4, 4, 4, 4, 5, 6, 6, 6, 6, 6, 6, 6, 6],
+             [4, 4, 4, 4, 4, 4, 5, 6, 6, 6, 6, 6, 6, 6, 6],
+             [4, 4, 4, 4, 4, 4, 5, 6, 6, 6, 6, 6, 6, 6, 6],
+             [4, 4, 4, 4, 4, 4, 5, 6, 6, 6, 6, 6, 6, 6, 6]]
             )
         assert_array_equal(a, b)
 
@@ -212,16 +212,16 @@ class TestStatistic(TestCase):
              49.5, 49.5, 49.5, 49.5, 49.5, 49.5, 49.5, 49.5, 49.5, 49.5,
              49.5, 49.5, 49.5, 49.5, 49.5,
 
-             0.,   1.,   2.,   3.,   4.,   5.,   6.,   7.,   8.,   9.,
-             10.,  11.,  12.,  13.,  14.,  15.,  16.,  17.,  18.,  19.,
-             20.,  21.,  22.,  23.,  24.,  25.,  26.,  27.,  28.,  29.,
-             30.,  31.,  32.,  33.,  34.,  35.,  36.,  37.,  38.,  39.,
-             40.,  41.,  42.,  43.,  44.,  45.,  46.,  47.,  48.,  49.,
-             50.,  51.,  52.,  53.,  54.,  55.,  56.,  57.,  58.,  59.,
-             60.,  61.,  62.,  63.,  64.,  65.,  66.,  67.,  68.,  69.,
-             70.,  71.,  72.,  73.,  74.,  75.,  76.,  77.,  78.,  79.,
-             80.,  81.,  82.,  83.,  84.,  85.,  86.,  87.,  88.,  89.,
-             90.,  91.,  92.,  93.,  94.,  95.,  96.,  97.,  98.,  99.,
+             0., 1., 2., 3., 4., 5., 6., 7., 8., 9.,
+             10., 11., 12., 13., 14., 15., 16., 17., 18., 19.,
+             20., 21., 22., 23., 24., 25., 26., 27., 28., 29.,
+             30., 31., 32., 33., 34., 35., 36., 37., 38., 39.,
+             40., 41., 42., 43., 44., 45., 46., 47., 48., 49.,
+             50., 51., 52., 53., 54., 55., 56., 57., 58., 59.,
+             60., 61., 62., 63., 64., 65., 66., 67., 68., 69.,
+             70., 71., 72., 73., 74., 75., 76., 77., 78., 79.,
+             80., 81., 82., 83., 84., 85., 86., 87., 88., 89.,
+             90., 91., 92., 93., 94., 95., 96., 97., 98., 99.,
 
              49.5, 49.5, 49.5, 49.5, 49.5, 49.5, 49.5, 49.5, 49.5, 49.5,
              49.5, 49.5, 49.5, 49.5, 49.5, 49.5, 49.5, 49.5, 49.5, 49.5]
@@ -238,7 +238,7 @@ class TestConstant(TestCase):
              10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
              10, 10, 10, 10, 10,
 
-             0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
+             0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
              10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
              20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
              30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
@@ -276,7 +276,7 @@ class TestLinearRamp(TestCase):
              90.0, 91.0, 92.0, 93.0, 94.0, 95.0, 96.0, 97.0, 98.0, 99.0,
 
              94.3, 89.6, 84.9, 80.2, 75.5, 70.8, 66.1, 61.4, 56.7, 52.0,
-             47.3, 42.6, 37.9, 33.2, 28.5, 23.8, 19.1, 14.4,  9.7,  5.]
+             47.3, 42.6, 37.9, 33.2, 28.5, 23.8, 19.1, 14.4, 9.7, 5.]
             )
         assert_array_almost_equal(a, b, decimal=5)
 
@@ -287,10 +287,10 @@ class TestReflect(TestCase):
         a = pad(a, (25, 20), 'reflect')
         b = np.array(
             [25, 24, 23, 22, 21, 20, 19, 18, 17, 16,
-             15, 14, 13, 12, 11, 10,  9,  8,  7,  6,
-             5,  4,  3,  2,  1,
+             15, 14, 13, 12, 11, 10, 9, 8, 7, 6,
+             5, 4, 3, 2, 1,
 
-             0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
+             0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
              10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
              20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
              30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
@@ -310,22 +310,22 @@ class TestReflect(TestCase):
         a = [[4, 5, 6], [6, 7, 8]]
         a = pad(a, (5, 7), 'reflect')
         b = np.array(
-            [[7, 6, 7, 8, 7,   6, 7, 8,   7, 6, 7, 8, 7, 6, 7],
-             [5, 4, 5, 6, 5,   4, 5, 6,   5, 4, 5, 6, 5, 4, 5],
-             [7, 6, 7, 8, 7,   6, 7, 8,   7, 6, 7, 8, 7, 6, 7],
-             [5, 4, 5, 6, 5,   4, 5, 6,   5, 4, 5, 6, 5, 4, 5],
-             [7, 6, 7, 8, 7,   6, 7, 8,   7, 6, 7, 8, 7, 6, 7],
-
-             [5, 4, 5, 6, 5,   4, 5, 6,   5, 4, 5, 6, 5, 4, 5],
-             [7, 6, 7, 8, 7,   6, 7, 8,   7, 6, 7, 8, 7, 6, 7],
-
-             [5, 4, 5, 6, 5,   4, 5, 6,   5, 4, 5, 6, 5, 4, 5],
-             [7, 6, 7, 8, 7,   6, 7, 8,   7, 6, 7, 8, 7, 6, 7],
-             [5, 4, 5, 6, 5,   4, 5, 6,   5, 4, 5, 6, 5, 4, 5],
-             [7, 6, 7, 8, 7,   6, 7, 8,   7, 6, 7, 8, 7, 6, 7],
-             [5, 4, 5, 6, 5,   4, 5, 6,   5, 4, 5, 6, 5, 4, 5],
-             [7, 6, 7, 8, 7,   6, 7, 8,   7, 6, 7, 8, 7, 6, 7],
-             [5, 4, 5, 6, 5,   4, 5, 6,   5, 4, 5, 6, 5, 4, 5]]
+            [[7, 6, 7, 8, 7, 6, 7, 8, 7, 6, 7, 8, 7, 6, 7],
+             [5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5],
+             [7, 6, 7, 8, 7, 6, 7, 8, 7, 6, 7, 8, 7, 6, 7],
+             [5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5],
+             [7, 6, 7, 8, 7, 6, 7, 8, 7, 6, 7, 8, 7, 6, 7],
+
+             [5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5],
+             [7, 6, 7, 8, 7, 6, 7, 8, 7, 6, 7, 8, 7, 6, 7],
+
+             [5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5],
+             [7, 6, 7, 8, 7, 6, 7, 8, 7, 6, 7, 8, 7, 6, 7],
+             [5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5],
+             [7, 6, 7, 8, 7, 6, 7, 8, 7, 6, 7, 8, 7, 6, 7],
+             [5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5],
+             [7, 6, 7, 8, 7, 6, 7, 8, 7, 6, 7, 8, 7, 6, 7],
+             [5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5]]
             )
         assert_array_equal(a, b)
 
@@ -333,21 +333,21 @@ class TestReflect(TestCase):
         a = [[4, 5, 6]]
         a = pad(a, (5, 7), 'reflect')
         b = np.array(
-            [[5, 4, 5, 6, 5,   4, 5, 6,   5, 4, 5, 6, 5, 4, 5],
-             [5, 4, 5, 6, 5,   4, 5, 6,   5, 4, 5, 6, 5, 4, 5],
-             [5, 4, 5, 6, 5,   4, 5, 6,   5, 4, 5, 6, 5, 4, 5],
-             [5, 4, 5, 6, 5,   4, 5, 6,   5, 4, 5, 6, 5, 4, 5],
-             [5, 4, 5, 6, 5,   4, 5, 6,   5, 4, 5, 6, 5, 4, 5],
-
-             [5, 4, 5, 6, 5,   4, 5, 6,   5, 4, 5, 6, 5, 4, 5],
-
-             [5, 4, 5, 6, 5,   4, 5, 6,   5, 4, 5, 6, 5, 4, 5],
-             [5, 4, 5, 6, 5,   4, 5, 6,   5, 4, 5, 6, 5, 4, 5],
-             [5, 4, 5, 6, 5,   4, 5, 6,   5, 4, 5, 6, 5, 4, 5],
-             [5, 4, 5, 6, 5,   4, 5, 6,   5, 4, 5, 6, 5, 4, 5],
-             [5, 4, 5, 6, 5,   4, 5, 6,   5, 4, 5, 6, 5, 4, 5],
-             [5, 4, 5, 6, 5,   4, 5, 6,   5, 4, 5, 6, 5, 4, 5],
-             [5, 4, 5, 6, 5,   4, 5, 6,   5, 4, 5, 6, 5, 4, 5]]
+            [[5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5],
+             [5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5],
+             [5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5],
+             [5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5],
+             [5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5],
+
+             [5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5],
+
+             [5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5],
+             [5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5],
+             [5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5],
+             [5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5],
+             [5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5],
+             [5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5],
+             [5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5, 6, 5, 4, 5]]
             )
         assert_array_equal(a, b)
 
@@ -376,7 +376,7 @@ class TestWrap(TestCase):
              85, 86, 87, 88, 89, 90, 91, 92, 93, 94,
              95, 96, 97, 98, 99,
 
-             0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
+             0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
              10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
              20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
              30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
@@ -387,7 +387,7 @@ class TestWrap(TestCase):
              80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
              90, 91, 92, 93, 94, 95, 96, 97, 98, 99,
 
-             0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
+             0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
              10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
             )
         assert_array_equal(a, b)
@@ -397,58 +397,58 @@ class TestWrap(TestCase):
         a = np.reshape(a, (3, 4))
         a = pad(a, (10, 12), 'wrap')
         b = np.array(
-            [[10, 11,  8,  9, 10, 11,  8,  9, 10, 11, 8,  9, 10, 11,  8,  9, 10,
-              11,  8,  9, 10, 11,  8,  9, 10, 11],
-             [2,  3,  0,  1,  2,  3,  0,  1,  2,  3,  0,  1,  2,  3,  0,  1,  2,
-              3,  0,  1,  2,  3,  0,  1,  2,  3],
-             [6,  7,  4,  5,  6,  7,  4,  5,  6,  7,  4,  5,  6,  7,  4,  5,  6,
-              7,  4,  5,  6,  7,  4,  5,  6,  7],
-             [10, 11,  8,  9, 10, 11,  8,  9, 10, 11, 8,  9, 10, 11,  8,  9, 10,
-              11,  8,  9, 10, 11,  8,  9, 10, 11],
-             [2,  3,  0,  1,  2,  3,  0,  1,  2,  3,  0,  1,  2,  3,  0,  1,  2,
-              3,  0,  1,  2,  3,  0,  1,  2,  3],
-             [6,  7,  4,  5,  6,  7,  4,  5,  6,  7,  4,  5,  6,  7,  4,  5,  6,
-              7,  4,  5,  6,  7,  4,  5,  6,  7],
-             [10, 11,  8,  9, 10, 11,  8,  9, 10, 11, 8,  9, 10, 11,  8,  9, 10,
-              11,  8,  9, 10, 11,  8,  9, 10, 11],
-             [2,  3,  0,  1,  2,  3,  0,  1,  2,  3,  0,  1,  2,  3,  0,  1,  2,
-              3,  0,  1,  2,  3,  0,  1,  2,  3],
-             [6,  7,  4,  5,  6,  7,  4,  5,  6,  7,  4,  5,  6,  7,  4,  5,  6,
-              7,  4,  5,  6,  7,  4,  5,  6,  7],
-             [10, 11,  8,  9, 10, 11,  8,  9, 10, 11, 8,  9, 10, 11,  8,  9, 10,
-              11,  8,  9, 10, 11,  8,  9, 10, 11],
-
-             [2,  3,  0,  1,  2,  3,  0,  1,  2,  3,  0,  1,  2,  3,  0,  1,  2,
-              3,  0,  1,  2,  3,  0,  1,  2,  3],
-             [6,  7,  4,  5,  6,  7,  4,  5,  6,  7,  4,  5,  6,  7,  4,  5,  6,
-              7,  4,  5,  6,  7,  4,  5,  6,  7],
-             [10, 11,  8,  9, 10, 11,  8,  9, 10, 11, 8,  9, 10, 11,  8,  9, 10,
-              11,  8,  9, 10, 11,  8,  9, 10, 11],
-
-             [2,  3,  0,  1,  2,  3,  0,  1,  2,  3,  0,  1,  2,  3,  0,  1,  2,
-              3,  0,  1,  2,  3,  0,  1,  2,  3],
-             [6,  7,  4,  5,  6,  7,  4,  5,  6,  7,  4,  5,  6,  7,  4,  5,  6,
-              7,  4,  5,  6,  7,  4,  5,  6,  7],
-             [10, 11,  8,  9, 10, 11,  8,  9, 10, 11, 8,  9, 10, 11,  8,  9, 10,
-              11,  8,  9, 10, 11,  8,  9, 10, 11],
-             [2,  3,  0,  1,  2,  3,  0,  1,  2,  3,  0,  1,  2,  3,  0,  1,  2,
-              3,  0,  1,  2,  3,  0,  1,  2,  3],
-             [6,  7,  4,  5,  6,  7,  4,  5,  6,  7,  4,  5,  6,  7,  4,  5,  6,
-              7,  4,  5,  6,  7,  4,  5,  6,  7],
-             [10, 11,  8,  9, 10, 11,  8,  9, 10, 11, 8,  9, 10, 11,  8,  9, 10,
-              11,  8,  9, 10, 11,  8,  9, 10, 11],
-             [2,  3,  0,  1,  2,  3,  0,  1,  2,  3,  0,  1,  2,  3,  0,  1,  2,
-              3,  0,  1,  2,  3,  0,  1,  2,  3],
-             [6,  7,  4,  5,  6,  7,  4,  5,  6,  7,  4,  5,  6,  7,  4,  5,  6,
-              7,  4,  5,  6,  7,  4,  5,  6,  7],
-             [10, 11,  8,  9, 10, 11,  8,  9, 10, 11, 8,  9, 10, 11,  8,  9, 10,
-              11,  8,  9, 10, 11,  8,  9, 10, 11],
-             [2,  3,  0,  1,  2,  3,  0,  1,  2,  3,  0,  1,  2,  3,  0,  1,  2,
-              3,  0,  1,  2,  3,  0,  1,  2,  3],
-             [6,  7,  4,  5,  6,  7,  4,  5,  6,  7,  4,  5,  6,  7,  4,  5,  6,
-              7,  4,  5,  6,  7,  4,  5,  6,  7],
-             [10, 11,  8,  9, 10, 11,  8,  9, 10, 11, 8,  9, 10, 11,  8,  9, 10,
-              11,  8,  9, 10, 11,  8,  9, 10, 11]]
+            [[10, 11, 8, 9, 10, 11, 8, 9, 10, 11, 8, 9, 10, 11, 8, 9, 10,
+              11, 8, 9, 10, 11, 8, 9, 10, 11],
+             [2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2,
+              3, 0, 1, 2, 3, 0, 1, 2, 3],
+             [6, 7, 4, 5, 6, 7, 4, 5, 6, 7, 4, 5, 6, 7, 4, 5, 6,
+              7, 4, 5, 6, 7, 4, 5, 6, 7],
+             [10, 11, 8, 9, 10, 11, 8, 9, 10, 11, 8, 9, 10, 11, 8, 9, 10,
+              11, 8, 9, 10, 11, 8, 9, 10, 11],
+             [2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2,
+              3, 0, 1, 2, 3, 0, 1, 2, 3],
+             [6, 7, 4, 5, 6, 7, 4, 5, 6, 7, 4, 5, 6, 7, 4, 5, 6,
+              7, 4, 5, 6, 7, 4, 5, 6, 7],
+             [10, 11, 8, 9, 10, 11, 8, 9, 10, 11, 8, 9, 10, 11, 8, 9, 10,
+              11, 8, 9, 10, 11, 8, 9, 10, 11],
+             [2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2,
+              3, 0, 1, 2, 3, 0, 1, 2, 3],
+             [6, 7, 4, 5, 6, 7, 4, 5, 6, 7, 4, 5, 6, 7, 4, 5, 6,
+              7, 4, 5, 6, 7, 4, 5, 6, 7],
+             [10, 11, 8, 9, 10, 11, 8, 9, 10, 11, 8, 9, 10, 11, 8, 9, 10,
+              11, 8, 9, 10, 11, 8, 9, 10, 11],
+
+             [2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2,
+              3, 0, 1, 2, 3, 0, 1, 2, 3],
+             [6, 7, 4, 5, 6, 7, 4, 5, 6, 7, 4, 5, 6, 7, 4, 5, 6,
+              7, 4, 5, 6, 7, 4, 5, 6, 7],
+             [10, 11, 8, 9, 10, 11, 8, 9, 10, 11, 8, 9, 10, 11, 8, 9, 10,
+              11, 8, 9, 10, 11, 8, 9, 10, 11],
+
+             [2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2,
+              3, 0, 1, 2, 3, 0, 1, 2, 3],
+             [6, 7, 4, 5, 6, 7, 4, 5, 6, 7, 4, 5, 6, 7, 4, 5, 6,
+              7, 4, 5, 6, 7, 4, 5, 6, 7],
+             [10, 11, 8, 9, 10, 11, 8, 9, 10, 11, 8, 9, 10, 11, 8, 9, 10,
+              11, 8, 9, 10, 11, 8, 9, 10, 11],
+             [2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2,
+              3, 0, 1, 2, 3, 0, 1, 2, 3],
+             [6, 7, 4, 5, 6, 7, 4, 5, 6, 7, 4, 5, 6, 7, 4, 5, 6,
+              7, 4, 5, 6, 7, 4, 5, 6, 7],
+             [10, 11, 8, 9, 10, 11, 8, 9, 10, 11, 8, 9, 10, 11, 8, 9, 10,
+              11, 8, 9, 10, 11, 8, 9, 10, 11],
+             [2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2,
+              3, 0, 1, 2, 3, 0, 1, 2, 3],
+             [6, 7, 4, 5, 6, 7, 4, 5, 6, 7, 4, 5, 6, 7, 4, 5, 6,
+              7, 4, 5, 6, 7, 4, 5, 6, 7],
+             [10, 11, 8, 9, 10, 11, 8, 9, 10, 11, 8, 9, 10, 11, 8, 9, 10,
+              11, 8, 9, 10, 11, 8, 9, 10, 11],
+             [2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2,
+              3, 0, 1, 2, 3, 0, 1, 2, 3],
+             [6, 7, 4, 5, 6, 7, 4, 5, 6, 7, 4, 5, 6, 7, 4, 5, 6,
+              7, 4, 5, 6, 7, 4, 5, 6, 7],
+             [10, 11, 8, 9, 10, 11, 8, 9, 10, 11, 8, 9, 10, 11, 8, 9, 10,
+              11, 8, 9, 10, 11, 8, 9, 10, 11]]
             )
         assert_array_equal(a, b)
 
@@ -469,19 +469,19 @@ class TestStatLen(TestCase):
         a = np.reshape(a, (6, 5))
         a = pad(a, ((2, 3), (3, 2)), mode='mean', stat_length=(3,))
         b = np.array(
-            [[6,  6,  6,     5,  6,  7,  8,  9,     8,  8],
-             [6,  6,  6,     5,  6,  7,  8,  9,     8,  8],
-
-             [1,  1,  1,     0,  1,  2,  3,  4,     3,  3],
-             [6,  6,  6,     5,  6,  7,  8,  9,     8,  8],
-             [11, 11, 11,    10, 11, 12, 13, 14,    13, 13],
-             [16, 16, 16,    15, 16, 17, 18, 19,    18, 18],
-             [21, 21, 21,    20, 21, 22, 23, 24,    23, 23],
-             [26, 26, 26,    25, 26, 27, 28, 29,    28, 28],
-
-             [21, 21, 21,    20, 21, 22, 23, 24,    23, 23],
-             [21, 21, 21,    20, 21, 22, 23, 24,    23, 23],
-             [21, 21, 21,    20, 21, 22, 23, 24,    23, 23]]
+            [[6, 6, 6, 5, 6, 7, 8, 9, 8, 8],
+             [6, 6, 6, 5, 6, 7, 8, 9, 8, 8],
+
+             [1, 1, 1, 0, 1, 2, 3, 4, 3, 3],
+             [6, 6, 6, 5, 6, 7, 8, 9, 8, 8],
+             [11, 11, 11, 10, 11, 12, 13, 14, 13, 13],
+             [16, 16, 16, 15, 16, 17, 18, 19, 18, 18],
+             [21, 21, 21, 20, 21, 22, 23, 24, 23, 23],
+             [26, 26, 26, 25, 26, 27, 28, 29, 28, 28],
+
+             [21, 21, 21, 20, 21, 22, 23, 24, 23, 23],
+             [21, 21, 21, 20, 21, 22, 23, 24, 23, 23],
+             [21, 21, 21, 20, 21, 22, 23, 24, 23, 23]]
             )
         assert_array_equal(a, b)
 
@@ -492,17 +492,17 @@ class TestEdge(TestCase):
         a = np.reshape(a, (4, 3))
         a = pad(a, ((2, 3), (3, 2)), 'edge')
         b = np.array(
-            [[0,  0,  0,    0,  1,  2,    2,  2],
-             [0,  0,  0,    0,  1,  2,    2,  2],
+            [[0, 0, 0, 0, 1, 2, 2, 2],
+             [0, 0, 0, 0, 1, 2, 2, 2],
 
-             [0,  0,  0,    0,  1,  2,    2,  2],
-             [3,  3,  3,    3,  4,  5,    5,  5],
-             [6,  6,  6,    6,  7,  8,    8,  8],
-             [9,  9,  9,    9, 10, 11,   11, 11],
+             [0, 0, 0, 0, 1, 2, 2, 2],
+             [3, 3, 3, 3, 4, 5, 5, 5],
+             [6, 6, 6, 6, 7, 8, 8, 8],
+             [9, 9, 9, 9, 10, 11, 11, 11],
 
-             [9,  9,  9,    9, 10, 11,   11, 11],
-             [9,  9,  9,    9, 10, 11,   11, 11],
-             [9,  9,  9,    9, 10, 11,   11, 11]]
+             [9, 9, 9, 9, 10, 11, 11, 11],
+             [9, 9, 9, 9, 10, 11, 11, 11],
+             [9, 9, 9, 9, 10, 11, 11, 11]]
             )
         assert_array_equal(a, b)
 
diff --git a/numpy/lib/tests/test_arraysetops.py b/numpy/lib/tests/test_arraysetops.py
index d2638e4b9..e83f8552e 100644
--- a/numpy/lib/tests/test_arraysetops.py
+++ b/numpy/lib/tests/test_arraysetops.py
@@ -96,8 +96,8 @@ class TestSetOps(TestCase):
         check_all(aa, bb, i1, i2, c, dt)
 
         # test for ticket #2799
-        aa = [1.+0.j, 1- 1.j, 1]
-        assert_array_equal(np.unique(aa), [ 1.-1.j,  1.+0.j])
+        aa = [1. + 0.j, 1 - 1.j, 1]
+        assert_array_equal(np.unique(aa), [1. - 1.j, 1. + 0.j])
 
         # test for ticket #4785
         a = [(1, 2), (1, 2), (2, 3)]
diff --git a/numpy/lib/tests/test_financial.py b/numpy/lib/tests/test_financial.py
index f02cfb36a..a4b9cfe2e 100644
--- a/numpy/lib/tests/test_financial.py
+++ b/numpy/lib/tests/test_financial.py
@@ -141,7 +141,7 @@ class TestFinancial(TestCase):
 
     def test_broadcast(self):
         assert_almost_equal(np.nper(0.075, -2000, 0, 100000., [0, 1]),
-                            [21.5449442,  20.76156441], 4)
+                            [21.5449442, 20.76156441], 4)
 
         assert_almost_equal(np.ipmt(0.1/12, list(range(5)), 24, 2000),
                             [-17.29165168, -16.66666667, -16.03647345,
diff --git a/numpy/lib/tests/test_index_tricks.py b/numpy/lib/tests/test_index_tricks.py
index 375fd9517..97047c53a 100644
--- a/numpy/lib/tests/test_index_tricks.py
+++ b/numpy/lib/tests/test_index_tricks.py
@@ -229,16 +229,16 @@ def test_fill_diagonal():
 
 def test_diag_indices():
     di = diag_indices(4)
-    a = np.array([[1,  2,  3,  4],
-               [5,  6,  7,  8],
-               [9,  10, 11, 12],
+    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,
-           np.array([[100, 2,   3,   4],
-                  [5,   100, 7,   8],
-                  [9,   10,  100, 12],
-                  [13,  14,  15,  100]]))
+           np.array([[100, 2, 3, 4],
+                  [5, 100, 7, 8],
+                  [9, 10, 100, 12],
+                  [13, 14, 15, 100]]))
 
     # Now, we create indices to manipulate a 3-d array:
     d3 = diag_indices(2, 3)
diff --git a/numpy/lib/tests/test_nanfunctions.py b/numpy/lib/tests/test_nanfunctions.py
index c5af61434..3da6b5149 100644
--- a/numpy/lib/tests/test_nanfunctions.py
+++ b/numpy/lib/tests/test_nanfunctions.py
@@ -10,17 +10,17 @@ from numpy.testing import (
 
 
 # Test data
-_ndat = np.array([[0.6244, np.nan, 0.2692,  0.0116, np.nan, 0.1170],
-                  [0.5351, -0.9403, np.nan,  0.2100, 0.4759, 0.2833],
-                  [np.nan, np.nan, np.nan,  0.1042, np.nan, -0.5954],
-                  [0.1610, np.nan, np.nan,  0.1859, 0.3146, np.nan]])
+_ndat = np.array([[0.6244, np.nan, 0.2692, 0.0116, np.nan, 0.1170],
+                  [0.5351, -0.9403, np.nan, 0.2100, 0.4759, 0.2833],
+                  [np.nan, np.nan, np.nan, 0.1042, np.nan, -0.5954],
+                  [0.1610, np.nan, np.nan, 0.1859, 0.3146, np.nan]])
 
 
 # Rows of _ndat with nans removed
-_rdat = [np.array([ 0.6244, 0.2692, 0.0116, 0.1170]),
-         np.array([ 0.5351, -0.9403, 0.2100, 0.4759, 0.2833]),
-         np.array([ 0.1042, -0.5954]),
-         np.array([ 0.1610, 0.1859, 0.3146])]
+_rdat = [np.array([0.6244, 0.2692, 0.0116, 0.1170]),
+         np.array([0.5351, -0.9403, 0.2100, 0.4759, 0.2833]),
+         np.array([0.1042, -0.5954]),
+         np.array([0.1610, 0.1859, 0.3146])]
 
 
 class TestNanFunctions_MinMax(TestCase):
@@ -205,7 +205,7 @@ class TestNanFunctions_IntTypes(TestCase):
     int_types = (np.int8, np.int16, np.int32, np.int64, np.uint8,
                  np.uint16, np.uint32, np.uint64)
 
-    mat = np.array([127, 39,  93,  87, 46])
+    mat = np.array([127, 39, 93, 87, 46])
 
     def integer_arrays(self):
         for dtype in self.int_types:
@@ -383,13 +383,13 @@ class TestNanFunctions_MeanVarStd(TestCase):
     def test_dtype_error(self):
         for f in self.nanfuncs:
             for dtype in [np.bool_, np.int_, np.object]:
-                assert_raises( TypeError, f, _ndat, axis=1, dtype=np.int)
+                assert_raises(TypeError, f, _ndat, axis=1, dtype=np.int)
 
     def test_out_dtype_error(self):
         for f in self.nanfuncs:
             for dtype in [np.bool_, np.int_, np.object]:
                 out = np.empty(_ndat.shape[0], dtype=dtype)
-                assert_raises( TypeError, f, _ndat, axis=1, out=out)
+                assert_raises(TypeError, f, _ndat, axis=1, out=out)
 
     def test_keepdims(self):
         mat = np.eye(3)
@@ -587,7 +587,7 @@ class TestNanFunctions_Median(TestCase):
             # Randomly set some elements to NaN:
             w = np.random.randint(0, d.size, size=d.size // 5)
             d.ravel()[w] = np.nan
-            d[:,0] = 1. # ensure at least one good value
+            d[:,0] = 1.  # ensure at least one good value
             # use normal median without nans to compare
             tgt = []
             for x in d:
diff --git a/numpy/lib/tests/test_polynomial.py b/numpy/lib/tests/test_polynomial.py
index 12d800e2e..02faa0283 100644
--- a/numpy/lib/tests/test_polynomial.py
+++ b/numpy/lib/tests/test_polynomial.py
@@ -121,10 +121,10 @@ class TestDocs(TestCase):
         assert_almost_equal(val0, cov, decimal=4)
 
         m2, cov2 = np.polyfit(x, y+err, 2, w=weights, cov=True)
-        assert_almost_equal([4.8927, -1.0177,  1.7768], m2, decimal=4)
-        val = [[8.7929, -10.0103,   0.9756],
-               [-10.0103,  13.6134,  -1.8178],
-               [0.9756,  -1.8178,   0.6674]]
+        assert_almost_equal([4.8927, -1.0177, 1.7768], m2, decimal=4)
+        val = [[8.7929, -10.0103, 0.9756],
+               [-10.0103, 13.6134, -1.8178],
+               [0.9756, -1.8178, 0.6674]]
         assert_almost_equal(val, cov2, decimal=4)
 
         # check 2D (n,1) case
diff --git a/numpy/lib/tests/test_twodim_base.py b/numpy/lib/tests/test_twodim_base.py
index 786993e91..e9dbef70f 100644
--- a/numpy/lib/tests/test_twodim_base.py
+++ b/numpy/lib/tests/test_twodim_base.py
@@ -79,12 +79,12 @@ class TestEye(TestCase):
                             [0, 1, 0]]))
 
     def test_eye_bounds(self):
-        assert_equal(eye(2, 2,  1), [[0, 1], [0, 0]])
+        assert_equal(eye(2, 2, 1), [[0, 1], [0, 0]])
         assert_equal(eye(2, 2, -1), [[0, 0], [1, 0]])
-        assert_equal(eye(2, 2,  2), [[0, 0], [0, 0]])
+        assert_equal(eye(2, 2, 2), [[0, 0], [0, 0]])
         assert_equal(eye(2, 2, -2), [[0, 0], [0, 0]])
-        assert_equal(eye(3, 2,  2), [[0, 0], [0, 0], [0, 0]])
-        assert_equal(eye(3, 2,  1), [[0, 1], [0, 0], [0, 0]])
+        assert_equal(eye(3, 2, 2), [[0, 0], [0, 0], [0, 0]])
+        assert_equal(eye(3, 2, 1), [[0, 1], [0, 0], [0, 0]])
         assert_equal(eye(3, 2, -1), [[0, 0], [1, 0], [0, 1]])
         assert_equal(eye(3, 2, -2), [[0, 0], [0, 0], [1, 0]])
         assert_equal(eye(3, 2, -3), [[0, 0], [0, 0], [0, 0]])
@@ -248,13 +248,13 @@ class TestHistogram2d(TestCase):
         y = array([1, 1, 1, 2, 2, 2, 3, 3, 3])
         H, xed, yed = histogram2d(
             x, y, [[1, 2, 3, 5], [1, 2, 3, 5]], normed=True)
-        answer = array([[1,  1,  .5],
-                        [1,  1,  .5],
+        answer = array([[1, 1, .5],
+                        [1, 1, .5],
                         [.5, .5, .25]])/9.
         assert_array_almost_equal(H, answer, 3)
 
     def test_all_outliers(self):
-        r = rand(100) + 1. + 1e6 # histogramdd rounds by decimal=6
+        r = rand(100) + 1. + 1e6  # histogramdd rounds by decimal=6
         H, xed, yed = histogram2d(r, r, (4, 5), range=([0, 1], [0, 1]))
         assert_array_equal(H, 0)
 
@@ -329,29 +329,29 @@ def test_tril_indices():
     il3 = tril_indices(4, m=5)
     il4 = tril_indices(4, k=2, m=5)
 
-    a = np.array([[1,  2,  3,  4],
-                  [5,  6,  7,  8],
-                  [9,  10, 11, 12],
+    a = np.array([[1, 2, 3, 4],
+                  [5, 6, 7, 8],
+                  [9, 10, 11, 12],
                   [13, 14, 15, 16]])
     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]))
+           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]))
 
     # And for assigning values:
     a[il1] = -1
     yield (assert_array_equal, a,
-           array([[-1,  2,  3, 4],
-                  [-1, -1,  7, 8],
+           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],
+           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):
@@ -363,8 +363,8 @@ def test_tril_indices():
                   [-10, -10, -10, -10]]))
     b[il4] = -10
     yield (assert_array_equal, b,
-           array([[-10, -10, -10,   4,   5],
-                  [-10, -10, -10, -10,  10],
+           array([[-10, -10, -10, 4, 5],
+                  [-10, -10, -10, -10, 10],
                   [-10, -10, -10, -10, -10],
                   [-10, -10, -10, -10, -10]]))
 
@@ -376,15 +376,15 @@ class TestTriuIndices(object):
         iu3 = triu_indices(4, m=5)
         iu4 = triu_indices(4, k=2, m=5)
 
-        a = np.array([[1,  2,  3,  4],
-                      [5,  6,  7,  8],
-                      [9,  10, 11, 12],
+        a = np.array([[1, 2, 3, 4],
+                      [5, 6, 7, 8],
+                      [9, 10, 11, 12],
                       [13, 14, 15, 16]])
         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]))
+               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]))
 
@@ -392,13 +392,13 @@ class TestTriuIndices(object):
         a[iu1] = -1
         yield (assert_array_equal, a,
                array([[-1, -1, -1, -1],
-                      [5,  -1, -1, -1],
-                      [9,  10, -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],
+                      [6, -1, -1, -1, -1],
                       [11, 12, -1, -1, -1],
                       [16, 17, 18, -1, -1]]))
 
@@ -406,10 +406,10 @@ class TestTriuIndices(object):
         # 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]]))
+               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],
@@ -436,10 +436,10 @@ class TestVander(object):
     def test_basic(self):
         c = np.array([0, 1, -2, 3])
         v = vander(c)
-        powers = np.array([[ 0,  0, 0,  0, 1],
-                           [ 1,  1, 1,  1, 1],
+        powers = np.array([[0, 0, 0, 0, 1],
+                           [1, 1, 1, 1, 1],
                            [16, -8, 4, -2, 1],
-                           [81, 27, 9,  3, 1]])
+                           [81, 27, 9, 3, 1]])
         # Check default value of N:
         yield (assert_array_equal, v, powers[:, 1:])
         # Check a range of N values, including 0 and 5 (greater than default)
@@ -451,14 +451,14 @@ class TestVander(object):
     def test_dtypes(self):
         c = array([11, -12, 13], dtype=np.int8)
         v = vander(c)
-        expected = np.array([[121,  11, 1],
+        expected = np.array([[121, 11, 1],
                              [144, -12, 1],
-                             [169,  13, 1]])
+                             [169, 13, 1]])
         yield (assert_array_equal, v, expected)
 
         c = array([1.0+1j, 1.0-1j])
         v = vander(c, N=3)
-        expected = np.array([[ 2j, 1+1j, 1],
+        expected = np.array([[2j, 1+1j, 1],
                              [-2j, 1-1j, 1]])
         # The data is floating point, but the values are small integers,
         # so assert_array_equal *should* be safe here (rather than, say,