python-3.6.zip added from Github

README.cosmo contains the necessary links.

third_party/python/Lib/test/test_fork1.py

@@ -0,0 +1,112 @@
+"""This test checks for correct fork() behavior.
+"""
+
+import _imp as imp
+import os
+import signal
+import sys
+import time
+import unittest
+
+from test.fork_wait import ForkWait
+from test.support import (reap_children, get_attribute,
+                          import_module, verbose)
+
+threading = import_module('threading')
+
+# Skip test if fork does not exist.
+get_attribute(os, 'fork')
+
+class ForkTest(ForkWait):
+    def wait_impl(self, cpid):
+        deadline = time.monotonic() + 10.0
+        while time.monotonic() <= deadline:
+            # waitpid() shouldn't hang, but some of the buildbots seem to hang
+            # in the forking tests.  This is an attempt to fix the problem.
+            spid, status = os.waitpid(cpid, os.WNOHANG)
+            if spid == cpid:
+                break
+            time.sleep(0.1)
+
+        self.assertEqual(spid, cpid)
+        self.assertEqual(status, 0, "cause = %d, exit = %d" % (status&0xff, status>>8))
+
+    def test_threaded_import_lock_fork(self):
+        """Check fork() in main thread works while a subthread is doing an import"""
+        import_started = threading.Event()
+        fake_module_name = "fake test module"
+        partial_module = "partial"
+        complete_module = "complete"
+        def importer():
+            imp.acquire_lock()
+            sys.modules[fake_module_name] = partial_module
+            import_started.set()
+            time.sleep(0.01) # Give the other thread time to try and acquire.
+            sys.modules[fake_module_name] = complete_module
+            imp.release_lock()
+        t = threading.Thread(target=importer)
+        t.start()
+        import_started.wait()
+        pid = os.fork()
+        try:
+            # PyOS_BeforeFork should have waited for the import to complete
+            # before forking, so the child can recreate the import lock
+            # correctly, but also won't see a partially initialised module
+            if not pid:
+                m = __import__(fake_module_name)
+                if m == complete_module:
+                    os._exit(0)
+                else:
+                    if verbose > 1:
+                        print("Child encountered partial module")
+                    os._exit(1)
+            else:
+                t.join()
+                # Exitcode 1 means the child got a partial module (bad.) No
+                # exitcode (but a hang, which manifests as 'got pid 0')
+                # means the child deadlocked (also bad.)
+                self.wait_impl(pid)
+        finally:
+            try:
+                os.kill(pid, signal.SIGKILL)
+            except OSError:
+                pass
+
+
+    def test_nested_import_lock_fork(self):
+        """Check fork() in main thread works while the main thread is doing an import"""
+        # Issue 9573: this used to trigger RuntimeError in the child process
+        def fork_with_import_lock(level):
+            release = 0
+            in_child = False
+            try:
+                try:
+                    for i in range(level):
+                        imp.acquire_lock()
+                        release += 1
+                    pid = os.fork()
+                    in_child = not pid
+                finally:
+                    for i in range(release):
+                        imp.release_lock()
+            except RuntimeError:
+                if in_child:
+                    if verbose > 1:
+                        print("RuntimeError in child")
+                    os._exit(1)
+                raise
+            if in_child:
+                os._exit(0)
+            self.wait_impl(pid)
+
+        # Check this works with various levels of nested
+        # import in the main thread
+        for level in range(5):
+            fork_with_import_lock(level)
+
+
+def tearDownModule():
+    reap_children()
+
+if __name__ == "__main__":
+    unittest.main()