Added a new NORMALIZE_NUMBERS option, which causes number literals in

the expected output to match corresponding number literals in the
actual output if their values are equal (to ten digits of precision).

2 files changed, 180 insertions, 1 deletions

diff --git a/Lib/doctest.py b/Lib/doctest.py
index 26a8914..dfd8bb9 100644
--- a/Lib/doctest.py
+++ b/Lib/doctest.py
@@ -55,6 +55,7 @@ __all__ = [
     'NORMALIZE_WHITESPACE',
     'ELLIPSIS',
     'IGNORE_EXCEPTION_DETAIL',
+    'NORMALIZE_NUMBERS',
     'COMPARISON_FLAGS',
     'REPORT_UDIFF',
     'REPORT_CDIFF',
@@ -139,12 +140,14 @@ DONT_ACCEPT_BLANKLINE = register_optionflag('DONT_ACCEPT_BLANKLINE')
 NORMALIZE_WHITESPACE = register_optionflag('NORMALIZE_WHITESPACE')
 ELLIPSIS = register_optionflag('ELLIPSIS')
 IGNORE_EXCEPTION_DETAIL = register_optionflag('IGNORE_EXCEPTION_DETAIL')
+NORMALIZE_NUMBERS = register_optionflag('NORMALIZE_NUMBERS')
 
 COMPARISON_FLAGS = (DONT_ACCEPT_TRUE_FOR_1 |
                     DONT_ACCEPT_BLANKLINE |
                     NORMALIZE_WHITESPACE |
                     ELLIPSIS |
-                    IGNORE_EXCEPTION_DETAIL)
+                    IGNORE_EXCEPTION_DETAIL |
+                    NORMALIZE_NUMBERS)
 
 REPORT_UDIFF = register_optionflag('REPORT_UDIFF')
 REPORT_CDIFF = register_optionflag('REPORT_CDIFF')
@@ -277,6 +280,72 @@ class _SpoofOut(StringIO):
         if hasattr(self, "softspace"):
             del self.softspace
 
+# The number of digits of precision that must be equal for
+# NORMALIZE_NUMBERS to consider two numbers equal.
+_NORMALIZE_NUMBERS_PRECISION_THRESHOLD = 10
+
+# A regular expression that matches Python number literals.  This is
+# used by _normalize_numbers to look for numbers that should be
+# normalized.
+_NUMBER_LITERAL = re.compile(r'''
+    (\d+[.]\d*(?:[eE][-+]?\d+)?[jJ]? | # float (w/ digits left of ".")
+        [.]\d+(?:[eE][-+]?\d+)?[jJ]? | # float (no digits left of ".")
+     \d+      (?:[eE][-+]?\d+) [jJ]? | # float (no ".", exponent only)
+     \d                        [jJ]  | # float (no ".", imaginary only)
+     0[xX]\d+[lL]?                   | # hexint
+     0[0-7]*[lL]?                    | # octint or zero
+     \d+[lL]?                        ) # decint
+     ''', re.VERBOSE)
+
+def _normalize_numbers(want, got):
+    """
+    If all the numbers in `want` and `got` match (one-for-one), then
+    return a new version of `got` with the exact number strings from
+    `want` spliced in.  Two numbers match if `str` of their float
+    values are equal.  (I.e., `x` matches `y` if
+    `str(float(x))==str(float(y))`).
+    """
+    want_pieces = _NUMBER_LITERAL.split(want)
+    got_pieces = _NUMBER_LITERAL.split(got)
+
+    # If they don't have the same number of numbers, fail immediately.
+    if len(want_pieces) != len(got_pieces):
+        return got
+
+    # If any individual numbers don't match, then fail.
+    for i in range(1, len(got_pieces), 2):
+        w, g = eval(want_pieces[i]), eval(got_pieces[i])
+        if not _numbers_match(w, g):
+            return got
+
+    # Success; replace numbers in got w/ numbers from want.
+    for i in range(1, len(got_pieces), 2):
+        got_pieces[i] = want_pieces[i]
+    return ''.join(got_pieces)
+
+def _numbers_match(x, y):
+    """
+    A helper function for _normalize_numbers, that returns true if the
+    numbers `x` and `y` are close enough to match for NORMALIZE_NUMBERS.
+    """
+    # Equal numbers match.
+    if x == y:
+        return True
+    # Split up complex numbers into real & imag.
+    if isinstance(x, complex):
+        return (isinstance(y, complex) and
+                _numbers_match(x.real, y.real) and
+                _numbers_match(x.imag, y.imag))
+    # If the signs are different, they don't match.
+    if x*y < 0:
+        return False
+    # If one is zero and the other isn't, they don't match.
+    if x==0 or y==0:
+        return False
+    # They're not exactly equal, but are they close enough?
+    threshold = 10**-_NORMALIZE_NUMBERS_PRECISION_THRESHOLD
+    return (abs(x-y) / min(abs(x), abs(y))) < threshold
+
 # Worst-case linear-time ellipsis matching.
 def _ellipsis_match(want, got):
     """
@@ -1503,6 +1572,13 @@ class OutputChecker:
             if got == want:
                 return True
 
+        # This flag causes doctest to treat numbers that are within a
+        # small threshold as if they are equal.
+        if optionflags & NORMALIZE_NUMBERS:
+            got = _normalize_numbers(want, got)
+            if got == want:
+                return True
+
         # The ELLIPSIS flag says to let the sequence "..." in `want`
         # match any substring in `got`.
         if optionflags & ELLIPSIS:
@@ -1783,6 +1859,7 @@ def testmod(m=None, name=None, globs=None, verbose=None, isprivate=None,
         NORMALIZE_WHITESPACE
         ELLIPSIS
         IGNORE_EXCEPTION_DETAIL
+        NORMALIZE_NUMBERS
         REPORT_UDIFF
         REPORT_CDIFF
         REPORT_NDIFF
@@ -1905,6 +1982,7 @@ def testfile(filename, module_relative=True, name=None, package=None,
         NORMALIZE_WHITESPACE
         ELLIPSIS
         IGNORE_EXCEPTION_DETAIL
+        NORMALIZE_NUMBERS
         REPORT_UDIFF
         REPORT_CDIFF
         REPORT_NDIFF
diff --git a/Lib/test/test_doctest.py b/Lib/test/test_doctest.py
index d17ca1a..eb0b10c 100644
--- a/Lib/test/test_doctest.py
+++ b/Lib/test/test_doctest.py
@@ -1032,6 +1032,107 @@ treated as equal:
     [0,   1,  2,  3,  4,  5,  6,  7,  8,  9,
     10,  11, 12, 13, 14, 15, 16, 17, 18, 19]
 
+The NORMALIZE_NUMBERS flag causes numbers that are equal (to
+approximately 10 decimal places) but formatted differently to match.
+
+    >>> def f(x): '''
+    ...     Numbers will match if they are exactly equal:
+    ...
+    ...     >>> print 1.1, 'intervening text', 1L # should match
+    ...     1.1 intervening text 1L
+    ...     >>> print 1.0j, 22, 22.0, 1, 1e1      # should match
+    ...     1j 22.0 22 1 10.0
+    ...
+    ...     Numbers will match if they are equal to 14 digits of
+    ...     precision:
+    ...
+    ...     >>> 2.00000000001                      # should match
+    ...     1.99999999999
+    ...     >>> 2.000000001                        # should not match
+    ...     1.999999999
+    ...     >>> 2.00000000001e10                   # should match
+    ...     1.99999999999e10
+    ...     >>> 2.000000001e10                     # should not match
+    ...     1.999999999e10
+    ...     '''
+
+    >>> # Without the flag:
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> doctest.DocTestRunner(verbose=False).run(test)
+    ... # doctest: +ELLIPSIS
+    **********************************************************************
+    File ..., line 4, in f
+    Failed example:
+        print 1.1, 'intervening text', 1L # should match
+    Expected:
+        1.1 intervening text 1L
+    Got:
+        1.1 intervening text 1
+    **********************************************************************
+    File ..., line 6, in f
+    Failed example:
+        print 1.0j, 22, 22.0, 1, 1e1      # should match
+    Expected:
+        1j 22.0 22 1 10.0
+    Got:
+        1j 22 22.0 1 10.0
+    **********************************************************************
+    File ..., line 12, in f
+    Failed example:
+        2.00000000001                      # should match
+    Expected:
+        1.99999999999
+    Got:
+        2.00000000001
+    **********************************************************************
+    File ..., line 14, in f
+    Failed example:
+        2.000000001                        # should not match
+    Expected:
+        1.999999999
+    Got:
+        2.0000000010000001
+    **********************************************************************
+    File ..., line 16, in f
+    Failed example:
+        2.00000000001e10                   # should match
+    Expected:
+        1.99999999999e10
+    Got:
+        20000000000.099998
+    **********************************************************************
+    File ..., line 18, in f
+    Failed example:
+        2.000000001e10                     # should not match
+    Expected:
+        1.999999999e10
+    Got:
+        20000000010.0
+    (6, 6)
+
+    >>> # With the flag:
+    >>> test = doctest.DocTestFinder().find(f)[0]
+    >>> flags = doctest.NORMALIZE_NUMBERS
+    >>> doctest.DocTestRunner(verbose=False, optionflags=flags).run(test)
+    ... # doctest: +ELLIPSIS
+    **********************************************************************
+    File ..., line 14, in f
+    Failed example:
+        2.000000001                        # should not match
+    Expected:
+        1.999999999
+    Got:
+        2.0000000010000001
+    **********************************************************************
+    File ..., line 18, in f
+    Failed example:
+        2.000000001e10                     # should not match
+    Expected:
+        1.999999999e10
+    Got:
+        20000000010.0
+    (2, 6)
+
 The ELLIPSIS flag causes ellipsis marker ("...") in the expected
 output to match any substring in the actual output: