Create test_repl.py and move run_pty() to test.support

Lib/test/support/__init__.py

@@ -32,6 +32,9 @@
 import unittest
 import urllib.error
 import warnings
+import selectors
+from contextlib import ExitStack
+from errno import EIO
 
 try:
     import multiprocessing.process
@@ -105,6 +108,7 @@
     "run_with_locale", "swap_item",
     "swap_attr", "Matcher", "set_memlimit", "SuppressCrashReport", "sortdict",
     "run_with_tz", "PGO", "missing_compiler_executable", "fd_count",
+    "run_pty",
     ]
 
 class Error(Exception):
@@ -2755,3 +2759,55 @@ def fd_count():
                 msvcrt.CrtSetReportMode(report_type, old_modes[report_type])
 
     return count
+
+def run_pty(script, input=b"dummy input\r", env=None):
+    pty = import_module('pty')
+    output = bytearray()
+    [master, slave] = pty.openpty()
+    if script is None:
+        args = (sys.executable, '-q')
+    else:
+        args = (sys.executable, '-c', script)
+    proc = subprocess.Popen(args, stdin=slave, stdout=slave, stderr=slave, env=env)
+    os.close(slave)
+    with ExitStack() as cleanup:
+        cleanup.enter_context(proc)
+        def terminate(proc):
+            try:
+                proc.terminate()
+            except ProcessLookupError:
+                # Workaround for Open/Net BSD bug (Issue 16762)
+                pass
+        cleanup.callback(terminate, proc)
+        cleanup.callback(os.close, master)
+        # Avoid using DefaultSelector and PollSelector. Kqueue() does not
+        # work with pseudo-terminals on OS X < 10.9 (Issue 20365) and Open
+        # BSD (Issue 20667). Poll() does not work with OS X 10.6 or 10.4
+        # either (Issue 20472). Hopefully the file descriptor is low enough
+        # to use with select().
+        sel = cleanup.enter_context(selectors.SelectSelector())
+        sel.register(master, selectors.EVENT_READ | selectors.EVENT_WRITE)
+        os.set_blocking(master, False)
+        while True:
+            for [_, events] in sel.select():
+                if events & selectors.EVENT_READ:
+                    try:
+                        chunk = os.read(master, 0x10000)
+                    except OSError as err:
+                        # Linux raises EIO when slave is closed (Issue 5380)
+                        if err.errno != EIO:
+                            raise
+                        chunk = b""
+                    if not chunk:
+                        return output
+                    output.extend(chunk)
+                if events & selectors.EVENT_WRITE:
+                    try:
+                        input = input[os.write(master, input):]
+                    except OSError as err:
+                        # Apparently EIO means the slave was closed
+                        if err.errno != EIO:
+                            raise
+                        input = b""  # Stop writing
+                    if not input:
+                        sel.modify(master, selectors.EVENT_READ)

Lib/test/test_readline.py

@@ -1,17 +1,11 @@
 """
 Very minimal unittests for parts of the readline module.
 """
-from contextlib import ExitStack
-from errno import EIO
 import os
-import selectors
-import subprocess
-import sys
 import tempfile
 import unittest
-from textwrap import dedent
 from test.support import (import_module, unlink, temp_dir, TESTFN, verbose,
-                          SuppressCrashReport)
+                         run_pty)
 from test.support.script_helper import assert_python_ok
 
 # Skip tests if there is no readline module
@@ -273,80 +267,5 @@ def test_history_size(self):
             self.assertEqual(lines[-1].strip(), b"last input")
 
 
-# Tests for the interactive interpreter.
-class TestInteractiveInterpreter(unittest.TestCase):
-
-    def test_interactive_no_memory(self):
-        # Issue #30696: Fix the interactive interpreter looping endlessly when
-        # no memory. Check also that the fix does not break the interactive
-        # loop when an exception is raised.
-        user_input = """
-            import sys, _testcapi
-            1/0
-            _testcapi.set_nomemory(0)
-            sys.exit(0)
-        """
-        user_input = dedent(user_input)
-        user_input = b'\r'.join(x.encode() for x in user_input.split('\n'))
-        user_input += b'\r'
-        with SuppressCrashReport():
-            output = run_pty(None, input=user_input)
-        self.assertIn(b"Fatal Python error: Cannot recover from MemoryErrors",
-                      output)
-
-
-def run_pty(script, input=b"dummy input\r", env=None):
-    pty = import_module('pty')
-    output = bytearray()
-    [master, slave] = pty.openpty()
-    if script is None:
-        args = (sys.executable, '-q')
-    else:
-        args = (sys.executable, '-c', script)
-    proc = subprocess.Popen(args, stdin=slave, stdout=slave, stderr=slave, env=env)
-    os.close(slave)
-    with ExitStack() as cleanup:
-        cleanup.enter_context(proc)
-        def terminate(proc):
-            try:
-                proc.terminate()
-            except ProcessLookupError:
-                # Workaround for Open/Net BSD bug (Issue 16762)
-                pass
-        cleanup.callback(terminate, proc)
-        cleanup.callback(os.close, master)
-        # Avoid using DefaultSelector and PollSelector. Kqueue() does not
-        # work with pseudo-terminals on OS X < 10.9 (Issue 20365) and Open
-        # BSD (Issue 20667). Poll() does not work with OS X 10.6 or 10.4
-        # either (Issue 20472). Hopefully the file descriptor is low enough
-        # to use with select().
-        sel = cleanup.enter_context(selectors.SelectSelector())
-        sel.register(master, selectors.EVENT_READ | selectors.EVENT_WRITE)
-        os.set_blocking(master, False)
-        while True:
-            for [_, events] in sel.select():
-                if events & selectors.EVENT_READ:
-                    try:
-                        chunk = os.read(master, 0x10000)
-                    except OSError as err:
-                        # Linux raises EIO when slave is closed (Issue 5380)
-                        if err.errno != EIO:
-                            raise
-                        chunk = b""
-                    if not chunk:
-                        return output
-                    output.extend(chunk)
-                if events & selectors.EVENT_WRITE:
-                    try:
-                        input = input[os.write(master, input):]
-                    except OSError as err:
-                        # Apparently EIO means the slave was closed
-                        if err.errno != EIO:
-                            raise
-                        input = b""  # Stop writing
-                    if not input:
-                        sel.modify(master, selectors.EVENT_READ)
-
-
 if __name__ == "__main__":
     unittest.main()

Lib/test/test_repl.py

@@ -0,0 +1,28 @@
+"""Test the interactive interpreter."""
+
+import unittest
+from textwrap import dedent
+from test.support import run_pty, SuppressCrashReport
+
+class TestInteractiveInterpreter(unittest.TestCase):
+
+    def test_no_memory(self):
+        # Issue #30696: Fix the interactive interpreter looping endlessly when
+        # no memory. Check also that the fix does not break the interactive
+        # loop when an exception is raised.
+        user_input = """
+            import sys, _testcapi
+            1/0
+            _testcapi.set_nomemory(0)
+            sys.exit(0)
+        """
+        user_input = dedent(user_input)
+        user_input = b'\r'.join(x.encode() for x in user_input.split('\n'))
+        user_input += b'\r'
+        with SuppressCrashReport():
+            output = run_pty(None, input=user_input)
+        self.assertIn(b"Fatal Python error: Cannot recover from MemoryErrors",
+                      output)
+
+if __name__ == "__main__":
+    unittest.main()