[Python-checkins] cpython (merge 3.2 -> default): (merge 3.2) Issue #12400: runtest() reuses the same io.StringIO instance for

[victor.stinner]

http://hg.python.org/cpython/rev/8897c755633b
changeset:   71069:8897c755633b
parent:      71067:c0afc8d00c0a
parent:      71068:6c54c334ea7a
user:        Victor Stinner <victor.stinner at haypocalc.com>
date:        Wed Jun 29 15:25:40 2011 +0200
summary:
  (merge 3.2) Issue #12400: runtest() reuses the same io.StringIO instance for
all calls

 * Don't force verbose to True with option -W
 * Rename rerun_failed variable to output_on_failure

files:
  Lib/test/regrtest.py |  58 ++++++++++++++++++-------------
  1 files changed, 34 insertions(+), 24 deletions(-)


diff --git a/Lib/test/regrtest.py b/Lib/test/regrtest.py
--- a/Lib/test/regrtest.py
+++ b/Lib/test/regrtest.py
@@ -162,23 +162,24 @@
 """
 
 import builtins
+import errno
 import faulthandler
 import getopt
+import io
 import json
+import logging
 import os
+import platform
 import random
 import re
 import sys
+import sysconfig
+import tempfile
 import time
-import errno
 import traceback
+import unittest
 import warnings
-import unittest
 from inspect import isabstract
-import tempfile
-import platform
-import sysconfig
-import logging
 
 
 # Some times __path__ and __file__ are not absolute (e.g. while running from
@@ -579,7 +580,8 @@
                 args_tuple = (
                     (test, verbose, quiet),
                     dict(huntrleaks=huntrleaks, use_resources=use_resources,
-                         debug=debug, rerun_failed=verbose3, timeout=timeout)
+                         debug=debug, output_on_failure=verbose3,
+                         timeout=timeout)
                 )
                 yield (test, args_tuple)
         pending = tests_and_args()
@@ -664,7 +666,7 @@
             else:
                 try:
                     result = runtest(test, verbose, quiet, huntrleaks, debug,
-                                     rerun_failed=verbose3, timeout=timeout)
+                                     output_on_failure=verbose3, timeout=timeout)
                     accumulate_result(test, result)
                 except KeyboardInterrupt:
                     interrupted = True
@@ -808,7 +810,7 @@
 
 def runtest(test, verbose, quiet,
             huntrleaks=False, debug=False, use_resources=None,
-            rerun_failed=False, timeout=None):
+            output_on_failure=False, timeout=None):
     """Run a single test.
 
     test -- the name of the test
@@ -817,7 +819,7 @@
     test_times -- a list of (time, test_name) pairs
     huntrleaks -- run multiple times to test for leaks; requires a debug
                   build; a triple corresponding to -R's three arguments
-    rerun_failed -- if true, re-run in verbose mode when failed
+    output_on_failure -- if true, display test output on failure
     timeout -- dump the traceback and exit if a test takes more than
                timeout seconds
 
@@ -836,22 +838,29 @@
     if use_timeout:
         faulthandler.dump_tracebacks_later(timeout, exit=True)
     try:
-        if rerun_failed:
-            support.verbose = True
+        support.verbose = verbose  # Tell tests to be moderately quiet
+        if output_on_failure:
+            if runtest.stringio is None:
+                # Reuse the same instance to all calls to runtest(). Some
+                # tests keep a reference to sys.stdout or sys.stderr
+                # (eg. test_argparse).
+                runtest.stringio = io.StringIO()
+
+            orig_stdout = sys.stdout
             orig_stderr = sys.stderr
-            with support.captured_stdout() as stream:
-                try:
-                    sys.stderr = stream
-                    result = runtest_inner(test, verbose, quiet, huntrleaks,
-                                           debug, display_failure=False)
-                    if result[0] == FAILED:
-                        output = stream.getvalue()
-                        orig_stderr.write(output)
-                        orig_stderr.flush()
-                finally:
-                    sys.stderr = orig_stderr
+            try:
+                sys.stdout = runtest.stringio
+                sys.stderr = runtest.stringio
+                result = runtest_inner(test, verbose, quiet, huntrleaks,
+                                       debug, display_failure=False)
+                if result[0] == FAILED:
+                    output = stringio.getvalue()
+                    orig_stderr.write(output)
+                    orig_stderr.flush()
+            finally:
+                sys.stdout = orig_stdout
+                sys.stderr = orig_stderr
         else:
-            support.verbose = verbose  # Tell tests to be moderately quiet
             result = runtest_inner(test, verbose, quiet, huntrleaks, debug,
                                    display_failure=not verbose)
         return result
@@ -859,6 +868,7 @@
         if use_timeout:
             faulthandler.cancel_dump_tracebacks_later()
         cleanup_test_droppings(test, verbose)
+runtest.stringio = None
 
 # Unit tests are supposed to leave the execution environment unchanged
 # once they complete.  But sometimes tests have bugs, especially when

-- 
Repository URL: http://hg.python.org/cpython