tests: Factor test scripts into separate files

This will make it easier to maintain these compared to the previous
nested triple quoted strings.

Signed-off-by: Matt Wozniski <mwozniski@bloomberg.net>

Author: godlygeek

tests/integration/subinterpreters_nested_same_thread_program.py

@@ -0,0 +1,31 @@
+import sys
+import threading
+import time
+
+from subinterpreters_shim import run_in_new_interpreter
+
+fifo = sys.argv[1]
+
+inner_code = f"""
+import time
+
+with open({fifo!r}, "w") as f:
+    f.write("ready")
+
+while True:
+    time.sleep(1)
+"""
+
+outer_code = f"""
+import sys
+sys.path.insert(0, {sys.path[0]!r})
+
+from subinterpreters_shim import run_in_new_interpreter
+run_in_new_interpreter({inner_code!r})
+"""
+
+t = threading.Thread(target=run_in_new_interpreter, args=(outer_code,))
+t.start()
+
+while True:
+    time.sleep(1)

tests/integration/subinterpreters_program.py

@@ -0,0 +1,42 @@
+import os
+import sys
+import threading
+import time
+
+from subinterpreters_shim import run_in_new_interpreter
+
+NUM_INTERPRETERS = 3
+
+r_fd, w_fd = os.pipe()
+
+
+def start_interpreter_async(code):
+    t = threading.Thread(target=run_in_new_interpreter, args=(code,))
+    t.start()
+
+
+CODE = f"""
+import os
+import time
+
+os.write({w_fd}, b"x")
+
+while True:
+    time.sleep(1)
+"""
+
+for _ in range(NUM_INTERPRETERS):
+    start_interpreter_async(CODE)
+
+data = b""
+while len(data) < NUM_INTERPRETERS:
+    data += os.read(r_fd, NUM_INTERPRETERS - len(data))
+os.close(r_fd)
+os.close(w_fd)
+
+fifo = sys.argv[1]
+with open(fifo, "w") as f:
+    f.write("ready")
+
+while True:
+    time.sleep(1)

tests/integration/subinterpreters_shim.py

@@ -0,0 +1,20 @@
+try:
+    from concurrent import interpreters
+
+    def run_in_new_interpreter(code):
+        interpreters.create().exec(code)
+
+except ImportError:
+    try:
+        import _interpreters
+
+        def run_in_new_interpreter(code):
+            _interpreters.exec(_interpreters.create(), code)
+
+    except ImportError:
+        import _xxsubinterpreters
+
+        def run_in_new_interpreter(code):
+            _xxsubinterpreters.run_string(
+                _xxsubinterpreters.create(isolated=False), code
+            )

tests/integration/subinterpreters_two_chains_program.py

@@ -0,0 +1,42 @@
+import os
+import sys
+import threading
+import time
+
+from subinterpreters_shim import run_in_new_interpreter
+
+r_fd, w_fd = os.pipe()
+
+
+def launch_chain():
+    level3_code = f"import os, time; os.write({w_fd}, b'x'); time.sleep(86400)"
+    level2_code = (
+        f"import sys; sys.path.insert(0, {sys.path[0]!r}); "
+        f"from subinterpreters_shim import run_in_new_interpreter as f;"
+        f"f({level3_code!r})"
+    )
+    level1_code = (
+        f"import sys; sys.path.insert(0, {sys.path[0]!r}); "
+        f"from subinterpreters_shim import run_in_new_interpreter as f;"
+        f"f({level2_code!r})"
+    )
+    run_in_new_interpreter(level1_code)
+
+
+t1 = threading.Thread(target=launch_chain, daemon=True)
+t2 = threading.Thread(target=launch_chain, daemon=True)
+t1.start()
+t2.start()
+
+data = b""
+while len(data) < 2:
+    data += os.read(r_fd, 2 - len(data))
+os.close(r_fd)
+os.close(w_fd)
+
+fifo = sys.argv[1]
+with open(fifo, "w") as f:
+    f.write("ready")
+
+while True:
+    time.sleep(1)

tests/integration/subinterpreters_with_threads_program.py

@@ -0,0 +1,62 @@
+import os
+import sys
+import threading
+import time
+
+from subinterpreters_shim import run_in_new_interpreter
+
+NUM_INTERPRETERS = 2
+NUM_THREADS_PER_SUBINTERPRETER = 2
+
+r_fd, w_fd = os.pipe()
+
+
+def start_interpreter_async(code):
+    t = threading.Thread(target=run_in_new_interpreter, args=(code,))
+    t.daemon = True
+    t.start()
+    return t
+
+
+CODE = """\
+import os
+import threading
+import time
+
+NUM_THREADS = 2
+
+def worker():
+    os.write(%d, b"x")
+    while True:
+        time.sleep(1)
+
+threads = []
+for _ in range(NUM_THREADS):
+    t = threading.Thread(target=worker)
+    t.start()
+    threads.append(t)
+
+os.write(%d, b"x")
+while True:
+    time.sleep(1)
+""" % (w_fd, w_fd)
+
+threads = []
+for _ in range(NUM_INTERPRETERS):
+    t = start_interpreter_async(CODE)
+    threads.append(t)
+
+TOTAL_EXPECTED = NUM_INTERPRETERS * (NUM_THREADS_PER_SUBINTERPRETER + 1)
+
+data = b""
+while len(data) < TOTAL_EXPECTED:
+    data += os.read(r_fd, TOTAL_EXPECTED - len(data))
+os.close(r_fd)
+os.close(w_fd)
+
+fifo = sys.argv[1]
+with open(fifo, "w") as f:
+    f.write("ready")
+
+while True:
+    time.sleep(1)