com.googler.python 1.1.2 → 1.1.4

package/python3.6.2/lib/python3.6/test/test_thread.py

@@ -1,269 +0,0 @@
-import os
-import unittest
-import random
-from test import support
-thread = support.import_module('_thread')
-import time
-import sys
-import weakref
-
-from test import lock_tests
-
-NUMTASKS = 10
-NUMTRIPS = 3
-POLL_SLEEP = 0.010 # seconds = 10 ms
-
-_print_mutex = thread.allocate_lock()
-
-def verbose_print(arg):
-    """Helper function for printing out debugging output."""
-    if support.verbose:
-        with _print_mutex:
-            print(arg)
-
-
-class BasicThreadTest(unittest.TestCase):
-
-    def setUp(self):
-        self.done_mutex = thread.allocate_lock()
-        self.done_mutex.acquire()
-        self.running_mutex = thread.allocate_lock()
-        self.random_mutex = thread.allocate_lock()
-        self.created = 0
-        self.running = 0
-        self.next_ident = 0
-
-        key = support.threading_setup()
-        self.addCleanup(support.threading_cleanup, *key)
-
-
-class ThreadRunningTests(BasicThreadTest):
-
-    def newtask(self):
-        with self.running_mutex:
-            self.next_ident += 1
-            verbose_print("creating task %s" % self.next_ident)
-            thread.start_new_thread(self.task, (self.next_ident,))
-            self.created += 1
-            self.running += 1
-
-    def task(self, ident):
-        with self.random_mutex:
-            delay = random.random() / 10000.0
-        verbose_print("task %s will run for %sus" % (ident, round(delay*1e6)))
-        time.sleep(delay)
-        verbose_print("task %s done" % ident)
-        with self.running_mutex:
-            self.running -= 1
-            if self.created == NUMTASKS and self.running == 0:
-                self.done_mutex.release()
-
-    def test_starting_threads(self):
-        # Basic test for thread creation.
-        for i in range(NUMTASKS):
-            self.newtask()
-        verbose_print("waiting for tasks to complete...")
-        self.done_mutex.acquire()
-        verbose_print("all tasks done")
-
-    def test_stack_size(self):
-        # Various stack size tests.
-        self.assertEqual(thread.stack_size(), 0, "initial stack size is not 0")
-
-        thread.stack_size(0)
-        self.assertEqual(thread.stack_size(), 0, "stack_size not reset to default")
-
-    @unittest.skipIf(os.name not in ("nt", "posix"), 'test meant for nt and posix')
-    def test_nt_and_posix_stack_size(self):
-        try:
-            thread.stack_size(4096)
-        except ValueError:
-            verbose_print("caught expected ValueError setting "
-                            "stack_size(4096)")
-        except thread.error:
-            self.skipTest("platform does not support changing thread stack "
-                          "size")
-
-        fail_msg = "stack_size(%d) failed - should succeed"
-        for tss in (262144, 0x100000, 0):
-            thread.stack_size(tss)
-            self.assertEqual(thread.stack_size(), tss, fail_msg % tss)
-            verbose_print("successfully set stack_size(%d)" % tss)
-
-        for tss in (262144, 0x100000):
-            verbose_print("trying stack_size = (%d)" % tss)
-            self.next_ident = 0
-            self.created = 0
-            for i in range(NUMTASKS):
-                self.newtask()
-
-            verbose_print("waiting for all tasks to complete")
-            self.done_mutex.acquire()
-            verbose_print("all tasks done")
-
-        thread.stack_size(0)
-
-    def test__count(self):
-        # Test the _count() function.
-        orig = thread._count()
-        mut = thread.allocate_lock()
-        mut.acquire()
-        started = []
-        def task():
-            started.append(None)
-            mut.acquire()
-            mut.release()
-        thread.start_new_thread(task, ())
-        while not started:
-            time.sleep(POLL_SLEEP)
-        self.assertEqual(thread._count(), orig + 1)
-        # Allow the task to finish.
-        mut.release()
-        # The only reliable way to be sure that the thread ended from the
-        # interpreter's point of view is to wait for the function object to be
-        # destroyed.
-        done = []
-        wr = weakref.ref(task, lambda _: done.append(None))
-        del task
-        while not done:
-            time.sleep(POLL_SLEEP)
-        self.assertEqual(thread._count(), orig)
-
-    def test_save_exception_state_on_error(self):
-        # See issue #14474
-        def task():
-            started.release()
-            raise SyntaxError
-        def mywrite(self, *args):
-            try:
-                raise ValueError
-            except ValueError:
-                pass
-            real_write(self, *args)
-        c = thread._count()
-        started = thread.allocate_lock()
-        with support.captured_output("stderr") as stderr:
-            real_write = stderr.write
-            stderr.write = mywrite
-            started.acquire()
-            thread.start_new_thread(task, ())
-            started.acquire()
-            while thread._count() > c:
-                time.sleep(POLL_SLEEP)
-        self.assertIn("Traceback", stderr.getvalue())
-
-
-class Barrier:
-    def __init__(self, num_threads):
-        self.num_threads = num_threads
-        self.waiting = 0
-        self.checkin_mutex  = thread.allocate_lock()
-        self.checkout_mutex = thread.allocate_lock()
-        self.checkout_mutex.acquire()
-
-    def enter(self):
-        self.checkin_mutex.acquire()
-        self.waiting = self.waiting + 1
-        if self.waiting == self.num_threads:
-            self.waiting = self.num_threads - 1
-            self.checkout_mutex.release()
-            return
-        self.checkin_mutex.release()
-
-        self.checkout_mutex.acquire()
-        self.waiting = self.waiting - 1
-        if self.waiting == 0:
-            self.checkin_mutex.release()
-            return
-        self.checkout_mutex.release()
-
-
-class BarrierTest(BasicThreadTest):
-
-    def test_barrier(self):
-        self.bar = Barrier(NUMTASKS)
-        self.running = NUMTASKS
-        for i in range(NUMTASKS):
-            thread.start_new_thread(self.task2, (i,))
-        verbose_print("waiting for tasks to end")
-        self.done_mutex.acquire()
-        verbose_print("tasks done")
-
-    def task2(self, ident):
-        for i in range(NUMTRIPS):
-            if ident == 0:
-                # give it a good chance to enter the next
-                # barrier before the others are all out
-                # of the current one
-                delay = 0
-            else:
-                with self.random_mutex:
-                    delay = random.random() / 10000.0
-            verbose_print("task %s will run for %sus" %
-                          (ident, round(delay * 1e6)))
-            time.sleep(delay)
-            verbose_print("task %s entering %s" % (ident, i))
-            self.bar.enter()
-            verbose_print("task %s leaving barrier" % ident)
-        with self.running_mutex:
-            self.running -= 1
-            # Must release mutex before releasing done, else the main thread can
-            # exit and set mutex to None as part of global teardown; then
-            # mutex.release() raises AttributeError.
-            finished = self.running == 0
-        if finished:
-            self.done_mutex.release()
-
-class LockTests(lock_tests.LockTests):
-    locktype = thread.allocate_lock
-
-
-class TestForkInThread(unittest.TestCase):
-    def setUp(self):
-        self.read_fd, self.write_fd = os.pipe()
-
-    @unittest.skipUnless(hasattr(os, 'fork'), 'need os.fork')
-    @support.reap_threads
-    def test_forkinthread(self):
-        running = True
-        status = "not set"
-
-        def thread1():
-            nonlocal running, status
-
-            # fork in a thread
-            pid = os.fork()
-            if pid == 0:
-                # child
-                try:
-                    os.close(self.read_fd)
-                    os.write(self.write_fd, b"OK")
-                finally:
-                    os._exit(0)
-            else:
-                # parent
-                os.close(self.write_fd)
-                pid, status = os.waitpid(pid, 0)
-                running = False
-
-        thread.start_new_thread(thread1, ())
-        self.assertEqual(os.read(self.read_fd, 2), b"OK",
-                         "Unable to fork() in thread")
-        while running:
-            time.sleep(POLL_SLEEP)
-        self.assertEqual(status, 0)
-
-    def tearDown(self):
-        try:
-            os.close(self.read_fd)
-        except OSError:
-            pass
-
-        try:
-            os.close(self.write_fd)
-        except OSError:
-            pass
-
-
-if __name__ == "__main__":
-    unittest.main()

package/python3.6.2/lib/python3.6/test/test_threaded_import.py

@@ -1,254 +0,0 @@
-# This is a variant of the very old (early 90's) file
-# Demo/threads/bug.py.  It simply provokes a number of threads into
-# trying to import the same module "at the same time".
-# There are no pleasant failure modes -- most likely is that Python
-# complains several times about module random having no attribute
-# randrange, and then Python hangs.
-
-import _imp as imp
-import os
-import importlib
-import sys
-import time
-import shutil
-import unittest
-from test.support import (
-    verbose, import_module, run_unittest, TESTFN, reap_threads,
-    forget, unlink, rmtree, start_threads)
-threading = import_module('threading')
-
-def task(N, done, done_tasks, errors):
-    try:
-        # We don't use modulefinder but still import it in order to stress
-        # importing of different modules from several threads.
-        if len(done_tasks) % 2:
-            import modulefinder
-            import random
-        else:
-            import random
-            import modulefinder
-        # This will fail if random is not completely initialized
-        x = random.randrange(1, 3)
-    except Exception as e:
-        errors.append(e.with_traceback(None))
-    finally:
-        done_tasks.append(threading.get_ident())
-        finished = len(done_tasks) == N
-        if finished:
-            done.set()
-
-# Create a circular import structure: A -> C -> B -> D -> A
-# NOTE: `time` is already loaded and therefore doesn't threaten to deadlock.
-
-circular_imports_modules = {
-    'A': """if 1:
-        import time
-        time.sleep(%(delay)s)
-        x = 'a'
-        import C
-        """,
-    'B': """if 1:
-        import time
-        time.sleep(%(delay)s)
-        x = 'b'
-        import D
-        """,
-    'C': """import B""",
-    'D': """import A""",
-}
-
-class Finder:
-    """A dummy finder to detect concurrent access to its find_spec()
-    method."""
-
-    def __init__(self):
-        self.numcalls = 0
-        self.x = 0
-        self.lock = threading.Lock()
-
-    def find_spec(self, name, path=None, target=None):
-        # Simulate some thread-unsafe behaviour. If calls to find_spec()
-        # are properly serialized, `x` will end up the same as `numcalls`.
-        # Otherwise not.
-        assert imp.lock_held()
-        with self.lock:
-            self.numcalls += 1
-        x = self.x
-        time.sleep(0.01)
-        self.x = x + 1
-
-class FlushingFinder:
-    """A dummy finder which flushes sys.path_importer_cache when it gets
-    called."""
-
-    def find_spec(self, name, path=None, target=None):
-        sys.path_importer_cache.clear()
-
-
-class ThreadedImportTests(unittest.TestCase):
-
-    def setUp(self):
-        self.old_random = sys.modules.pop('random', None)
-
-    def tearDown(self):
-        # If the `random` module was already initialized, we restore the
-        # old module at the end so that pickling tests don't fail.
-        # See http://bugs.python.org/issue3657#msg110461
-        if self.old_random is not None:
-            sys.modules['random'] = self.old_random
-
-    def check_parallel_module_init(self):
-        if imp.lock_held():
-            # This triggers on, e.g., from test import autotest.
-            raise unittest.SkipTest("can't run when import lock is held")
-
-        done = threading.Event()
-        for N in (20, 50) * 3:
-            if verbose:
-                print("Trying", N, "threads ...", end=' ')
-            # Make sure that random and modulefinder get reimported freshly
-            for modname in ['random', 'modulefinder']:
-                try:
-                    del sys.modules[modname]
-                except KeyError:
-                    pass
-            errors = []
-            done_tasks = []
-            done.clear()
-            t0 = time.monotonic()
-            with start_threads(threading.Thread(target=task,
-                                                args=(N, done, done_tasks, errors,))
-                               for i in range(N)):
-                pass
-            completed = done.wait(10 * 60)
-            dt = time.monotonic() - t0
-            if verbose:
-                print("%.1f ms" % (dt*1e3), flush=True, end=" ")
-            dbg_info = 'done: %s/%s' % (len(done_tasks), N)
-            self.assertFalse(errors, dbg_info)
-            self.assertTrue(completed, dbg_info)
-            if verbose:
-                print("OK.")
-
-    def test_parallel_module_init(self):
-        self.check_parallel_module_init()
-
-    def test_parallel_meta_path(self):
-        finder = Finder()
-        sys.meta_path.insert(0, finder)
-        try:
-            self.check_parallel_module_init()
-            self.assertGreater(finder.numcalls, 0)
-            self.assertEqual(finder.x, finder.numcalls)
-        finally:
-            sys.meta_path.remove(finder)
-
-    def test_parallel_path_hooks(self):
-        # Here the Finder instance is only used to check concurrent calls
-        # to path_hook().
-        finder = Finder()
-        # In order for our path hook to be called at each import, we need
-        # to flush the path_importer_cache, which we do by registering a
-        # dedicated meta_path entry.
-        flushing_finder = FlushingFinder()
-        def path_hook(path):
-            finder.find_spec('')
-            raise ImportError
-        sys.path_hooks.insert(0, path_hook)
-        sys.meta_path.append(flushing_finder)
-        try:
-            # Flush the cache a first time
-            flushing_finder.find_spec('')
-            numtests = self.check_parallel_module_init()
-            self.assertGreater(finder.numcalls, 0)
-            self.assertEqual(finder.x, finder.numcalls)
-        finally:
-            sys.meta_path.remove(flushing_finder)
-            sys.path_hooks.remove(path_hook)
-
-    def test_import_hangers(self):
-        # In case this test is run again, make sure the helper module
-        # gets loaded from scratch again.
-        try:
-            del sys.modules['test.threaded_import_hangers']
-        except KeyError:
-            pass
-        import test.threaded_import_hangers
-        self.assertFalse(test.threaded_import_hangers.errors)
-
-    def test_circular_imports(self):
-        # The goal of this test is to exercise implementations of the import
-        # lock which use a per-module lock, rather than a global lock.
-        # In these implementations, there is a possible deadlock with
-        # circular imports, for example:
-        # - thread 1 imports A (grabbing the lock for A) which imports B
-        # - thread 2 imports B (grabbing the lock for B) which imports A
-        # Such implementations should be able to detect such situations and
-        # resolve them one way or the other, without freezing.
-        # NOTE: our test constructs a slightly less trivial import cycle,
-        # in order to better stress the deadlock avoidance mechanism.
-        delay = 0.5
-        os.mkdir(TESTFN)
-        self.addCleanup(shutil.rmtree, TESTFN)
-        sys.path.insert(0, TESTFN)
-        self.addCleanup(sys.path.remove, TESTFN)
-        for name, contents in circular_imports_modules.items():
-            contents = contents % {'delay': delay}
-            with open(os.path.join(TESTFN, name + ".py"), "wb") as f:
-                f.write(contents.encode('utf-8'))
-            self.addCleanup(forget, name)
-
-        importlib.invalidate_caches()
-        results = []
-        def import_ab():
-            import A
-            results.append(getattr(A, 'x', None))
-        def import_ba():
-            import B
-            results.append(getattr(B, 'x', None))
-        t1 = threading.Thread(target=import_ab)
-        t2 = threading.Thread(target=import_ba)
-        t1.start()
-        t2.start()
-        t1.join()
-        t2.join()
-        self.assertEqual(set(results), {'a', 'b'})
-
-    def test_side_effect_import(self):
-        code = """if 1:
-            import threading
-            def target():
-                import random
-            t = threading.Thread(target=target)
-            t.start()
-            t.join()
-            t = None"""
-        sys.path.insert(0, os.curdir)
-        self.addCleanup(sys.path.remove, os.curdir)
-        filename = TESTFN + ".py"
-        with open(filename, "wb") as f:
-            f.write(code.encode('utf-8'))
-        self.addCleanup(unlink, filename)
-        self.addCleanup(forget, TESTFN)
-        self.addCleanup(rmtree, '__pycache__')
-        importlib.invalidate_caches()
-        __import__(TESTFN)
-        del sys.modules[TESTFN]
-
-
-@reap_threads
-def test_main():
-    old_switchinterval = None
-    try:
-        old_switchinterval = sys.getswitchinterval()
-        sys.setswitchinterval(1e-5)
-    except AttributeError:
-        pass
-    try:
-        run_unittest(ThreadedImportTests)
-    finally:
-        if old_switchinterval is not None:
-            sys.setswitchinterval(old_switchinterval)
-
-if __name__ == "__main__":
-    test_main()

package/python3.6.2/lib/python3.6/test/test_threadedtempfile.py

@@ -1,62 +0,0 @@
-"""
-Create and delete FILES_PER_THREAD temp files (via tempfile.TemporaryFile)
-in each of NUM_THREADS threads, recording the number of successes and
-failures.  A failure is a bug in tempfile, and may be due to:
-
-+ Trying to create more than one tempfile with the same name.
-+ Trying to delete a tempfile that doesn't still exist.
-+ Something we've never seen before.
-
-By default, NUM_THREADS == 20 and FILES_PER_THREAD == 50.  This is enough to
-create about 150 failures per run under Win98SE in 2.0, and runs pretty
-quickly. Guido reports needing to boost FILES_PER_THREAD to 500 before
-provoking a 2.0 failure under Linux.
-"""
-
-NUM_THREADS = 20
-FILES_PER_THREAD = 50
-
-import tempfile
-
-from test.support import start_threads, import_module
-threading = import_module('threading')
-import unittest
-import io
-from traceback import print_exc
-
-startEvent = threading.Event()
-
-class TempFileGreedy(threading.Thread):
-    error_count = 0
-    ok_count = 0
-
-    def run(self):
-        self.errors = io.StringIO()
-        startEvent.wait()
-        for i in range(FILES_PER_THREAD):
-            try:
-                f = tempfile.TemporaryFile("w+b")
-                f.close()
-            except:
-                self.error_count += 1
-                print_exc(file=self.errors)
-            else:
-                self.ok_count += 1
-
-
-class ThreadedTempFileTest(unittest.TestCase):
-    def test_main(self):
-        threads = [TempFileGreedy() for i in range(NUM_THREADS)]
-        with start_threads(threads, startEvent.set):
-            pass
-        ok = sum(t.ok_count for t in threads)
-        errors = [str(t.name) + str(t.errors.getvalue())
-                  for t in threads if t.error_count]
-
-        msg = "Errors: errors %d ok %d\n%s" % (len(errors), ok,
-            '\n'.join(errors))
-        self.assertEqual(errors, [], msg)
-        self.assertEqual(ok, NUM_THREADS * FILES_PER_THREAD)
-
-if __name__ == "__main__":
-    unittest.main()