Restoring authorship annotation for <shadchin@yandex-team.ru>. Commit 2 of 2.

1 files changed, 491 insertions, 491 deletions

diff --git a/contrib/python/ipython/py3/IPython/testing/iptestcontroller.py b/contrib/python/ipython/py3/IPython/testing/iptestcontroller.py
index 0ca4647e5f..b522f60f37 100644
--- a/contrib/python/ipython/py3/IPython/testing/iptestcontroller.py
+++ b/contrib/python/ipython/py3/IPython/testing/iptestcontroller.py
@@ -1,491 +1,491 @@
-# -*- coding: utf-8 -*- 
-"""IPython Test Process Controller 
- 
-This module runs one or more subprocesses which will actually run the IPython 
-test suite. 
- 
-""" 
- 
-# Copyright (c) IPython Development Team. 
-# Distributed under the terms of the Modified BSD License. 
- 
- 
-import argparse 
-import multiprocessing.pool 
-import os 
-import stat 
-import shutil 
-import signal 
-import sys 
-import subprocess 
-import time 
- 
-from .iptest import ( 
-    have, test_group_names as py_test_group_names, test_sections, StreamCapturer, 
-) 
-from IPython.utils.path import compress_user 
-from IPython.utils.py3compat import decode 
-from IPython.utils.sysinfo import get_sys_info 
-from IPython.utils.tempdir import TemporaryDirectory 
- 
-class TestController: 
-    """Run tests in a subprocess 
-    """ 
-    #: str, IPython test suite to be executed. 
-    section = None 
-    #: list, command line arguments to be executed 
-    cmd = None 
-    #: dict, extra environment variables to set for the subprocess 
-    env = None 
-    #: list, TemporaryDirectory instances to clear up when the process finishes 
-    dirs = None 
-    #: subprocess.Popen instance 
-    process = None 
-    #: str, process stdout+stderr 
-    stdout = None 
- 
-    def __init__(self): 
-        self.cmd = [] 
-        self.env = {} 
-        self.dirs = [] 
- 
-    def setUp(self): 
-        """Create temporary directories etc. 
-         
-        This is only called when we know the test group will be run. Things 
-        created here may be cleaned up by self.cleanup(). 
-        """ 
-        pass 
- 
-    def launch(self, buffer_output=False, capture_output=False): 
-        # print('*** ENV:', self.env)  # dbg 
-        # print('*** CMD:', self.cmd)  # dbg 
-        env = os.environ.copy() 
-        env.update(self.env) 
-        if buffer_output: 
-            capture_output = True 
-        self.stdout_capturer = c = StreamCapturer(echo=not buffer_output) 
-        c.start() 
-        stdout = c.writefd if capture_output else None 
-        stderr = subprocess.STDOUT if capture_output else None 
-        self.process = subprocess.Popen(self.cmd, stdout=stdout, 
-                stderr=stderr, env=env) 
- 
-    def wait(self): 
-        self.process.wait() 
-        self.stdout_capturer.halt() 
-        self.stdout = self.stdout_capturer.get_buffer() 
-        return self.process.returncode 
- 
-    def cleanup_process(self): 
-        """Cleanup on exit by killing any leftover processes.""" 
-        subp = self.process 
-        if subp is None or (subp.poll() is not None): 
-            return  # Process doesn't exist, or is already dead. 
- 
-        try: 
-            print('Cleaning up stale PID: %d' % subp.pid) 
-            subp.kill() 
-        except: # (OSError, WindowsError) ? 
-            # This is just a best effort, if we fail or the process was 
-            # really gone, ignore it. 
-            pass 
-        else: 
-            for i in range(10): 
-                if subp.poll() is None: 
-                    time.sleep(0.1) 
-                else: 
-                    break 
- 
-        if subp.poll() is None: 
-            # The process did not die... 
-            print('... failed. Manual cleanup may be required.') 
- 
-    def cleanup(self): 
-        "Kill process if it's still alive, and clean up temporary directories" 
-        self.cleanup_process() 
-        for td in self.dirs: 
-            td.cleanup() 
- 
-    __del__ = cleanup 
- 
- 
-class PyTestController(TestController): 
-    """Run Python tests using IPython.testing.iptest""" 
-    #: str, Python command to execute in subprocess 
-    pycmd = None 
- 
-    def __init__(self, section, options): 
-        """Create new test runner.""" 
-        TestController.__init__(self) 
-        self.section = section 
-        # pycmd is put into cmd[2] in PyTestController.launch() 
-        self.cmd = [sys.executable, '-c', None, section] 
-        self.pycmd = "from IPython.testing.iptest import run_iptest; run_iptest()" 
-        self.options = options 
- 
-    def setup(self): 
-        ipydir = TemporaryDirectory() 
-        self.dirs.append(ipydir) 
-        self.env['IPYTHONDIR'] = ipydir.name 
-        self.workingdir = workingdir = TemporaryDirectory() 
-        self.dirs.append(workingdir) 
-        self.env['IPTEST_WORKING_DIR'] = workingdir.name 
-        # This means we won't get odd effects from our own matplotlib config 
-        self.env['MPLCONFIGDIR'] = workingdir.name 
-        # For security reasons (http://bugs.python.org/issue16202), use 
-        # a temporary directory to which other users have no access. 
-        self.env['TMPDIR'] = workingdir.name 
- 
-        # Add a non-accessible directory to PATH (see gh-7053) 
-        noaccess = os.path.join(self.workingdir.name, "_no_access_") 
-        self.noaccess = noaccess 
-        os.mkdir(noaccess, 0) 
- 
-        PATH = os.environ.get('PATH', '') 
-        if PATH: 
-            PATH = noaccess + os.pathsep + PATH 
-        else: 
-            PATH = noaccess 
-        self.env['PATH'] = PATH 
- 
-        # From options: 
-        if self.options.xunit: 
-            self.add_xunit() 
-        if self.options.coverage: 
-            self.add_coverage() 
-        self.env['IPTEST_SUBPROC_STREAMS'] = self.options.subproc_streams 
-        self.cmd.extend(self.options.extra_args) 
- 
-    def cleanup(self): 
-        """ 
-        Make the non-accessible directory created in setup() accessible 
-        again, otherwise deleting the workingdir will fail. 
-        """ 
-        os.chmod(self.noaccess, stat.S_IRWXU) 
-        TestController.cleanup(self) 
- 
-    @property 
-    def will_run(self): 
-        try: 
-            return test_sections[self.section].will_run 
-        except KeyError: 
-            return True 
- 
-    def add_xunit(self): 
-        xunit_file = os.path.abspath(self.section + '.xunit.xml') 
-        self.cmd.extend(['--with-xunit', '--xunit-file', xunit_file]) 
- 
-    def add_coverage(self): 
-        try: 
-            sources = test_sections[self.section].includes 
-        except KeyError: 
-            sources = ['IPython'] 
- 
-        coverage_rc = ("[run]\n" 
-                       "data_file = {data_file}\n" 
-                       "source =\n" 
-                       "  {source}\n" 
-                      ).format(data_file=os.path.abspath('.coverage.'+self.section), 
-                               source="\n  ".join(sources)) 
-        config_file = os.path.join(self.workingdir.name, '.coveragerc') 
-        with open(config_file, 'w') as f: 
-            f.write(coverage_rc) 
- 
-        self.env['COVERAGE_PROCESS_START'] = config_file 
-        self.pycmd = "import coverage; coverage.process_startup(); " + self.pycmd 
- 
-    def launch(self, buffer_output=False): 
-        self.cmd[2] = self.pycmd 
-        super(PyTestController, self).launch(buffer_output=buffer_output) 
- 
- 
-def prepare_controllers(options): 
-    """Returns two lists of TestController instances, those to run, and those 
-    not to run.""" 
-    testgroups = options.testgroups 
-    if not testgroups: 
-        testgroups = py_test_group_names 
- 
-    controllers = [PyTestController(name, options) for name in testgroups] 
- 
-    to_run = [c for c in controllers if c.will_run] 
-    not_run = [c for c in controllers if not c.will_run] 
-    return to_run, not_run 
- 
-def do_run(controller, buffer_output=True): 
-    """Setup and run a test controller. 
-     
-    If buffer_output is True, no output is displayed, to avoid it appearing 
-    interleaved. In this case, the caller is responsible for displaying test 
-    output on failure. 
-     
-    Returns 
-    ------- 
-    controller : TestController 
-      The same controller as passed in, as a convenience for using map() type 
-      APIs. 
-    exitcode : int 
-      The exit code of the test subprocess. Non-zero indicates failure. 
-    """ 
-    try: 
-        try: 
-            controller.setup() 
-            controller.launch(buffer_output=buffer_output) 
-        except Exception: 
-            import traceback 
-            traceback.print_exc() 
-            return controller, 1  # signal failure 
- 
-        exitcode = controller.wait() 
-        return controller, exitcode 
- 
-    except KeyboardInterrupt: 
-        return controller, -signal.SIGINT 
-    finally: 
-        controller.cleanup() 
- 
-def report(): 
-    """Return a string with a summary report of test-related variables.""" 
-    inf = get_sys_info() 
-    out = [] 
-    def _add(name, value): 
-        out.append((name, value)) 
- 
-    _add('IPython version', inf['ipython_version']) 
-    _add('IPython commit', "{} ({})".format(inf['commit_hash'], inf['commit_source'])) 
-    _add('IPython package', compress_user(inf['ipython_path'])) 
-    _add('Python version', inf['sys_version'].replace('\n','')) 
-    _add('sys.executable', compress_user(inf['sys_executable'])) 
-    _add('Platform', inf['platform']) 
- 
-    width = max(len(n) for (n,v) in out) 
-    out = ["{:<{width}}: {}\n".format(n, v, width=width) for (n,v) in out] 
- 
-    avail = [] 
-    not_avail = [] 
- 
-    for k, is_avail in have.items(): 
-        if is_avail: 
-            avail.append(k) 
-        else: 
-            not_avail.append(k) 
- 
-    if avail: 
-        out.append('\nTools and libraries available at test time:\n') 
-        avail.sort() 
-        out.append('   ' + ' '.join(avail)+'\n') 
- 
-    if not_avail: 
-        out.append('\nTools and libraries NOT available at test time:\n') 
-        not_avail.sort() 
-        out.append('   ' + ' '.join(not_avail)+'\n') 
- 
-    return ''.join(out) 
- 
-def run_iptestall(options): 
-    """Run the entire IPython test suite by calling nose and trial. 
- 
-    This function constructs :class:`IPTester` instances for all IPython 
-    modules and package and then runs each of them.  This causes the modules 
-    and packages of IPython to be tested each in their own subprocess using 
-    nose. 
- 
-    Parameters 
-    ---------- 
- 
-    All parameters are passed as attributes of the options object. 
- 
-    testgroups : list of str 
-      Run only these sections of the test suite. If empty, run all the available 
-      sections. 
- 
-    fast : int or None 
-      Run the test suite in parallel, using n simultaneous processes. If None 
-      is passed, one process is used per CPU core. Default 1 (i.e. sequential) 
- 
-    inc_slow : bool 
-      Include slow tests. By default, these tests aren't run. 
- 
-    url : unicode 
-      Address:port to use when running the JS tests. 
- 
-    xunit : bool 
-      Produce Xunit XML output. This is written to multiple foo.xunit.xml files. 
- 
-    coverage : bool or str 
-      Measure code coverage from tests. True will store the raw coverage data, 
-      or pass 'html' or 'xml' to get reports. 
- 
-    extra_args : list 
-      Extra arguments to pass to the test subprocesses, e.g. '-v' 
-    """ 
-    to_run, not_run = prepare_controllers(options) 
- 
-    def justify(ltext, rtext, width=70, fill='-'): 
-        ltext += ' ' 
-        rtext = (' ' + rtext).rjust(width - len(ltext), fill) 
-        return ltext + rtext 
- 
-    # Run all test runners, tracking execution time 
-    failed = [] 
-    t_start = time.time() 
- 
-    print() 
-    if options.fast == 1: 
-        # This actually means sequential, i.e. with 1 job 
-        for controller in to_run: 
-            print('Test group:', controller.section) 
-            sys.stdout.flush()  # Show in correct order when output is piped 
-            controller, res = do_run(controller, buffer_output=False) 
-            if res: 
-                failed.append(controller) 
-                if res == -signal.SIGINT: 
-                    print("Interrupted") 
-                    break 
-            print() 
- 
-    else: 
-        # Run tests concurrently 
-        try: 
-            pool = multiprocessing.pool.ThreadPool(options.fast) 
-            for (controller, res) in pool.imap_unordered(do_run, to_run): 
-                res_string = 'OK' if res == 0 else 'FAILED' 
-                print(justify('Test group: ' + controller.section, res_string)) 
-                if res: 
-                    print(decode(controller.stdout)) 
-                    failed.append(controller) 
-                    if res == -signal.SIGINT: 
-                        print("Interrupted") 
-                        break 
-        except KeyboardInterrupt: 
-            return 
- 
-    for controller in not_run: 
-        print(justify('Test group: ' + controller.section, 'NOT RUN')) 
- 
-    t_end = time.time() 
-    t_tests = t_end - t_start 
-    nrunners = len(to_run) 
-    nfail = len(failed) 
-    # summarize results 
-    print('_'*70) 
-    print('Test suite completed for system with the following information:') 
-    print(report()) 
-    took = "Took %.3fs." % t_tests 
-    print('Status: ', end='') 
-    if not failed: 
-        print('OK (%d test groups).' % nrunners, took) 
-    else: 
-        # If anything went wrong, point out what command to rerun manually to 
-        # see the actual errors and individual summary 
-        failed_sections = [c.section for c in failed] 
-        print('ERROR - {} out of {} test groups failed ({}).'.format(nfail, 
-                                  nrunners, ', '.join(failed_sections)), took) 
-        print() 
-        print('You may wish to rerun these, with:') 
-        print('  iptest', *failed_sections) 
-        print() 
- 
-    if options.coverage: 
-        from coverage import coverage, CoverageException 
-        cov = coverage(data_file='.coverage') 
-        cov.combine() 
-        cov.save() 
- 
-        # Coverage HTML report 
-        if options.coverage == 'html': 
-            html_dir = 'ipy_htmlcov' 
-            shutil.rmtree(html_dir, ignore_errors=True) 
-            print("Writing HTML coverage report to %s/ ... " % html_dir, end="") 
-            sys.stdout.flush() 
- 
-            # Custom HTML reporter to clean up module names. 
-            from coverage.html import HtmlReporter 
-            class CustomHtmlReporter(HtmlReporter): 
-                def find_code_units(self, morfs): 
-                    super(CustomHtmlReporter, self).find_code_units(morfs) 
-                    for cu in self.code_units: 
-                        nameparts = cu.name.split(os.sep) 
-                        if 'IPython' not in nameparts: 
-                            continue 
-                        ix = nameparts.index('IPython') 
-                        cu.name = '.'.join(nameparts[ix:]) 
- 
-            # Reimplement the html_report method with our custom reporter 
-            cov.get_data() 
-            cov.config.from_args(omit='*{0}tests{0}*'.format(os.sep), html_dir=html_dir, 
-                                 html_title='IPython test coverage', 
-                                ) 
-            reporter = CustomHtmlReporter(cov, cov.config) 
-            reporter.report(None) 
-            print('done.') 
- 
-        # Coverage XML report 
-        elif options.coverage == 'xml': 
-            try: 
-                cov.xml_report(outfile='ipy_coverage.xml') 
-            except CoverageException as e: 
-                print('Generating coverage report failed. Are you running javascript tests only?') 
-                import traceback 
-                traceback.print_exc() 
- 
-    if failed: 
-        # Ensure that our exit code indicates failure 
-        sys.exit(1) 
- 
-argparser = argparse.ArgumentParser(description='Run IPython test suite') 
-argparser.add_argument('testgroups', nargs='*', 
-                    help='Run specified groups of tests. If omitted, run ' 
-                    'all tests.') 
-argparser.add_argument('--all', action='store_true', 
-                    help='Include slow tests not run by default.') 
-argparser.add_argument('-j', '--fast', nargs='?', const=None, default=1, type=int, 
-                    help='Run test sections in parallel. This starts as many ' 
-                    'processes as you have cores, or you can specify a number.') 
-argparser.add_argument('--xunit', action='store_true', 
-                    help='Produce Xunit XML results') 
-argparser.add_argument('--coverage', nargs='?', const=True, default=False, 
-                    help="Measure test coverage. Specify 'html' or " 
-                    "'xml' to get reports.") 
-argparser.add_argument('--subproc-streams', default='capture', 
-                    help="What to do with stdout/stderr from subprocesses. " 
-                    "'capture' (default), 'show' and 'discard' are the options.") 
- 
-def default_options(): 
-    """Get an argparse Namespace object with the default arguments, to pass to 
-    :func:`run_iptestall`. 
-    """ 
-    options = argparser.parse_args([]) 
-    options.extra_args = [] 
-    return options 
- 
-def main(): 
-    # iptest doesn't work correctly if the working directory is the 
-    # root of the IPython source tree. Tell the user to avoid 
-    # frustration. 
-    if os.path.exists(os.path.join(os.getcwd(), 
-                                   'IPython', 'testing', '__main__.py')): 
-        print("Don't run iptest from the IPython source directory", 
-              file=sys.stderr) 
-        sys.exit(1) 
-    # Arguments after -- should be passed through to nose. Argparse treats 
-    # everything after -- as regular positional arguments, so we separate them 
-    # first. 
-    try: 
-        ix = sys.argv.index('--') 
-    except ValueError: 
-        to_parse = sys.argv[1:] 
-        extra_args = [] 
-    else: 
-        to_parse = sys.argv[1:ix] 
-        extra_args = sys.argv[ix+1:] 
- 
-    options = argparser.parse_args(to_parse) 
-    options.extra_args = extra_args 
- 
-    run_iptestall(options) 
- 
- 
-if __name__ == '__main__': 
-    main() 
+# -*- coding: utf-8 -*-
+"""IPython Test Process Controller
+
+This module runs one or more subprocesses which will actually run the IPython
+test suite.
+
+"""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+
+import argparse
+import multiprocessing.pool
+import os
+import stat
+import shutil
+import signal
+import sys
+import subprocess
+import time
+
+from .iptest import (
+    have, test_group_names as py_test_group_names, test_sections, StreamCapturer,
+)
+from IPython.utils.path import compress_user
+from IPython.utils.py3compat import decode
+from IPython.utils.sysinfo import get_sys_info
+from IPython.utils.tempdir import TemporaryDirectory
+
+class TestController:
+    """Run tests in a subprocess
+    """
+    #: str, IPython test suite to be executed.
+    section = None
+    #: list, command line arguments to be executed
+    cmd = None
+    #: dict, extra environment variables to set for the subprocess
+    env = None
+    #: list, TemporaryDirectory instances to clear up when the process finishes
+    dirs = None
+    #: subprocess.Popen instance
+    process = None
+    #: str, process stdout+stderr
+    stdout = None
+
+    def __init__(self):
+        self.cmd = []
+        self.env = {}
+        self.dirs = []
+
+    def setUp(self):
+        """Create temporary directories etc.
+        
+        This is only called when we know the test group will be run. Things
+        created here may be cleaned up by self.cleanup().
+        """
+        pass
+
+    def launch(self, buffer_output=False, capture_output=False):
+        # print('*** ENV:', self.env)  # dbg
+        # print('*** CMD:', self.cmd)  # dbg
+        env = os.environ.copy()
+        env.update(self.env)
+        if buffer_output:
+            capture_output = True
+        self.stdout_capturer = c = StreamCapturer(echo=not buffer_output)
+        c.start()
+        stdout = c.writefd if capture_output else None
+        stderr = subprocess.STDOUT if capture_output else None
+        self.process = subprocess.Popen(self.cmd, stdout=stdout,
+                stderr=stderr, env=env)
+
+    def wait(self):
+        self.process.wait()
+        self.stdout_capturer.halt()
+        self.stdout = self.stdout_capturer.get_buffer()
+        return self.process.returncode
+
+    def cleanup_process(self):
+        """Cleanup on exit by killing any leftover processes."""
+        subp = self.process
+        if subp is None or (subp.poll() is not None):
+            return  # Process doesn't exist, or is already dead.
+
+        try:
+            print('Cleaning up stale PID: %d' % subp.pid)
+            subp.kill()
+        except: # (OSError, WindowsError) ?
+            # This is just a best effort, if we fail or the process was
+            # really gone, ignore it.
+            pass
+        else:
+            for i in range(10):
+                if subp.poll() is None:
+                    time.sleep(0.1)
+                else:
+                    break
+
+        if subp.poll() is None:
+            # The process did not die...
+            print('... failed. Manual cleanup may be required.')
+
+    def cleanup(self):
+        "Kill process if it's still alive, and clean up temporary directories"
+        self.cleanup_process()
+        for td in self.dirs:
+            td.cleanup()
+
+    __del__ = cleanup
+
+
+class PyTestController(TestController):
+    """Run Python tests using IPython.testing.iptest"""
+    #: str, Python command to execute in subprocess
+    pycmd = None
+
+    def __init__(self, section, options):
+        """Create new test runner."""
+        TestController.__init__(self)
+        self.section = section
+        # pycmd is put into cmd[2] in PyTestController.launch()
+        self.cmd = [sys.executable, '-c', None, section]
+        self.pycmd = "from IPython.testing.iptest import run_iptest; run_iptest()"
+        self.options = options
+
+    def setup(self):
+        ipydir = TemporaryDirectory()
+        self.dirs.append(ipydir)
+        self.env['IPYTHONDIR'] = ipydir.name
+        self.workingdir = workingdir = TemporaryDirectory()
+        self.dirs.append(workingdir)
+        self.env['IPTEST_WORKING_DIR'] = workingdir.name
+        # This means we won't get odd effects from our own matplotlib config
+        self.env['MPLCONFIGDIR'] = workingdir.name
+        # For security reasons (http://bugs.python.org/issue16202), use
+        # a temporary directory to which other users have no access.
+        self.env['TMPDIR'] = workingdir.name
+
+        # Add a non-accessible directory to PATH (see gh-7053)
+        noaccess = os.path.join(self.workingdir.name, "_no_access_")
+        self.noaccess = noaccess
+        os.mkdir(noaccess, 0)
+
+        PATH = os.environ.get('PATH', '')
+        if PATH:
+            PATH = noaccess + os.pathsep + PATH
+        else:
+            PATH = noaccess
+        self.env['PATH'] = PATH
+
+        # From options:
+        if self.options.xunit:
+            self.add_xunit()
+        if self.options.coverage:
+            self.add_coverage()
+        self.env['IPTEST_SUBPROC_STREAMS'] = self.options.subproc_streams
+        self.cmd.extend(self.options.extra_args)
+
+    def cleanup(self):
+        """
+        Make the non-accessible directory created in setup() accessible
+        again, otherwise deleting the workingdir will fail.
+        """
+        os.chmod(self.noaccess, stat.S_IRWXU)
+        TestController.cleanup(self)
+
+    @property
+    def will_run(self):
+        try:
+            return test_sections[self.section].will_run
+        except KeyError:
+            return True
+
+    def add_xunit(self):
+        xunit_file = os.path.abspath(self.section + '.xunit.xml')
+        self.cmd.extend(['--with-xunit', '--xunit-file', xunit_file])
+
+    def add_coverage(self):
+        try:
+            sources = test_sections[self.section].includes
+        except KeyError:
+            sources = ['IPython']
+
+        coverage_rc = ("[run]\n"
+                       "data_file = {data_file}\n"
+                       "source =\n"
+                       "  {source}\n"
+                      ).format(data_file=os.path.abspath('.coverage.'+self.section),
+                               source="\n  ".join(sources))
+        config_file = os.path.join(self.workingdir.name, '.coveragerc')
+        with open(config_file, 'w') as f:
+            f.write(coverage_rc)
+
+        self.env['COVERAGE_PROCESS_START'] = config_file
+        self.pycmd = "import coverage; coverage.process_startup(); " + self.pycmd
+
+    def launch(self, buffer_output=False):
+        self.cmd[2] = self.pycmd
+        super(PyTestController, self).launch(buffer_output=buffer_output)
+
+
+def prepare_controllers(options):
+    """Returns two lists of TestController instances, those to run, and those
+    not to run."""
+    testgroups = options.testgroups
+    if not testgroups:
+        testgroups = py_test_group_names
+
+    controllers = [PyTestController(name, options) for name in testgroups]
+
+    to_run = [c for c in controllers if c.will_run]
+    not_run = [c for c in controllers if not c.will_run]
+    return to_run, not_run
+
+def do_run(controller, buffer_output=True):
+    """Setup and run a test controller.
+    
+    If buffer_output is True, no output is displayed, to avoid it appearing
+    interleaved. In this case, the caller is responsible for displaying test
+    output on failure.
+    
+    Returns
+    -------
+    controller : TestController
+      The same controller as passed in, as a convenience for using map() type
+      APIs.
+    exitcode : int
+      The exit code of the test subprocess. Non-zero indicates failure.
+    """
+    try:
+        try:
+            controller.setup()
+            controller.launch(buffer_output=buffer_output)
+        except Exception:
+            import traceback
+            traceback.print_exc()
+            return controller, 1  # signal failure
+
+        exitcode = controller.wait()
+        return controller, exitcode
+
+    except KeyboardInterrupt:
+        return controller, -signal.SIGINT
+    finally:
+        controller.cleanup()
+
+def report():
+    """Return a string with a summary report of test-related variables."""
+    inf = get_sys_info()
+    out = []
+    def _add(name, value):
+        out.append((name, value))
+
+    _add('IPython version', inf['ipython_version'])
+    _add('IPython commit', "{} ({})".format(inf['commit_hash'], inf['commit_source']))
+    _add('IPython package', compress_user(inf['ipython_path']))
+    _add('Python version', inf['sys_version'].replace('\n',''))
+    _add('sys.executable', compress_user(inf['sys_executable']))
+    _add('Platform', inf['platform'])
+
+    width = max(len(n) for (n,v) in out)
+    out = ["{:<{width}}: {}\n".format(n, v, width=width) for (n,v) in out]
+
+    avail = []
+    not_avail = []
+
+    for k, is_avail in have.items():
+        if is_avail:
+            avail.append(k)
+        else:
+            not_avail.append(k)
+
+    if avail:
+        out.append('\nTools and libraries available at test time:\n')
+        avail.sort()
+        out.append('   ' + ' '.join(avail)+'\n')
+
+    if not_avail:
+        out.append('\nTools and libraries NOT available at test time:\n')
+        not_avail.sort()
+        out.append('   ' + ' '.join(not_avail)+'\n')
+
+    return ''.join(out)
+
+def run_iptestall(options):
+    """Run the entire IPython test suite by calling nose and trial.
+
+    This function constructs :class:`IPTester` instances for all IPython
+    modules and package and then runs each of them.  This causes the modules
+    and packages of IPython to be tested each in their own subprocess using
+    nose.
+
+    Parameters
+    ----------
+
+    All parameters are passed as attributes of the options object.
+
+    testgroups : list of str
+      Run only these sections of the test suite. If empty, run all the available
+      sections.
+
+    fast : int or None
+      Run the test suite in parallel, using n simultaneous processes. If None
+      is passed, one process is used per CPU core. Default 1 (i.e. sequential)
+
+    inc_slow : bool
+      Include slow tests. By default, these tests aren't run.
+
+    url : unicode
+      Address:port to use when running the JS tests.
+
+    xunit : bool
+      Produce Xunit XML output. This is written to multiple foo.xunit.xml files.
+
+    coverage : bool or str
+      Measure code coverage from tests. True will store the raw coverage data,
+      or pass 'html' or 'xml' to get reports.
+
+    extra_args : list
+      Extra arguments to pass to the test subprocesses, e.g. '-v'
+    """
+    to_run, not_run = prepare_controllers(options)
+
+    def justify(ltext, rtext, width=70, fill='-'):
+        ltext += ' '
+        rtext = (' ' + rtext).rjust(width - len(ltext), fill)
+        return ltext + rtext
+
+    # Run all test runners, tracking execution time
+    failed = []
+    t_start = time.time()
+
+    print()
+    if options.fast == 1:
+        # This actually means sequential, i.e. with 1 job
+        for controller in to_run:
+            print('Test group:', controller.section)
+            sys.stdout.flush()  # Show in correct order when output is piped
+            controller, res = do_run(controller, buffer_output=False)
+            if res:
+                failed.append(controller)
+                if res == -signal.SIGINT:
+                    print("Interrupted")
+                    break
+            print()
+
+    else:
+        # Run tests concurrently
+        try:
+            pool = multiprocessing.pool.ThreadPool(options.fast)
+            for (controller, res) in pool.imap_unordered(do_run, to_run):
+                res_string = 'OK' if res == 0 else 'FAILED'
+                print(justify('Test group: ' + controller.section, res_string))
+                if res:
+                    print(decode(controller.stdout))
+                    failed.append(controller)
+                    if res == -signal.SIGINT:
+                        print("Interrupted")
+                        break
+        except KeyboardInterrupt:
+            return
+
+    for controller in not_run:
+        print(justify('Test group: ' + controller.section, 'NOT RUN'))
+
+    t_end = time.time()
+    t_tests = t_end - t_start
+    nrunners = len(to_run)
+    nfail = len(failed)
+    # summarize results
+    print('_'*70)
+    print('Test suite completed for system with the following information:')
+    print(report())
+    took = "Took %.3fs." % t_tests
+    print('Status: ', end='')
+    if not failed:
+        print('OK (%d test groups).' % nrunners, took)
+    else:
+        # If anything went wrong, point out what command to rerun manually to
+        # see the actual errors and individual summary
+        failed_sections = [c.section for c in failed]
+        print('ERROR - {} out of {} test groups failed ({}).'.format(nfail,
+                                  nrunners, ', '.join(failed_sections)), took)
+        print()
+        print('You may wish to rerun these, with:')
+        print('  iptest', *failed_sections)
+        print()
+
+    if options.coverage:
+        from coverage import coverage, CoverageException
+        cov = coverage(data_file='.coverage')
+        cov.combine()
+        cov.save()
+
+        # Coverage HTML report
+        if options.coverage == 'html':
+            html_dir = 'ipy_htmlcov'
+            shutil.rmtree(html_dir, ignore_errors=True)
+            print("Writing HTML coverage report to %s/ ... " % html_dir, end="")
+            sys.stdout.flush()
+
+            # Custom HTML reporter to clean up module names.
+            from coverage.html import HtmlReporter
+            class CustomHtmlReporter(HtmlReporter):
+                def find_code_units(self, morfs):
+                    super(CustomHtmlReporter, self).find_code_units(morfs)
+                    for cu in self.code_units:
+                        nameparts = cu.name.split(os.sep)
+                        if 'IPython' not in nameparts:
+                            continue
+                        ix = nameparts.index('IPython')
+                        cu.name = '.'.join(nameparts[ix:])
+
+            # Reimplement the html_report method with our custom reporter
+            cov.get_data()
+            cov.config.from_args(omit='*{0}tests{0}*'.format(os.sep), html_dir=html_dir,
+                                 html_title='IPython test coverage',
+                                )
+            reporter = CustomHtmlReporter(cov, cov.config)
+            reporter.report(None)
+            print('done.')
+
+        # Coverage XML report
+        elif options.coverage == 'xml':
+            try:
+                cov.xml_report(outfile='ipy_coverage.xml')
+            except CoverageException as e:
+                print('Generating coverage report failed. Are you running javascript tests only?')
+                import traceback
+                traceback.print_exc()
+
+    if failed:
+        # Ensure that our exit code indicates failure
+        sys.exit(1)
+
+argparser = argparse.ArgumentParser(description='Run IPython test suite')
+argparser.add_argument('testgroups', nargs='*',
+                    help='Run specified groups of tests. If omitted, run '
+                    'all tests.')
+argparser.add_argument('--all', action='store_true',
+                    help='Include slow tests not run by default.')
+argparser.add_argument('-j', '--fast', nargs='?', const=None, default=1, type=int,
+                    help='Run test sections in parallel. This starts as many '
+                    'processes as you have cores, or you can specify a number.')
+argparser.add_argument('--xunit', action='store_true',
+                    help='Produce Xunit XML results')
+argparser.add_argument('--coverage', nargs='?', const=True, default=False,
+                    help="Measure test coverage. Specify 'html' or "
+                    "'xml' to get reports.")
+argparser.add_argument('--subproc-streams', default='capture',
+                    help="What to do with stdout/stderr from subprocesses. "
+                    "'capture' (default), 'show' and 'discard' are the options.")
+
+def default_options():
+    """Get an argparse Namespace object with the default arguments, to pass to
+    :func:`run_iptestall`.
+    """
+    options = argparser.parse_args([])
+    options.extra_args = []
+    return options
+
+def main():
+    # iptest doesn't work correctly if the working directory is the
+    # root of the IPython source tree. Tell the user to avoid
+    # frustration.
+    if os.path.exists(os.path.join(os.getcwd(),
+                                   'IPython', 'testing', '__main__.py')):
+        print("Don't run iptest from the IPython source directory",
+              file=sys.stderr)
+        sys.exit(1)
+    # Arguments after -- should be passed through to nose. Argparse treats
+    # everything after -- as regular positional arguments, so we separate them
+    # first.
+    try:
+        ix = sys.argv.index('--')
+    except ValueError:
+        to_parse = sys.argv[1:]
+        extra_args = []
+    else:
+        to_parse = sys.argv[1:ix]
+        extra_args = sys.argv[ix+1:]
+
+    options = argparser.parse_args(to_parse)
+    options.extra_args = extra_args
+
+    run_iptestall(options)
+
+
+if __name__ == '__main__':
+    main()