com.googler.python 1.1.2 → 1.1.4

package/python3.6.2/lib/python3.6/test/libregrtest/runtest_mp.py

@@ -1,244 +0,0 @@
-import faulthandler
-import json
-import os
-import queue
-import sys
-import time
-import traceback
-import types
-from test import support
-try:
-    import threading
-except ImportError:
-    print("Multiprocess option requires thread support")
-    sys.exit(2)
-
-from test.libregrtest.runtest import (
-    runtest, INTERRUPTED, CHILD_ERROR, PROGRESS_MIN_TIME,
-    format_test_result)
-from test.libregrtest.setup import setup_tests
-
-
-# Display the running tests if nothing happened last N seconds
-PROGRESS_UPDATE = 30.0   # seconds
-
-# If interrupted, display the wait progress every N seconds
-WAIT_PROGRESS = 2.0   # seconds
-
-
-def run_test_in_subprocess(testname, ns):
-    """Run the given test in a subprocess with --slaveargs.
-
-    ns is the option Namespace parsed from command-line arguments. regrtest
-    is invoked in a subprocess with the --slaveargs argument; when the
-    subprocess exits, its return code, stdout and stderr are returned as a
-    3-tuple.
-    """
-    from subprocess import Popen, PIPE
-
-    ns_dict = vars(ns)
-    slaveargs = (ns_dict, testname)
-    slaveargs = json.dumps(slaveargs)
-
-    cmd = [sys.executable, *support.args_from_interpreter_flags(),
-           '-u',    # Unbuffered stdout and stderr
-           '-m', 'test.regrtest',
-           '--slaveargs', slaveargs]
-    if ns.pgo:
-        cmd += ['--pgo']
-
-    # Running the child from the same working directory as regrtest's original
-    # invocation ensures that TEMPDIR for the child is the same when
-    # sysconfig.is_python_build() is true. See issue 15300.
-    popen = Popen(cmd,
-                  stdout=PIPE, stderr=PIPE,
-                  universal_newlines=True,
-                  close_fds=(os.name != 'nt'),
-                  cwd=support.SAVEDCWD)
-    with popen:
-        stdout, stderr = popen.communicate()
-        retcode = popen.wait()
-    return retcode, stdout, stderr
-
-
-def run_tests_slave(slaveargs):
-    ns_dict, testname = json.loads(slaveargs)
-    ns = types.SimpleNamespace(**ns_dict)
-
-    setup_tests(ns)
-
-    try:
-        result = runtest(ns, testname)
-    except KeyboardInterrupt:
-        result = INTERRUPTED, ''
-    except BaseException as e:
-        traceback.print_exc()
-        result = CHILD_ERROR, str(e)
-
-    print()   # Force a newline (just in case)
-    print(json.dumps(result), flush=True)
-    sys.exit(0)
-
-
-# We do not use a generator so multiple threads can call next().
-class MultiprocessIterator:
-
-    """A thread-safe iterator over tests for multiprocess mode."""
-
-    def __init__(self, tests):
-        self.interrupted = False
-        self.lock = threading.Lock()
-        self.tests = tests
-
-    def __iter__(self):
-        return self
-
-    def __next__(self):
-        with self.lock:
-            if self.interrupted:
-                raise StopIteration('tests interrupted')
-            return next(self.tests)
-
-
-class MultiprocessThread(threading.Thread):
-    def __init__(self, pending, output, ns):
-        super().__init__()
-        self.pending = pending
-        self.output = output
-        self.ns = ns
-        self.current_test = None
-        self.start_time = None
-
-    def _runtest(self):
-        try:
-            test = next(self.pending)
-        except StopIteration:
-            self.output.put((None, None, None, None))
-            return True
-
-        try:
-            self.start_time = time.monotonic()
-            self.current_test = test
-
-            retcode, stdout, stderr = run_test_in_subprocess(test, self.ns)
-        finally:
-            self.current_test = None
-
-        if retcode != 0:
-            result = (CHILD_ERROR, "Exit code %s" % retcode)
-            self.output.put((test, stdout.rstrip(), stderr.rstrip(),
-                             result))
-            return False
-
-        stdout, _, result = stdout.strip().rpartition("\n")
-        if not result:
-            self.output.put((None, None, None, None))
-            return True
-
-        result = json.loads(result)
-        self.output.put((test, stdout.rstrip(), stderr.rstrip(),
-                         result))
-        return False
-
-    def run(self):
-        try:
-            stop = False
-            while not stop:
-                stop = self._runtest()
-        except BaseException:
-            self.output.put((None, None, None, None))
-            raise
-
-
-def run_tests_multiprocess(regrtest):
-    output = queue.Queue()
-    pending = MultiprocessIterator(regrtest.tests)
-    test_timeout = regrtest.ns.timeout
-    use_timeout = (test_timeout is not None)
-
-    workers = [MultiprocessThread(pending, output, regrtest.ns)
-               for i in range(regrtest.ns.use_mp)]
-    print("Run tests in parallel using %s child processes"
-          % len(workers))
-    for worker in workers:
-        worker.start()
-
-    def get_running(workers):
-        running = []
-        for worker in workers:
-            current_test = worker.current_test
-            if not current_test:
-                continue
-            dt = time.monotonic() - worker.start_time
-            if dt >= PROGRESS_MIN_TIME:
-                running.append('%s (%.0f sec)' % (current_test, dt))
-        return running
-
-    finished = 0
-    test_index = 1
-    get_timeout = max(PROGRESS_UPDATE, PROGRESS_MIN_TIME)
-    try:
-        while finished < regrtest.ns.use_mp:
-            if use_timeout:
-                faulthandler.dump_traceback_later(test_timeout, exit=True)
-
-            try:
-                item = output.get(timeout=get_timeout)
-            except queue.Empty:
-                running = get_running(workers)
-                if running and not regrtest.ns.pgo:
-                    print('running: %s' % ', '.join(running))
-                continue
-
-            test, stdout, stderr, result = item
-            if test is None:
-                finished += 1
-                continue
-            regrtest.accumulate_result(test, result)
-
-            # Display progress
-            ok, test_time = result
-            text = format_test_result(test, ok)
-            if (ok not in (CHILD_ERROR, INTERRUPTED)
-                and test_time >= PROGRESS_MIN_TIME
-                and not regrtest.ns.pgo):
-                text += ' (%.0f sec)' % test_time
-            elif ok == CHILD_ERROR:
-                text = '%s (%s)' % (text, test_time)
-            running = get_running(workers)
-            if running and not regrtest.ns.pgo:
-                text += ' -- running: %s' % ', '.join(running)
-            regrtest.display_progress(test_index, text)
-
-            # Copy stdout and stderr from the child process
-            if stdout:
-                print(stdout, flush=True)
-            if stderr and not regrtest.ns.pgo:
-                print(stderr, file=sys.stderr, flush=True)
-
-            if result[0] == INTERRUPTED:
-                raise KeyboardInterrupt
-            test_index += 1
-    except KeyboardInterrupt:
-        regrtest.interrupted = True
-        pending.interrupted = True
-        print()
-    finally:
-        if use_timeout:
-            faulthandler.cancel_dump_traceback_later()
-
-    # If tests are interrupted, wait until tests complete
-    wait_start = time.monotonic()
-    while True:
-        running = [worker.current_test for worker in workers]
-        running = list(filter(bool, running))
-        if not running:
-            break
-
-        dt = time.monotonic() - wait_start
-        line = "Waiting for %s (%s tests)" % (', '.join(running), len(running))
-        if dt >= WAIT_PROGRESS:
-            line = "%s since %.0f sec" % (line, dt)
-        print(line)
-        for worker in workers:
-            worker.join(WAIT_PROGRESS)

package/python3.6.2/lib/python3.6/test/libregrtest/save_env.py

@@ -1,284 +0,0 @@
-import builtins
-import locale
-import logging
-import os
-import shutil
-import sys
-import sysconfig
-import warnings
-from test import support
-try:
-    import threading
-except ImportError:
-    threading = None
-try:
-    import _multiprocessing, multiprocessing.process
-except ImportError:
-    multiprocessing = None
-
-
-# Unit tests are supposed to leave the execution environment unchanged
-# once they complete.  But sometimes tests have bugs, especially when
-# tests fail, and the changes to environment go on to mess up other
-# tests.  This can cause issues with buildbot stability, since tests
-# are run in random order and so problems may appear to come and go.
-# There are a few things we can save and restore to mitigate this, and
-# the following context manager handles this task.
-
-class saved_test_environment:
-    """Save bits of the test environment and restore them at block exit.
-
-        with saved_test_environment(testname, verbose, quiet):
-            #stuff
-
-    Unless quiet is True, a warning is printed to stderr if any of
-    the saved items was changed by the test.  The attribute 'changed'
-    is initially False, but is set to True if a change is detected.
-
-    If verbose is more than 1, the before and after state of changed
-    items is also printed.
-    """
-
-    changed = False
-
-    def __init__(self, testname, verbose=0, quiet=False, *, pgo=False):
-        self.testname = testname
-        self.verbose = verbose
-        self.quiet = quiet
-        self.pgo = pgo
-
-    # To add things to save and restore, add a name XXX to the resources list
-    # and add corresponding get_XXX/restore_XXX functions.  get_XXX should
-    # return the value to be saved and compared against a second call to the
-    # get function when test execution completes.  restore_XXX should accept
-    # the saved value and restore the resource using it.  It will be called if
-    # and only if a change in the value is detected.
-    #
-    # Note: XXX will have any '.' replaced with '_' characters when determining
-    # the corresponding method names.
-
-    resources = ('sys.argv', 'cwd', 'sys.stdin', 'sys.stdout', 'sys.stderr',
-                 'os.environ', 'sys.path', 'sys.path_hooks', '__import__',
-                 'warnings.filters', 'asyncore.socket_map',
-                 'logging._handlers', 'logging._handlerList', 'sys.gettrace',
-                 'sys.warnoptions',
-                 # multiprocessing.process._cleanup() may release ref
-                 # to a thread, so check processes first.
-                 'multiprocessing.process._dangling', 'threading._dangling',
-                 'sysconfig._CONFIG_VARS', 'sysconfig._INSTALL_SCHEMES',
-                 'files', 'locale', 'warnings.showwarning',
-                 'shutil_archive_formats', 'shutil_unpack_formats',
-                )
-
-    def get_sys_argv(self):
-        return id(sys.argv), sys.argv, sys.argv[:]
-    def restore_sys_argv(self, saved_argv):
-        sys.argv = saved_argv[1]
-        sys.argv[:] = saved_argv[2]
-
-    def get_cwd(self):
-        return os.getcwd()
-    def restore_cwd(self, saved_cwd):
-        os.chdir(saved_cwd)
-
-    def get_sys_stdout(self):
-        return sys.stdout
-    def restore_sys_stdout(self, saved_stdout):
-        sys.stdout = saved_stdout
-
-    def get_sys_stderr(self):
-        return sys.stderr
-    def restore_sys_stderr(self, saved_stderr):
-        sys.stderr = saved_stderr
-
-    def get_sys_stdin(self):
-        return sys.stdin
-    def restore_sys_stdin(self, saved_stdin):
-        sys.stdin = saved_stdin
-
-    def get_os_environ(self):
-        return id(os.environ), os.environ, dict(os.environ)
-    def restore_os_environ(self, saved_environ):
-        os.environ = saved_environ[1]
-        os.environ.clear()
-        os.environ.update(saved_environ[2])
-
-    def get_sys_path(self):
-        return id(sys.path), sys.path, sys.path[:]
-    def restore_sys_path(self, saved_path):
-        sys.path = saved_path[1]
-        sys.path[:] = saved_path[2]
-
-    def get_sys_path_hooks(self):
-        return id(sys.path_hooks), sys.path_hooks, sys.path_hooks[:]
-    def restore_sys_path_hooks(self, saved_hooks):
-        sys.path_hooks = saved_hooks[1]
-        sys.path_hooks[:] = saved_hooks[2]
-
-    def get_sys_gettrace(self):
-        return sys.gettrace()
-    def restore_sys_gettrace(self, trace_fxn):
-        sys.settrace(trace_fxn)
-
-    def get___import__(self):
-        return builtins.__import__
-    def restore___import__(self, import_):
-        builtins.__import__ = import_
-
-    def get_warnings_filters(self):
-        return id(warnings.filters), warnings.filters, warnings.filters[:]
-    def restore_warnings_filters(self, saved_filters):
-        warnings.filters = saved_filters[1]
-        warnings.filters[:] = saved_filters[2]
-
-    def get_asyncore_socket_map(self):
-        asyncore = sys.modules.get('asyncore')
-        # XXX Making a copy keeps objects alive until __exit__ gets called.
-        return asyncore and asyncore.socket_map.copy() or {}
-    def restore_asyncore_socket_map(self, saved_map):
-        asyncore = sys.modules.get('asyncore')
-        if asyncore is not None:
-            asyncore.close_all(ignore_all=True)
-            asyncore.socket_map.update(saved_map)
-
-    def get_shutil_archive_formats(self):
-        # we could call get_archives_formats() but that only returns the
-        # registry keys; we want to check the values too (the functions that
-        # are registered)
-        return shutil._ARCHIVE_FORMATS, shutil._ARCHIVE_FORMATS.copy()
-    def restore_shutil_archive_formats(self, saved):
-        shutil._ARCHIVE_FORMATS = saved[0]
-        shutil._ARCHIVE_FORMATS.clear()
-        shutil._ARCHIVE_FORMATS.update(saved[1])
-
-    def get_shutil_unpack_formats(self):
-        return shutil._UNPACK_FORMATS, shutil._UNPACK_FORMATS.copy()
-    def restore_shutil_unpack_formats(self, saved):
-        shutil._UNPACK_FORMATS = saved[0]
-        shutil._UNPACK_FORMATS.clear()
-        shutil._UNPACK_FORMATS.update(saved[1])
-
-    def get_logging__handlers(self):
-        # _handlers is a WeakValueDictionary
-        return id(logging._handlers), logging._handlers, logging._handlers.copy()
-    def restore_logging__handlers(self, saved_handlers):
-        # Can't easily revert the logging state
-        pass
-
-    def get_logging__handlerList(self):
-        # _handlerList is a list of weakrefs to handlers
-        return id(logging._handlerList), logging._handlerList, logging._handlerList[:]
-    def restore_logging__handlerList(self, saved_handlerList):
-        # Can't easily revert the logging state
-        pass
-
-    def get_sys_warnoptions(self):
-        return id(sys.warnoptions), sys.warnoptions, sys.warnoptions[:]
-    def restore_sys_warnoptions(self, saved_options):
-        sys.warnoptions = saved_options[1]
-        sys.warnoptions[:] = saved_options[2]
-
-    # Controlling dangling references to Thread objects can make it easier
-    # to track reference leaks.
-    def get_threading__dangling(self):
-        if not threading:
-            return None
-        # This copies the weakrefs without making any strong reference
-        return threading._dangling.copy()
-    def restore_threading__dangling(self, saved):
-        if not threading:
-            return
-        threading._dangling.clear()
-        threading._dangling.update(saved)
-
-    # Same for Process objects
-    def get_multiprocessing_process__dangling(self):
-        if not multiprocessing:
-            return None
-        # Unjoined process objects can survive after process exits
-        multiprocessing.process._cleanup()
-        # This copies the weakrefs without making any strong reference
-        return multiprocessing.process._dangling.copy()
-    def restore_multiprocessing_process__dangling(self, saved):
-        if not multiprocessing:
-            return
-        multiprocessing.process._dangling.clear()
-        multiprocessing.process._dangling.update(saved)
-
-    def get_sysconfig__CONFIG_VARS(self):
-        # make sure the dict is initialized
-        sysconfig.get_config_var('prefix')
-        return (id(sysconfig._CONFIG_VARS), sysconfig._CONFIG_VARS,
-                dict(sysconfig._CONFIG_VARS))
-    def restore_sysconfig__CONFIG_VARS(self, saved):
-        sysconfig._CONFIG_VARS = saved[1]
-        sysconfig._CONFIG_VARS.clear()
-        sysconfig._CONFIG_VARS.update(saved[2])
-
-    def get_sysconfig__INSTALL_SCHEMES(self):
-        return (id(sysconfig._INSTALL_SCHEMES), sysconfig._INSTALL_SCHEMES,
-                sysconfig._INSTALL_SCHEMES.copy())
-    def restore_sysconfig__INSTALL_SCHEMES(self, saved):
-        sysconfig._INSTALL_SCHEMES = saved[1]
-        sysconfig._INSTALL_SCHEMES.clear()
-        sysconfig._INSTALL_SCHEMES.update(saved[2])
-
-    def get_files(self):
-        return sorted(fn + ('/' if os.path.isdir(fn) else '')
-                      for fn in os.listdir())
-    def restore_files(self, saved_value):
-        fn = support.TESTFN
-        if fn not in saved_value and (fn + '/') not in saved_value:
-            if os.path.isfile(fn):
-                support.unlink(fn)
-            elif os.path.isdir(fn):
-                support.rmtree(fn)
-
-    _lc = [getattr(locale, lc) for lc in dir(locale)
-           if lc.startswith('LC_')]
-    def get_locale(self):
-        pairings = []
-        for lc in self._lc:
-            try:
-                pairings.append((lc, locale.setlocale(lc, None)))
-            except (TypeError, ValueError):
-                continue
-        return pairings
-    def restore_locale(self, saved):
-        for lc, setting in saved:
-            locale.setlocale(lc, setting)
-
-    def get_warnings_showwarning(self):
-        return warnings.showwarning
-    def restore_warnings_showwarning(self, fxn):
-        warnings.showwarning = fxn
-
-    def resource_info(self):
-        for name in self.resources:
-            method_suffix = name.replace('.', '_')
-            get_name = 'get_' + method_suffix
-            restore_name = 'restore_' + method_suffix
-            yield name, getattr(self, get_name), getattr(self, restore_name)
-
-    def __enter__(self):
-        self.saved_values = dict((name, get()) for name, get, restore
-                                                   in self.resource_info())
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        saved_values = self.saved_values
-        del self.saved_values
-        support.gc_collect()  # Some resources use weak references
-        for name, get, restore in self.resource_info():
-            current = get()
-            original = saved_values.pop(name)
-            # Check for changes to the resource's value
-            if current != original:
-                self.changed = True
-                restore(original)
-                if not self.quiet and not self.pgo:
-                    print(f"Warning -- {name} was modified by {self.testname}",
-                          file=sys.stderr, flush=True)
-                    print(f"  Before: {original}\n  After:  {current} ",
-                          file=sys.stderr, flush=True)
-        return False

package/python3.6.2/lib/python3.6/test/libregrtest/setup.py

@@ -1,140 +0,0 @@
-import atexit
-import faulthandler
-import os
-import signal
-import sys
-import unittest
-from test import support
-try:
-    import gc
-except ImportError:
-    gc = None
-
-from test.libregrtest.refleak import warm_caches
-
-
-def setup_tests(ns):
-    try:
-        stderr_fd = sys.__stderr__.fileno()
-    except (ValueError, AttributeError):
-        # Catch ValueError to catch io.UnsupportedOperation on TextIOBase
-        # and ValueError on a closed stream.
-        #
-        # Catch AttributeError for stderr being None.
-        stderr_fd = None
-    else:
-        # Display the Python traceback on fatal errors (e.g. segfault)
-        faulthandler.enable(all_threads=True, file=stderr_fd)
-
-        # Display the Python traceback on SIGALRM or SIGUSR1 signal
-        signals = []
-        if hasattr(signal, 'SIGALRM'):
-            signals.append(signal.SIGALRM)
-        if hasattr(signal, 'SIGUSR1'):
-            signals.append(signal.SIGUSR1)
-        for signum in signals:
-            faulthandler.register(signum, chain=True, file=stderr_fd)
-
-    replace_stdout()
-    support.record_original_stdout(sys.stdout)
-
-    if ns.testdir:
-        # Prepend test directory to sys.path, so runtest() will be able
-        # to locate tests
-        sys.path.insert(0, os.path.abspath(ns.testdir))
-
-    # Some times __path__ and __file__ are not absolute (e.g. while running from
-    # Lib/) and, if we change the CWD to run the tests in a temporary dir, some
-    # imports might fail.  This affects only the modules imported before os.chdir().
-    # These modules are searched first in sys.path[0] (so '' -- the CWD) and if
-    # they are found in the CWD their __file__ and __path__ will be relative (this
-    # happens before the chdir).  All the modules imported after the chdir, are
-    # not found in the CWD, and since the other paths in sys.path[1:] are absolute
-    # (site.py absolutize them), the __file__ and __path__ will be absolute too.
-    # Therefore it is necessary to absolutize manually the __file__ and __path__ of
-    # the packages to prevent later imports to fail when the CWD is different.
-    for module in sys.modules.values():
-        if hasattr(module, '__path__'):
-            for index, path in enumerate(module.__path__):
-                module.__path__[index] = os.path.abspath(path)
-        if hasattr(module, '__file__'):
-            module.__file__ = os.path.abspath(module.__file__)
-
-    # MacOSX (a.k.a. Darwin) has a default stack size that is too small
-    # for deeply recursive regular expressions.  We see this as crashes in
-    # the Python test suite when running test_re.py and test_sre.py.  The
-    # fix is to set the stack limit to 2048.
-    # This approach may also be useful for other Unixy platforms that
-    # suffer from small default stack limits.
-    if sys.platform == 'darwin':
-        try:
-            import resource
-        except ImportError:
-            pass
-        else:
-            soft, hard = resource.getrlimit(resource.RLIMIT_STACK)
-            newsoft = min(hard, max(soft, 1024*2048))
-            resource.setrlimit(resource.RLIMIT_STACK, (newsoft, hard))
-
-    if ns.huntrleaks:
-        unittest.BaseTestSuite._cleanup = False
-
-        # Avoid false positives due to various caches
-        # filling slowly with random data:
-        warm_caches()
-
-    if ns.memlimit is not None:
-        support.set_memlimit(ns.memlimit)
-
-    if ns.threshold is not None:
-        gc.set_threshold(ns.threshold)
-
-    try:
-        import msvcrt
-    except ImportError:
-        pass
-    else:
-        msvcrt.SetErrorMode(msvcrt.SEM_FAILCRITICALERRORS|
-                            msvcrt.SEM_NOALIGNMENTFAULTEXCEPT|
-                            msvcrt.SEM_NOGPFAULTERRORBOX|
-                            msvcrt.SEM_NOOPENFILEERRORBOX)
-        try:
-            msvcrt.CrtSetReportMode
-        except AttributeError:
-            # release build
-            pass
-        else:
-            for m in [msvcrt.CRT_WARN, msvcrt.CRT_ERROR, msvcrt.CRT_ASSERT]:
-                if ns.verbose and ns.verbose >= 2:
-                    msvcrt.CrtSetReportMode(m, msvcrt.CRTDBG_MODE_FILE)
-                    msvcrt.CrtSetReportFile(m, msvcrt.CRTDBG_FILE_STDERR)
-                else:
-                    msvcrt.CrtSetReportMode(m, 0)
-
-    support.use_resources = ns.use_resources
-
-
-def replace_stdout():
-    """Set stdout encoder error handler to backslashreplace (as stderr error
-    handler) to avoid UnicodeEncodeError when printing a traceback"""
-    stdout = sys.stdout
-    try:
-        fd = stdout.fileno()
-    except ValueError:
-        # On IDLE, sys.stdout has no file descriptor and is not a TextIOWrapper
-        # object. Leaving sys.stdout unchanged.
-        #
-        # Catch ValueError to catch io.UnsupportedOperation on TextIOBase
-        # and ValueError on a closed stream.
-        return
-
-    sys.stdout = open(fd, 'w',
-        encoding=stdout.encoding,
-        errors="backslashreplace",
-        closefd=False,
-        newline='\n')
-
-    def restore_stdout():
-        sys.stdout.close()
-        sys.stdout = stdout
-    atexit.register(restore_stdout)