tests: Add Ctrl-C interrupt tests using extended repl_ framework.

Extends the repl_ test framework to support signal generation by
configuring terminal attributes (ISIG, VINTR) and setting up the PTY
as the controlling terminal for the MicroPython subprocess.

This allows testing Ctrl-C interrupt behavior in both paste mode and
during code execution using the standard repl_ test syntax with {\x03}
for Ctrl-C control codes.

Tests added:
- repl_ctrl_c_interrupt.py: Tests Ctrl-C cancels paste mode
- repl_ctrl_c_interrupt_execution.py: Tests Ctrl-C interrupts running code

Changes to run-tests.py:
- Added terminal configuration to enable ISIG flag and VINTR mapping
- Added setup_controlling_terminal() to make PTY the controlling terminal
- Modified repl_ Popen call to use preexec_fn for proper signal delivery

Signed-off-by: Andrew Leech <[email protected]>

Author: pi-anl

pyproject.toml

@@ -35,6 +35,8 @@ exclude = [  # Ruff finds Python SyntaxError in these files
   "tests/cmdline/repl_autoindent.py",
   "tests/cmdline/repl_basic.py",
   "tests/cmdline/repl_cont.py",
+  "tests/cmdline/repl_ctrl_c_paste_cancel.py",
+  "tests/cmdline/repl_ctrl_c_interrupt_execution.py",
   "tests/cmdline/repl_emacs_keys.py",
   "tests/cmdline/repl_paste.py",
   "tests/cmdline/repl_words_move.py",

tests/cmdline/repl_ctrl_c_interrupt_execution.py

@@ -0,0 +1,7 @@
+# Test Ctrl-C interrupts executing code
+# The test framework sends lines sequentially without waiting for completion,
+# so Ctrl-C is sent while sleep(30) is still running, triggering SIGINT.
+import time
+time.sleep(30)
+{\x03}
+print('repl still responds')

tests/cmdline/repl_ctrl_c_interrupt_execution.py.exp

@@ -0,0 +1,14 @@
+MicroPython \.\+ version
+Use Ctrl-D to exit, Ctrl-E for paste mode
+>>> # Test Ctrl-C interrupts executing code
+>>> # The test framework sends lines sequentially without waiting for completion,
+>>> # so Ctrl-C is sent while sleep(30) is still running, triggering SIGINT.
+>>> import time
+>>> time.sleep(30)
+^C
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+KeyboardInterrupt: 
+>>> print('repl still responds')
+repl still responds
+>>> 

tests/cmdline/repl_ctrl_c_paste_cancel.py

@@ -0,0 +1,9 @@
+# Test that Ctrl-C cancels paste mode
+
+# Test paste mode Ctrl-C cancel
+{\x05}
+print('paste mode')
+{\x03}
+
+# Verify REPL works
+print('REPL works')

tests/cmdline/repl_ctrl_c_paste_cancel.py.exp

@@ -0,0 +1,16 @@
+MicroPython \.\+ version
+Use Ctrl-D to exit, Ctrl-E for paste mode
+>>> # Test that Ctrl-C cancels paste mode
+>>> 
+>>> # Test paste mode Ctrl-C cancel
+>>> 
+paste mode; Ctrl-C to cancel, Ctrl-D to finish
+=== 
+=== print('paste mode')
+=== 
+>>> 
+>>> 
+>>> # Verify REPL works
+>>> print('REPL works')
+REPL works
+>>> 

tests/run-tests.py

@@ -60,6 +60,23 @@ def base_path(*p):
 # Set PYTHONIOENCODING so that CPython will use utf-8 on systems which set another encoding in the locale
 os.environ["PYTHONIOENCODING"] = "utf-8"
 
+
+def normalize_newlines(data):
+    """Normalize newline variations to \\n.
+
+    Only normalizes actual line endings, not literal \\r characters in strings.
+    Handles \\r\\r\\n and \\r\\n cases to ensure consistent comparison
+    across different platforms and terminals.
+    """
+    if isinstance(data, bytes):
+        # Handle PTY double-newline issue first
+        data = data.replace(b"\r\r\n", b"\n")
+        # Then handle standard Windows line endings
+        data = data.replace(b"\r\n", b"\n")
+        # Don't convert standalone \r as it might be literal content
+    return data
+
+
 # Code to allow a target MicroPython to import an .mpy from RAM
 # Note: the module is named `__injected_test` but it needs to have `__name__` set to
 # `__main__` so that the test sees itself as the main module, eg so unittest works.
@@ -602,6 +619,8 @@ def run_micropython(pyb, args, test_file, test_file_abspath, is_special=False):
                     # Need to use a PTY to test command line editing
                     try:
                         import pty
+                        import termios
+                        import fcntl
                     except ImportError:
                         # in case pty module is not available, like on Windows
                         return b"SKIP\n"
@@ -632,24 +651,44 @@ def send_get(what):
                     with open(test_file, "rb") as f:
                         # instead of: output_mupy = subprocess.check_output(args, stdin=f)
                         master, slave = pty.openpty()
-                        p = subprocess.Popen(
-                            args, stdin=slave, stdout=slave, stderr=subprocess.STDOUT, bufsize=0
-                        )
-                        banner = get(True)
-                        output_mupy = banner + b"".join(send_get(line) for line in f)
-                        send_get(b"\x04")  # exit the REPL, so coverage info is saved
-                        # At this point the process might have exited already, but trying to
-                        # kill it 'again' normally doesn't result in exceptions as Python and/or
-                        # the OS seem to try to handle this nicely. When running Linux on WSL
-                        # though, the situation differs and calling Popen.kill after the process
-                        # terminated results in a ProcessLookupError. Just catch that one here
-                        # since we just want the process to be gone and that's the case.
                         try:
-                            p.kill()
-                        except ProcessLookupError:
-                            pass
-                        os.close(master)
-                        os.close(slave)
+                            # Configure terminal attributes to enable Ctrl-C signal generation
+                            attrs = termios.tcgetattr(slave)
+                            attrs[3] |= termios.ISIG  # Enable signal generation (ISIG flag)
+                            attrs[6][termios.VINTR] = 3  # Set Ctrl-C (0x03) as interrupt character
+                            termios.tcsetattr(slave, termios.TCSANOW, attrs)
+
+                            def setup_controlling_terminal():
+                                """Set up the child process with the PTY as controlling terminal."""
+                                os.setsid()  # Create a new session
+                                fcntl.ioctl(
+                                    0, termios.TIOCSCTTY, 0
+                                )  # Make PTY the controlling terminal
+
+                            p = subprocess.Popen(
+                                args,
+                                stdin=slave,
+                                stdout=slave,
+                                stderr=subprocess.STDOUT,
+                                bufsize=0,
+                                preexec_fn=setup_controlling_terminal,
+                            )
+                            banner = get(True)
+                            output_mupy = banner + b"".join(send_get(line) for line in f)
+                            send_get(b"\x04")  # exit the REPL, so coverage info is saved
+                            # At this point the process might have exited already, but trying to
+                            # kill it 'again' normally doesn't result in exceptions as Python and/or
+                            # the OS seem to try to handle this nicely. When running Linux on WSL
+                            # though, the situation differs and calling Popen.kill after the process
+                            # terminated results in a ProcessLookupError. Just catch that one here
+                            # since we just want the process to be gone and that's the case.
+                            try:
+                                p.kill()
+                            except ProcessLookupError:
+                                pass
+                        finally:
+                            os.close(master)
+                            os.close(slave)
                 else:
                     output_mupy = subprocess.check_output(
                         args + [test_file], stderr=subprocess.STDOUT
@@ -705,7 +744,7 @@ def send_get(what):
         )
 
     # canonical form for all ports/platforms is to use \n for end-of-line
-    output_mupy = output_mupy.replace(b"\r\n", b"\n")
+    output_mupy = normalize_newlines(output_mupy)
 
     # don't try to convert the output if we should skip this test
     if had_crash or output_mupy in (b"SKIP\n", b"SKIP-TOO-LARGE\n", b"CRASH"):