BUG: Fix possibly unbalanced seterr calls. Fixes change of divide state after

running np.test().

3 files changed, 78 insertions, 59 deletions

diff --git a/numpy/core/tests/test_numeric.py b/numpy/core/tests/test_numeric.py
index 8eb0d5359..59c195010 100644
--- a/numpy/core/tests/test_numeric.py
+++ b/numpy/core/tests/test_numeric.py
@@ -223,26 +223,32 @@ class TestBoolScalar(TestCase):
 class TestSeterr(TestCase):
     def test_set(self):
         err = seterr()
-        old = seterr(divide='warn')
-        self.assertTrue(err == old)
-        new = seterr()
-        self.assertTrue(new['divide'] == 'warn')
-        seterr(over='raise')
-        self.assertTrue(geterr()['over'] == 'raise')
-        self.assertTrue(new['divide'] == 'warn')
-        seterr(**old)
-        self.assertTrue(geterr() == old)
+        try:
+            old = seterr(divide='warn')
+            self.assertTrue(err == old)
+            new = seterr()
+            self.assertTrue(new['divide'] == 'warn')
+            seterr(over='raise')
+            self.assertTrue(geterr()['over'] == 'raise')
+            self.assertTrue(new['divide'] == 'warn')
+            seterr(**old)
+            self.assertTrue(geterr() == old)
+        finally:
+            seterr(**err)
 
     def test_divide_err(self):
-        seterr(divide='raise')
+        err = seterr(divide='raise')
         try:
+            try:
+                array([1.]) / array([0.])
+            except FloatingPointError:
+                pass
+            else:
+                self.fail()
+            seterr(divide='ignore')
             array([1.]) / array([0.])
-        except FloatingPointError:
-            pass
-        else:
-            self.fail()
-        seterr(divide='ignore')
-        array([1.]) / array([0.])
+        finally:
+            seterr(**err)
 
 
 class TestFromiter(TestCase):
diff --git a/numpy/core/tests/test_umath_complex.py b/numpy/core/tests/test_umath_complex.py
index c180b5e4a..c98060ac7 100644
--- a/numpy/core/tests/test_umath_complex.py
+++ b/numpy/core/tests/test_umath_complex.py
@@ -465,12 +465,16 @@ def check_real_value(f, x1, y1, x, exact=True):
         assert_almost_equal(f(z1), x)
 
 def check_complex_value(f, x1, y1, x2, y2, exact=True):
+    err = np.seterr(invalid='ignore')
     z1 = np.array([complex(x1, y1)])
     z2 = np.complex(x2, y2)
-    if exact:
-        assert_equal(f(z1), z2)
-    else:
-        assert_almost_equal(f(z1), z2)
+    try:
+        if exact:
+            assert_equal(f(z1), z2)
+        else:
+            assert_almost_equal(f(z1), z2)
+    finally:
+        np.seterr(**err)
 
 if __name__ == "__main__":
     run_module_suite()
diff --git a/numpy/ma/tests/test_old_ma.py b/numpy/ma/tests/test_old_ma.py
index cf971b32c..f0a8dff90 100644
--- a/numpy/ma/tests/test_old_ma.py
+++ b/numpy/ma/tests/test_old_ma.py
@@ -89,14 +89,18 @@ class TestMa(TestCase):
             self.assertTrue(eq(x - y, xm - ym))
             self.assertTrue(eq(x * y, xm * ym))
             olderr = numpy.seterr(divide='ignore', invalid='ignore')
-            self.assertTrue(eq(x / y, xm / ym))
-            numpy.seterr(**olderr)
+            try:
+                self.assertTrue(eq(x / y, xm / ym))
+            finally:
+                numpy.seterr(**olderr)
             self.assertTrue(eq(a10 + y, a10 + ym))
             self.assertTrue(eq(a10 - y, a10 - ym))
             self.assertTrue(eq(a10 * y, a10 * ym))
             olderr = numpy.seterr(divide='ignore', invalid='ignore')
-            self.assertTrue(eq(a10 / y, a10 / ym))
-            numpy.seterr(**olderr)
+            try:
+                self.assertTrue(eq(a10 / y, a10 / ym))
+            finally:
+                numpy.seterr(**olderr)
             self.assertTrue(eq(x + a10, xm + a10))
             self.assertTrue(eq(x - a10, xm - a10))
             self.assertTrue(eq(x * a10, xm * a10))
@@ -108,8 +112,10 @@ class TestMa(TestCase):
             self.assertTrue(eq(numpy.subtract(x,y), subtract(xm, ym)))
             self.assertTrue(eq(numpy.multiply(x,y), multiply(xm, ym)))
             olderr = numpy.seterr(divide='ignore', invalid='ignore')
-            self.assertTrue(eq(numpy.divide(x,y), divide(xm, ym)))
-            numpy.seterr(**olderr)
+            try:
+                self.assertTrue(eq(numpy.divide(x,y), divide(xm, ym)))
+            finally:
+                numpy.seterr(**olderr)
 
 
     def test_testMixedArithmetic(self):
@@ -128,10 +134,12 @@ class TestMa(TestCase):
         self.assertTrue (eq(numpy.tan(x), tan(xm)))
         self.assertTrue (eq(numpy.tanh(x), tanh(xm)))
         olderr = numpy.seterr(divide='ignore', invalid='ignore')
-        self.assertTrue (eq(numpy.sqrt(abs(x)), sqrt(xm)))
-        self.assertTrue (eq(numpy.log(abs(x)), log(xm)))
-        self.assertTrue (eq(numpy.log10(abs(x)), log10(xm)))
-        numpy.seterr(**olderr)
+        try:
+            self.assertTrue (eq(numpy.sqrt(abs(x)), sqrt(xm)))
+            self.assertTrue (eq(numpy.log(abs(x)), log(xm)))
+            self.assertTrue (eq(numpy.log10(abs(x)), log10(xm)))
+        finally:
+            numpy.seterr(**olderr)
         self.assertTrue (eq(numpy.exp(x), exp(xm)))
         self.assertTrue (eq(numpy.arcsin(z), arcsin(zm)))
         self.assertTrue (eq(numpy.arccos(z), arccos(zm)))
@@ -658,25 +666,28 @@ class TestUfuncs(TestCase):
 
 
     def test_testUfuncRegression(self):
+        f_invalid_ignore = ['sqrt', 'arctanh', 'arcsin', 'arccos',
+                'arccosh', 'arctanh', 'log', 'log10','divide',
+                'true_divide', 'floor_divide', 'remainder', 'fmod']
         for f in ['sqrt', 'log', 'log10', 'exp', 'conjugate',
-                  'sin', 'cos', 'tan',
-                  'arcsin', 'arccos', 'arctan',
-                  'sinh', 'cosh', 'tanh',
-                  'arcsinh',
-                  'arccosh',
-                  'arctanh',
-                  'absolute', 'fabs', 'negative',
-                  # 'nonzero', 'around',
-                  'floor', 'ceil',
-                  # 'sometrue', 'alltrue',
-                  'logical_not',
-                  'add', 'subtract', 'multiply',
-                  'divide', 'true_divide', 'floor_divide',
-                  'remainder', 'fmod', 'hypot', 'arctan2',
-                  'equal', 'not_equal', 'less_equal', 'greater_equal',
-                  'less', 'greater',
-                  'logical_and', 'logical_or', 'logical_xor',
-                  ]:
+                'sin', 'cos', 'tan',
+                'arcsin', 'arccos', 'arctan',
+                'sinh', 'cosh', 'tanh',
+                'arcsinh',
+                'arccosh',
+                'arctanh',
+                'absolute', 'fabs', 'negative',
+                # 'nonzero', 'around',
+                'floor', 'ceil',
+                # 'sometrue', 'alltrue',
+                'logical_not',
+                'add', 'subtract', 'multiply',
+                'divide', 'true_divide', 'floor_divide',
+                'remainder', 'fmod', 'hypot', 'arctan2',
+                'equal', 'not_equal', 'less_equal', 'greater_equal',
+                'less', 'greater',
+                'logical_and', 'logical_or', 'logical_xor',
+                ]:
             try:
                 uf = getattr(umath, f)
             except AttributeError:
@@ -684,17 +695,15 @@ class TestUfuncs(TestCase):
             mf = getattr(numpy.ma, f)
             args = self.d[:uf.nin]
             olderr = numpy.geterr()
-            f_invalid_ignore = ['sqrt', 'arctanh', 'arcsin', 'arccos',
-                                'arccosh', 'arctanh', 'log', 'log10','divide',
-                                'true_divide', 'floor_divide', 'remainder',
-                                'fmod']
-            if f in f_invalid_ignore:
-                numpy.seterr(invalid='ignore')
-            if f in ['arctanh', 'log', 'log10']:
-                numpy.seterr(divide='ignore')
-            ur = uf(*args)
-            mr = mf(*args)
-            numpy.seterr(**olderr)
+            try:
+                if f in f_invalid_ignore:
+                    numpy.seterr(invalid='ignore')
+                if f in ['arctanh', 'log', 'log10']:
+                    numpy.seterr(divide='ignore')
+                ur = uf(*args)
+                mr = mf(*args)
+            finally:
+                numpy.seterr(**olderr)
             self.assertTrue(eq(ur.filled(0), mr.filled(0), f))
             self.assertTrue(eqmask(ur.mask, mr.mask))