Lines Matching full:signal
7 import signal
29 for name in dir(signal):
30 sig = getattr(signal, name)
32 self.assertIsInstance(sig, signal.Handlers)
34 self.assertIsInstance(sig, signal.Sigmasks)
36 self.assertIsInstance(sig, signal.Signals)
38 self.assertIsInstance(sig, signal.Signals)
42 enum.IntEnum, 'Signals', 'signal',
47 source=signal,
49 enum._test_simple_enum(CheckedSignals, signal.Signals)
52 enum.IntEnum, 'Handlers', 'signal',
54 source=signal,
56 enum._test_simple_enum(CheckedHandlers, signal.Handlers)
58 Sigmasks = getattr(signal, 'Sigmasks', None)
61 enum.IntEnum, 'Sigmasks', 'signal',
63 source=signal,
70 for name in dir(signal):
71 value = getattr(signal, name)
73 self.assertEqual(value.__module__, 'signal')
85 self.assertRaises(ValueError, signal.getsignal, 4242)
87 self.assertRaises(ValueError, signal.signal, 4242,
90 self.assertRaises(ValueError, signal.strsignal, 4242)
93 self.assertRaises(TypeError, signal.signal,
94 signal.SIGUSR1, None)
97 hup = signal.signal(signal.SIGHUP, self.trivial_signal_handler)
98 self.assertIsInstance(hup, signal.Handlers)
99 self.assertEqual(signal.getsignal(signal.SIGHUP),
101 signal.signal(signal.SIGHUP, hup)
102 self.assertEqual(signal.getsignal(signal.SIGHUP), hup)
119 hup = signal.signal(signal.SIGHUP, handler)
120 self.assertIsInstance(hup, signal.Handlers)
121 self.assertEqual(signal.getsignal(signal.SIGHUP), handler)
122 signal.signal(signal.SIGHUP, hup)
123 self.assertEqual(signal.getsignal(signal.SIGHUP), hup)
129 self.assertIn("Interrupt", signal.strsignal(signal.SIGINT))
130 self.assertIn("Terminated", signal.strsignal(signal.SIGTERM))
131 self.assertIn("Hangup", signal.strsignal(signal.SIGHUP))
140 hasattr(signal, "valid_signals"),
141 "requires signal.valid_signals"
144 s = signal.valid_signals()
146 self.assertIn(signal.Signals.SIGINT, s)
147 self.assertIn(signal.Signals.SIGALRM, s)
149 self.assertNotIn(signal.NSIG, s)
150 self.assertLess(len(s), signal.NSIG)
153 # signal module have a number in the [0; signal.NSIG-1] range.
154 for name in dir(signal):
161 signum = getattr(signal, name)
163 self.assertLess(signum, signal.NSIG)
171 "import os, signal, time\n"
172 "os.kill(os.getpid(), signal.SIGINT)\n"
176 self.assertEqual(process.returncode, -signal.SIGINT)
178 # via a signal. POSIX shells do more than look at the 8 bit value.
187 s = signal.valid_signals()
190 self.assertIn(signal.Signals.SIGINT, s)
192 self.assertNotIn(signal.NSIG, s)
193 self.assertLess(len(s), signal.NSIG)
199 for sig in (signal.SIGABRT, signal.SIGBREAK, signal.SIGFPE,
200 signal.SIGILL, signal.SIGINT, signal.SIGSEGV,
201 signal.SIGTERM):
204 if signal.getsignal(sig) is not None:
205 signal.signal(sig, signal.signal(sig, handler))
211 signal.signal(-1, handler)
214 signal.signal(7, handler)
220 # We don't test via os.kill(os.getpid(), signal.CTRL_C_EVENT) here
237 signal.set_wakeup_fd(signum=signal.SIGINT)
241 signal.set_wakeup_fd(signal.SIGINT, False)
246 signal.set_wakeup_fd, fd)
254 signal.set_wakeup_fd, fd)
272 signal.set_wakeup_fd(w1)
273 self.assertEqual(signal.set_wakeup_fd(w2), w1)
274 self.assertEqual(signal.set_wakeup_fd(-1), w2)
275 self.assertEqual(signal.set_wakeup_fd(-1), -1)
290 signal.set_wakeup_fd(fd1)
291 self.assertEqual(signal.set_wakeup_fd(fd2), fd1)
292 self.assertEqual(signal.set_wakeup_fd(-1), fd2)
293 self.assertEqual(signal.set_wakeup_fd(-1), -1)
308 signal.set_wakeup_fd(wfd)
314 signal.set_wakeup_fd(wfd)
315 signal.set_wakeup_fd(-1)
326 import signal
345 signal.signal(signal.SIGALRM, handler)
348 signal.set_wakeup_fd(write)
362 # Issue #16105: write() errors in the C signal handler should not
369 import signal
376 signal.signal(signal.SIGALRM, handler)
381 signal.set_wakeup_fd(r)
384 signal.raise_signal(signal.SIGALRM)
388 if ('Exception ignored when trying to write to the signal wakeup fd'
425 signal.signal(signal.SIGALRM, handler)
427 signal.alarm(1)
429 # We attempt to get a signal during the sleep,
444 """, signal.SIGALRM)
459 signal.signal(signal.SIGALRM, handler)
461 signal.alarm(1)
463 # We attempt to get a signal during the select call
474 """, signal.SIGALRM)
478 signal.signal(signal.SIGUSR1, handler)
479 signal.raise_signal(signal.SIGUSR1)
480 signal.raise_signal(signal.SIGALRM)
481 """, signal.SIGUSR1, signal.SIGALRM)
483 @unittest.skipUnless(hasattr(signal, 'pthread_sigmask'),
484 'need signal.pthread_sigmask()')
487 signum1 = signal.SIGUSR1
488 signum2 = signal.SIGUSR2
490 signal.signal(signum1, handler)
491 signal.signal(signum2, handler)
493 signal.pthread_sigmask(signal.SIG_BLOCK, (signum1, signum2))
494 signal.raise_signal(signum1)
495 signal.raise_signal(signum2)
496 # Unblocking the 2 signals calls the C signal handler twice
497 signal.pthread_sigmask(signal.SIG_UNBLOCK, (signum1, signum2))
498 """, signal.SIGUSR1, signal.SIGUSR2, ordered=False)
508 import signal
513 signum = signal.SIGINT
519 signal.signal(signum, handler)
523 signal.set_wakeup_fd(write.fileno())
525 signal.raise_signal(signum)
549 import signal
556 signum = signal.SIGINT
561 signal.signal(signum, handler)
567 signal.set_wakeup_fd(write.fileno())
574 signal.raise_signal(signum)
577 if ('Exception ignored when trying to {action} to the signal wakeup fd'
592 import signal
599 signum = signal.SIGINT
606 signal.signal(signum, handler)
646 # By default, we get a warning when a signal arrives
648 'to the signal wakeup fd')
649 signal.set_wakeup_fd(write.fileno())
652 signal.raise_signal(signum)
660 signal.set_wakeup_fd(write.fileno(), warn_on_full_buffer=True)
663 signal.raise_signal(signum)
671 signal.set_wakeup_fd(write.fileno(), warn_on_full_buffer=False)
674 signal.raise_signal(signum)
683 signal.set_wakeup_fd(write.fileno())
686 signal.raise_signal(signum)
698 @unittest.skipUnless(hasattr(signal, 'siginterrupt'), "needs signal.siginterrupt()")
704 """Perform a read during which a signal will arrive. Return True if the
705 read is interrupted by the signal and raises an exception. Return False
709 # blocking read and to not touch signal handling in this process
713 import signal
722 signal.signal(signal.SIGALRM, handler)
724 signal.siginterrupt(signal.SIGALRM, interrupt)
733 signal.alarm(1)
764 # If a signal handler is installed and siginterrupt is not called
765 # at all, when that signal arrives, it interrupts a syscall that's in
771 # If a signal handler is installed and siginterrupt is called with
772 # a true value for the second argument, when that signal arrives, it
779 # If a signal handler is installed and siginterrupt is called with
780 # a false value for the second argument, when that signal arrives, it
787 @unittest.skipUnless(hasattr(signal, 'getitimer') and hasattr(signal, 'setitimer'),
788 "needs signal.getitimer() and signal.setitimer()")
794 self.old_alarm = signal.signal(signal.SIGALRM, self.sig_alrm)
797 signal.signal(signal.SIGALRM, self.old_alarm)
800 signal.setitimer(self.itimer, 0)
810 raise signal.ItimerError("setitimer didn't disable ITIMER_VIRTUAL "
814 signal.setitimer(signal.ITIMER_VIRTUAL, 0)
820 signal.setitimer(signal.ITIMER_PROF, 0)
825 self.assertRaises(signal.ItimerError, signal.setitimer, -1, 0)
828 self.assertRaises(signal.ItimerError,
829 signal.setitimer, signal.ITIMER_REAL, -1)
832 self.itimer = signal.ITIMER_REAL
833 signal.setitimer(self.itimer, 1.0)
834 signal.pause()
841 self.itimer = signal.ITIMER_VIRTUAL
842 signal.signal(signal.SIGVTALRM, self.sig_vtalrm)
843 signal.setitimer(self.itimer, 0.3, 0.2)
848 if signal.getitimer(self.itimer) == (0.0, 0.0):
853 self.assertEqual(signal.getitimer(self.itimer), (0.0, 0.0))
858 self.itimer = signal.ITIMER_PROF
859 signal.signal(signal.SIGPROF, self.sig_prof)
860 signal.setitimer(self.itimer, 0.2, 0.2)
865 if signal.getitimer(self.itimer) == (0.0, 0.0):
870 self.assertEqual(signal.getitimer(self.itimer), (0.0, 0.0))
878 self.itimer = signal.ITIMER_REAL
879 signal.setitimer(self.itimer, 1e-6)
889 @unittest.skipUnless(hasattr(signal, 'sigpending'),
890 'need signal.sigpending()')
892 self.assertEqual(signal.sigpending(), set())
894 @unittest.skipUnless(hasattr(signal, 'pthread_sigmask'),
895 'need signal.pthread_sigmask()')
896 @unittest.skipUnless(hasattr(signal, 'sigpending'),
897 'need signal.sigpending()')
901 import signal
906 signum = signal.SIGUSR1
907 signal.signal(signum, handler)
909 signal.pthread_sigmask(signal.SIG_BLOCK, [signum])
911 pending = signal.sigpending()
913 assert isinstance(sig, signal.Signals), repr(pending)
917 signal.pthread_sigmask(signal.SIG_UNBLOCK, [signum])
925 @unittest.skipUnless(hasattr(signal, 'pthread_kill'),
926 'need signal.pthread_kill()')
930 import signal
934 signum = signal.SIGUSR1
939 signal.signal(signum, handler)
943 signal.pthread_kill(tid, signum)
951 @unittest.skipUnless(hasattr(signal, 'pthread_sigmask'),
952 'need signal.pthread_sigmask()')
956 blocked: number of the blocked signal
959 import signal
961 from signal import Signals
969 signum = signal.SIGALRM
971 # child: block and wait the signal
973 signal.signal(signum, handler)
974 signal.pthread_sigmask(signal.SIG_BLOCK, [blocked])
981 signal.pthread_sigmask(signal.SIG_UNBLOCK, [blocked])
983 print("the signal handler has been called",
992 # sig*wait* must be called with the signal blocked: since the current
997 @unittest.skipUnless(hasattr(signal, 'sigwait'),
998 'need signal.sigwait()')
1000 self.wait_helper(signal.SIGALRM, '''
1002 signal.alarm(1)
1003 received = signal.sigwait([signum])
1004 assert isinstance(received, signal.Signals), received
1009 @unittest.skipUnless(hasattr(signal, 'sigwaitinfo'),
1010 'need signal.sigwaitinfo()')
1012 self.wait_helper(signal.SIGALRM, '''
1014 signal.alarm(1)
1015 info = signal.sigwaitinfo([signum])
1020 @unittest.skipUnless(hasattr(signal, 'sigtimedwait'),
1021 'need signal.sigtimedwait()')
1023 self.wait_helper(signal.SIGALRM, '''
1025 signal.alarm(1)
1026 info = signal.sigtimedwait([signum], 10.1000)
1031 @unittest.skipUnless(hasattr(signal, 'sigtimedwait'),
1032 'need signal.sigtimedwait()')
1035 self.wait_helper(signal.SIGALRM, '''
1039 info = signal.sigtimedwait([signum], 0)
1044 @unittest.skipUnless(hasattr(signal, 'sigtimedwait'),
1045 'need signal.sigtimedwait()')
1047 self.wait_helper(signal.SIGALRM, '''
1049 received = signal.sigtimedwait([signum], 1.0)
1054 @unittest.skipUnless(hasattr(signal, 'sigtimedwait'),
1055 'need signal.sigtimedwait()')
1057 signum = signal.SIGALRM
1058 self.assertRaises(ValueError, signal.sigtimedwait, [signum], -1.0)
1060 @unittest.skipUnless(hasattr(signal, 'sigwait'),
1061 'need signal.sigwait()')
1062 @unittest.skipUnless(hasattr(signal, 'pthread_sigmask'),
1063 'need signal.pthread_sigmask()')
1071 import os, threading, sys, time, signal
1074 signum = signal.SIGUSR1
1081 # the signal must be blocked by all the threads
1082 signal.pthread_sigmask(signal.SIG_BLOCK, [signum])
1085 received = signal.sigwait([signum])
1091 # unblock the signal, which should have been cleared by sigwait()
1092 signal.pthread_sigmask(signal.SIG_UNBLOCK, [signum])
1095 @unittest.skipUnless(hasattr(signal, 'pthread_sigmask'),
1096 'need signal.pthread_sigmask()')
1098 self.assertRaises(TypeError, signal.pthread_sigmask)
1099 self.assertRaises(TypeError, signal.pthread_sigmask, 1)
1100 self.assertRaises(TypeError, signal.pthread_sigmask, 1, 2, 3)
1101 self.assertRaises(OSError, signal.pthread_sigmask, 1700, [])
1103 signal.pthread_sigmask(signal.SIG_BLOCK, [signal.NSIG])
1105 signal.pthread_sigmask(signal.SIG_BLOCK, [0])
1107 signal.pthread_sigmask(signal.SIG_BLOCK, [1<<1000])
1109 @unittest.skipUnless(hasattr(signal, 'pthread_sigmask'),
1110 'need signal.pthread_sigmask()')
1112 s = signal.pthread_sigmask(signal.SIG_BLOCK, signal.valid_signals())
1113 self.addCleanup(signal.pthread_sigmask, signal.SIG_SETMASK, s)
1115 s = signal.pthread_sigmask(signal.SIG_UNBLOCK, signal.valid_signals())
1116 self.assertLessEqual(s, signal.valid_signals())
1118 @unittest.skipUnless(hasattr(signal, 'pthread_sigmask'),
1119 'need signal.pthread_sigmask()')
1123 import signal
1134 assert isinstance(sig, signal.Signals), repr(sig)
1137 sigmask = signal.pthread_sigmask(signal.SIG_BLOCK, [])
1141 signum = signal.SIGUSR1
1143 # Install our signal handler
1144 old_handler = signal.signal(signum, handler)
1146 # Unblock SIGUSR1 (and copy the old mask) to test our signal handler
1147 old_mask = signal.pthread_sigmask(signal.SIG_UNBLOCK, [signum])
1156 # Block and then raise SIGUSR1. The signal is blocked: the signal
1157 # handler is not called, and the signal is now pending
1158 mask = signal.pthread_sigmask(signal.SIG_BLOCK, [signum])
1172 # unblock the pending signal calls immediately the signal handler
1173 signal.pthread_sigmask(signal.SIG_UNBLOCK, [signum])
1196 @unittest.skipUnless(hasattr(signal, 'pthread_kill'),
1197 'need signal.pthread_kill()')
1200 # Test that a signal can be sent to the main thread with pthread_kill()
1204 import signal
1210 signal.signal(signal.SIGUSR1, handler)
1211 signal.pthread_kill(threading.get_ident(), signal.SIGUSR1)
1225 Stress signal delivery, especially when a signal arrives in
1226 the middle of recomputing the signal state or executing
1227 previously tripped signal handlers.
1231 old_handler = signal.signal(signum, handler)
1232 self.addCleanup(signal.signal, signum, old_handler)
1244 signal.setitimer(signal.ITIMER_REAL, 1e-6)
1246 self.addCleanup(signal.setitimer, signal.ITIMER_REAL, 0)
1247 self.setsig(signal.SIGALRM, handler)
1272 @unittest.skipUnless(hasattr(signal, "setitimer"),
1276 This test uses dependent signal handlers.
1284 # triggering a race condition. Ideally the signal is received
1285 # when inside critical signal-handling routines such as
1287 signal.setitimer(signal.ITIMER_REAL, 1e-6 + random.random() * 1e-5)
1295 self.setsig(signal.SIGPROF, first_handler)
1296 self.setsig(signal.SIGUSR1, first_handler)
1297 self.setsig(signal.SIGALRM, second_handler) # for ITIMER_REAL
1303 os.kill(os.getpid(), signal.SIGPROF)
1305 # Wait for handlers to run to avoid signal coalescing
1309 os.kill(os.getpid(), signal.SIGUSR1)
1318 @unittest.skipUnless(hasattr(signal, "setitimer"),
1322 This test uses simultaneous signal handlers.
1331 # another signal – see Android/testbed/app/src/main/python/main.py.
1332 # So we use a different signal.
1333 self.setsig(signal.SIGUSR2, handler)
1334 self.setsig(signal.SIGALRM, handler) # for ITIMER_REAL
1340 signal.setitimer(signal.ITIMER_REAL, 1e-6 + random.random() * 1e-5)
1341 os.kill(os.getpid(), signal.SIGUSR2)
1344 # Wait for handlers to run to avoid signal coalescing
1354 @unittest.skipUnless(hasattr(signal, "SIGUSR1"),
1358 # bpo-43406: race condition between trip_signal() and signal.signal
1359 signum = signal.SIGUSR1
1371 signal.raise_signal(signum)
1378 for handler in [custom_handler, signal.SIG_IGN]:
1379 signal.signal(signum, handler)
1381 old_handler = signal.signal(signum, custom_handler)
1382 self.addCleanup(signal.signal, signum, old_handler)
1395 # a signal is ignored due to the aforementioned
1399 f"Signal {signum:d} ignored due to race condition",
1418 signal.raise_signal(signal.SIGINT)
1424 signal.raise_signal(SIGHUP)
1437 old_signal = signal.signal(signal.SIGINT, handler)
1438 self.addCleanup(signal.signal, signal.SIGINT, old_signal)
1440 signal.raise_signal(signal.SIGINT)
1455 self.assertIn(b'OSError: Signal 2 ignored due to race condition', err)
1462 hasattr(signal, "pidfd_send_signal"),
1467 signal.pidfd_send_signal(0, signal.SIGINT)
1476 signal.pidfd_send_signal(my_pidfd, signal.SIGINT, object(), 0)
1478 signal.pidfd_send_signal(my_pidfd, signal.SIGINT)