self.assertNotIn(signal.NSIG, s)
self.assertLess(len(s), signal.NSIG)
+ @unittest.skipUnless(sys.executable, "sys.executable required.")
+ def test_keyboard_interrupt_exit_code(self):
+ """KeyboardInterrupt triggers exit via SIGINT."""
+ process = subprocess.run(
+ [sys.executable, "-c",
+ "import os,signal; os.kill(os.getpid(), signal.SIGINT)"],
+ stderr=subprocess.PIPE)
+ self.assertIn(b"KeyboardInterrupt", process.stderr)
+ self.assertEqual(process.returncode, -signal.SIGINT)
+
+ @unittest.skipUnless(sys.executable, "sys.executable required.")
+ def test_keyboard_interrupt_communicated_to_shell(self):
+ """KeyboardInterrupt exits such that shells detect a ^C."""
+ try:
+ bash_proc = subprocess.run(
+ ["bash", "-c", 'echo "${BASH_VERSION}"'],
+ stdout=subprocess.PIPE, stderr=subprocess.DEVNULL)
+ except OSError:
+ raise unittest.SkipTest("bash required.")
+ if bash_proc.returncode:
+ raise unittest.SkipTest("could not determine bash version.")
+ bash_ver = bash_proc.stdout.decode("ascii").strip()
+ bash_major_minor = [int(n) for n in bash_ver.split(".", 2)[:2]]
+ if bash_major_minor < [4, 4]:
+ # In older versions of bash, -i does not work as needed
+ # _for this automated test_. Older shells do behave as
+ # expected in manual interactive use.
+ raise unittest.SkipTest(f"bash version {bash_ver} is too old.")
+ # The motivation for https://bugs.python.org/issue1054041.
+ # An _interactive_ shell (bash -i simulates that here) detects
+ # when a command exits via ^C and stops executing further
+ # commands.
+ process = subprocess.run(
+ ["bash", "-ic",
+ f"{sys.executable} -c 'import os,signal; os.kill(os.getpid(), signal.SIGINT)'; "
+ "echo TESTFAIL using bash \"${BASH_VERSION}\""],
+ stderr=subprocess.PIPE, stdout=subprocess.PIPE)
+ self.assertIn(b"KeyboardInterrupt", process.stderr)
+ # An interactive shell will abort if python exits properly to
+ # indicate that a KeyboardInterrupt occurred.
+ self.assertNotIn(b"TESTFAIL", process.stdout)
+
@unittest.skipUnless(sys.platform == "win32", "Windows specific")
class WindowsSignalTests(unittest.TestCase):
with self.assertRaises(ValueError):
signal.signal(7, handler)
+ @unittest.skipUnless(sys.executable, "sys.executable required.")
+ def test_keyboard_interrupt_exit_code(self):
+ """KeyboardInterrupt triggers an exit using STATUS_CONTROL_C_EXIT."""
+ # We don't test via os.kill(os.getpid(), signal.CTRL_C_EVENT) here
+ # as that requires setting up a console control handler in a child
+ # in its own process group. Doable, but quite complicated. (see
+ # @eryksun on https://github.com/python/cpython/pull/11862)
+ process = subprocess.run(
+ [sys.executable, "-c", "raise KeyboardInterrupt"],
+ stderr=subprocess.PIPE)
+ self.assertIn(b"KeyboardInterrupt", process.stderr)
+ STATUS_CONTROL_C_EXIT = 0xC000013A
+ self.assertEqual(process.returncode, STATUS_CONTROL_C_EXIT)
+
class WakeupFDTests(unittest.TestCase):
class RaiseSignalTest(unittest.TestCase):
def test_sigint(self):
- try:
+ with self.assertRaises(KeyboardInterrupt):
signal.raise_signal(signal.SIGINT)
- self.fail("Expected KeyInterrupt")
- except KeyboardInterrupt:
- pass
@unittest.skipIf(sys.platform != "win32", "Windows specific test")
def test_invalid_argument(self):
#include "pycore_pystate.h"
#include <locale.h>
+#ifdef HAVE_SIGNAL_H
+#include <signal.h>
+#endif
+#include <stdio.h>
+#if defined(HAVE_GETPID) && defined(HAVE_UNISTD_H)
+#include <unistd.h>
+#endif
#if defined(MS_WINDOWS) || defined(__CYGWIN__)
# include <windows.h>
pymain_free(pymain);
+ if (_Py_UnhandledKeyboardInterrupt) {
+ /* https://bugs.python.org/issue1054041 - We need to exit via the
+ * SIG_DFL handler for SIGINT if KeyboardInterrupt went unhandled.
+ * If we don't, a calling process such as a shell may not know
+ * about the user's ^C. https://www.cons.org/cracauer/sigint.html */
+#if defined(HAVE_GETPID) && !defined(MS_WINDOWS)
+ if (PyOS_setsig(SIGINT, SIG_DFL) == SIG_ERR) {
+ perror("signal"); /* Impossible in normal environments. */
+ } else {
+ kill(getpid(), SIGINT);
+ }
+ /* If setting SIG_DFL failed, or kill failed to terminate us,
+ * there isn't much else we can do aside from an error code. */
+#endif /* HAVE_GETPID && !MS_WINDOWS */
+#ifdef MS_WINDOWS
+ /* cmd.exe detects this, prints ^C, and offers to terminate. */
+ /* https://msdn.microsoft.com/en-us/library/cc704588.aspx */
+ pymain->status = STATUS_CONTROL_C_EXIT;
+#else
+ pymain->status = SIGINT + 128;
+#endif /* !MS_WINDOWS */
+ }
+
return pymain->status;
}
#include "Python-ast.h"
#undef Yield /* undefine macro conflicting with <winbase.h> */
+#include "pycore_pylifecycle.h"
#include "pycore_pystate.h"
#include "grammar.h"
#include "node.h"
PyErr_Restore(type, value, traceback);
}
+static PyObject *
+run_eval_code_obj(PyCodeObject *co, PyObject *globals, PyObject *locals)
+{
+ PyObject *v;
+ v = PyEval_EvalCode((PyObject*)co, globals, locals);
+ if (!v && PyErr_Occurred() == PyExc_KeyboardInterrupt) {
+ _Py_UnhandledKeyboardInterrupt = 1;
+ }
+ return v;
+}
+
static PyObject *
run_mod(mod_ty mod, PyObject *filename, PyObject *globals, PyObject *locals,
PyCompilerFlags *flags, PyArena *arena)
co = PyAST_CompileObject(mod, filename, flags, -1, arena);
if (co == NULL)
return NULL;
- v = PyEval_EvalCode((PyObject*)co, globals, locals);
+ v = run_eval_code_obj(co, globals, locals);
Py_DECREF(co);
return v;
}
}
fclose(fp);
co = (PyCodeObject *)v;
- v = PyEval_EvalCode((PyObject*)co, globals, locals);
+ v = run_eval_code_obj(co, globals, locals);
if (v && flags)
flags->cf_flags |= (co->co_flags & PyCF_MASK);
Py_DECREF(co);
projects / python / commitdiff