Test for math.* exceptional behavior only in verbose mode, so that the

oddball platforms (where, e.g., math.exp(+huge) still fails to raise
OverflowError) don't fail the std test suite when run normally.

2 files changed, 40 insertions, 31 deletions

diff --git a/Lib/test/output/test_math b/Lib/test/output/test_math
index bce7dde..2a98000 100644
--- a/Lib/test/output/test_math
+++ b/Lib/test/output/test_math
@@ -24,4 +24,3 @@ sinh
 sqrt
 tan
 tanh
-exceptions
diff --git a/Lib/test/test_math.py b/Lib/test/test_math.py
index 1452035..b7fde0a 100644
--- a/Lib/test/test_math.py
+++ b/Lib/test/test_math.py
@@ -153,33 +153,43 @@ print 'tanh'
 testit('tanh(0)', math.tanh(0), 0)
 testit('tanh(1)+tanh(-1)', math.tanh(1)+math.tanh(-1), 0)
 
-print 'exceptions'  # oooooh, *this* is a x-platform gamble!  good luck
-
-try:
-    x = math.exp(-1000000000)
-except:
-    # mathmodule.c is failing to weed out underflows from libm, or
-    # we've got an fp format with huge dynamic range
-    raise TestFailed("underflowing exp() should not have rasied an exception")
-if x != 0:
-    raise TestFailed("underflowing exp() should have returned 0")
-
-# If this fails, probably using a strict IEEE-754 conforming libm, and x
-# is +Inf afterwards.  But Python wants overflows detected by default.
-try:
-    x = math.exp(1000000000)
-except OverflowError:
-    pass
-else:
-    raise TestFailed("overflowing exp() didn't trigger OverflowError")
-
-# If this fails, it could be a puzzle.  One odd possibility is that
-# mathmodule.c's CHECK() macro is getting confused while comparing
-# Inf (HUGE_VAL) to a NaN, and artificially setting errno to ERANGE
-# as a result (and so raising OverflowError instead).
-try:
-    x = math.sqrt(-1.0)
-except ValueError:
-    pass
-else:
-    raise TestFailed("sqrt(-1) didn't raise ValueError")
+# RED_FLAG 16-Oct-2000 Tim
+# While 2.0 is more consistent about exceptions than previous releases, it
+# still fails this part of the test on some platforms.  For now, we only
+# *run* test_exceptions() in verbose mode, so that this isn't normally
+# tested.
+
+def test_exceptions():
+    print 'exceptions'
+    try:
+        x = math.exp(-1000000000)
+    except:
+        # mathmodule.c is failing to weed out underflows from libm, or
+        # we've got an fp format with huge dynamic range
+        raise TestFailed("underflowing exp() should not have raised "
+                         "an exception")
+    if x != 0:
+        raise TestFailed("underflowing exp() should have returned 0")
+
+    # If this fails, probably using a strict IEEE-754 conforming libm, and x
+    # is +Inf afterwards.  But Python wants overflows detected by default.
+    try:
+        x = math.exp(1000000000)
+    except OverflowError:
+        pass
+    else:
+        raise TestFailed("overflowing exp() didn't trigger OverflowError")
+
+    # If this fails, it could be a puzzle.  One odd possibility is that
+    # mathmodule.c's CHECK() macro is getting confused while comparing
+    # Inf (HUGE_VAL) to a NaN, and artificially setting errno to ERANGE
+    # as a result (and so raising OverflowError instead).
+    try:
+        x = math.sqrt(-1.0)
+    except ValueError:
+        pass
+    else:
+        raise TestFailed("sqrt(-1) didn't raise ValueError")
+
+if verbose:
+    test_exceptions()