Lines Matching refs:signal
6 import signal
27 for name in dir(signal):
28 sig = getattr(signal, name)
30 self.assertIsInstance(sig, signal.Handlers)
32 self.assertIsInstance(sig, signal.Sigmasks)
34 self.assertIsInstance(sig, signal.Signals)
36 self.assertIsInstance(sig, signal.Signals)
40 enum.IntEnum, 'Signals', 'signal',
45 source=signal,
47 enum._test_simple_enum(CheckedSignals, signal.Signals)
50 enum.IntEnum, 'Handlers', 'signal',
52 source=signal,
54 enum._test_simple_enum(CheckedHandlers, signal.Handlers)
56 Sigmasks = getattr(signal, 'Sigmasks', None)
59 enum.IntEnum, 'Sigmasks', 'signal',
61 source=signal,
68 for name in dir(signal):
69 value = getattr(signal, name)
71 self.assertEqual(value.__module__, 'signal')
80 self.assertRaises(ValueError, signal.getsignal, 4242)
82 self.assertRaises(ValueError, signal.signal, 4242,
85 self.assertRaises(ValueError, signal.strsignal, 4242)
88 self.assertRaises(TypeError, signal.signal,
89 signal.SIGUSR1, None)
92 hup = signal.signal(signal.SIGHUP, self.trivial_signal_handler)
93 self.assertIsInstance(hup, signal.Handlers)
94 self.assertEqual(signal.getsignal(signal.SIGHUP),
96 signal.signal(signal.SIGHUP, hup)
97 self.assertEqual(signal.getsignal(signal.SIGHUP), hup)
100 self.assertIn("Interrupt", signal.strsignal(signal.SIGINT))
101 self.assertIn("Terminated", signal.strsignal(signal.SIGTERM))
102 self.assertIn("Hangup", signal.strsignal(signal.SIGHUP))
111 hasattr(signal, "valid_signals"),
112 "requires signal.valid_signals"
115 s = signal.valid_signals()
117 self.assertIn(signal.Signals.SIGINT, s)
118 self.assertIn(signal.Signals.SIGALRM, s)
120 self.assertNotIn(signal.NSIG, s)
121 self.assertLess(len(s), signal.NSIG)
124 # signal module have a number in the [0; signal.NSIG-1] range.
125 for name in dir(signal):
132 signum = getattr(signal, name)
134 self.assertLess(signum, signal.NSIG)
142 "import os, signal, time\n"
143 "os.kill(os.getpid(), signal.SIGINT)\n"
147 self.assertEqual(process.returncode, -signal.SIGINT)
149 # via a signal. POSIX shells do more than look at the 8 bit value.
158 s = signal.valid_signals()
161 self.assertIn(signal.Signals.SIGINT, s)
163 self.assertNotIn(signal.NSIG, s)
164 self.assertLess(len(s), signal.NSIG)
170 for sig in (signal.SIGABRT, signal.SIGBREAK, signal.SIGFPE,
171 signal.SIGILL, signal.SIGINT, signal.SIGSEGV,
172 signal.SIGTERM):
175 if signal.getsignal(sig) is not None:
176 signal.signal(sig, signal.signal(sig, handler))
182 signal.signal(-1, handler)
185 signal.signal(7, handler)
191 # We don't test via os.kill(os.getpid(), signal.CTRL_C_EVENT) here
208 signal.set_wakeup_fd(signum=signal.SIGINT)
212 signal.set_wakeup_fd(signal.SIGINT, False)
217 signal.set_wakeup_fd, fd)
225 signal.set_wakeup_fd, fd)
243 signal.set_wakeup_fd(w1)
244 self.assertEqual(signal.set_wakeup_fd(w2), w1)
245 self.assertEqual(signal.set_wakeup_fd(-1), w2)
246 self.assertEqual(signal.set_wakeup_fd(-1), -1)
261 signal.set_wakeup_fd(fd1)
262 self.assertEqual(signal.set_wakeup_fd(fd2), fd1)
263 self.assertEqual(signal.set_wakeup_fd(-1), fd2)
264 self.assertEqual(signal.set_wakeup_fd(-1), -1)
279 signal.set_wakeup_fd(wfd)
285 signal.set_wakeup_fd(wfd)
286 signal.set_wakeup_fd(-1)
297 import signal
316 signal.signal(signal.SIGALRM, handler)
319 signal.set_wakeup_fd(write)
333 # Issue #16105: write() errors in the C signal handler should not
340 import signal
347 signal.signal(signal.SIGALRM, handler)
352 signal.set_wakeup_fd(r)
355 signal.raise_signal(signal.SIGALRM)
359 if ('Exception ignored when trying to write to the signal wakeup fd'
396 signal.signal(signal.SIGALRM, handler)
398 signal.alarm(1)
400 # We attempt to get a signal during the sleep,
415 """, signal.SIGALRM)
430 signal.signal(signal.SIGALRM, handler)
432 signal.alarm(1)
434 # We attempt to get a signal during the select call
445 """, signal.SIGALRM)
449 signal.signal(signal.SIGUSR1, handler)
450 signal.raise_signal(signal.SIGUSR1)
451 signal.raise_signal(signal.SIGALRM)
452 """, signal.SIGUSR1, signal.SIGALRM)
454 @unittest.skipUnless(hasattr(signal, 'pthread_sigmask'),
455 'need signal.pthread_sigmask()')
458 signum1 = signal.SIGUSR1
459 signum2 = signal.SIGUSR2
461 signal.signal(signum1, handler)
462 signal.signal(signum2, handler)
464 signal.pthread_sigmask(signal.SIG_BLOCK, (signum1, signum2))
465 signal.raise_signal(signum1)
466 signal.raise_signal(signum2)
467 # Unblocking the 2 signals calls the C signal handler twice
468 signal.pthread_sigmask(signal.SIG_UNBLOCK, (signum1, signum2))
469 """, signal.SIGUSR1, signal.SIGUSR2, ordered=False)
479 import signal
484 signum = signal.SIGINT
490 signal.signal(signum, handler)
494 signal.set_wakeup_fd(write.fileno())
496 signal.raise_signal(signum)
520 import signal
527 signum = signal.SIGINT
532 signal.signal(signum, handler)
538 signal.set_wakeup_fd(write.fileno())
545 signal.raise_signal(signum)
548 if ('Exception ignored when trying to {action} to the signal wakeup fd'
563 import signal
570 signum = signal.SIGINT
577 signal.signal(signum, handler)
617 # By default, we get a warning when a signal arrives
619 'to the signal wakeup fd')
620 signal.set_wakeup_fd(write.fileno())
623 signal.raise_signal(signum)
631 signal.set_wakeup_fd(write.fileno(), warn_on_full_buffer=True)
634 signal.raise_signal(signum)
642 signal.set_wakeup_fd(write.fileno(), warn_on_full_buffer=False)
645 signal.raise_signal(signum)
654 signal.set_wakeup_fd(write.fileno())
657 signal.raise_signal(signum)
669 @unittest.skipUnless(hasattr(signal, 'siginterrupt'), "needs signal.siginterrupt()")
675 """Perform a read during which a signal will arrive. Return True if the
676 read is interrupted by the signal and raises an exception. Return False
680 # blocking read and to not touch signal handling in this process
684 import signal
693 signal.signal(signal.SIGALRM, handler)
695 signal.siginterrupt(signal.SIGALRM, interrupt)
704 signal.alarm(1)
735 # If a signal handler is installed and siginterrupt is not called
736 # at all, when that signal arrives, it interrupts a syscall that's in
742 # If a signal handler is installed and siginterrupt is called with
743 # a true value for the second argument, when that signal arrives, it
749 # If a signal handler is installed and siginterrupt is called with
750 # a false value for the second argument, when that signal arrives, it
757 @unittest.skipUnless(hasattr(signal, 'getitimer') and hasattr(signal, 'setitimer'),
758 "needs signal.getitimer() and signal.setitimer()")
764 self.old_alarm = signal.signal(signal.SIGALRM, self.sig_alrm)
767 signal.signal(signal.SIGALRM, self.old_alarm)
770 signal.setitimer(self.itimer, 0)
780 raise signal.ItimerError("setitimer didn't disable ITIMER_VIRTUAL "
784 signal.setitimer(signal.ITIMER_VIRTUAL, 0)
790 signal.setitimer(signal.ITIMER_PROF, 0)
795 self.assertRaises(signal.ItimerError, signal.setitimer, -1, 0)
798 self.assertRaises(signal.ItimerError,
799 signal.setitimer, signal.ITIMER_REAL, -1)
802 self.itimer = signal.ITIMER_REAL
803 signal.setitimer(self.itimer, 1.0)
804 signal.pause()
811 self.itimer = signal.ITIMER_VIRTUAL
812 signal.signal(signal.SIGVTALRM, self.sig_vtalrm)
813 signal.setitimer(self.itimer, 0.3, 0.2)
819 if signal.getitimer(self.itimer) == (0.0, 0.0):
826 self.assertEqual(signal.getitimer(self.itimer), (0.0, 0.0))
831 self.itimer = signal.ITIMER_PROF
832 signal.signal(signal.SIGPROF, self.sig_prof)
833 signal.setitimer(self.itimer, 0.2, 0.2)
839 if signal.getitimer(self.itimer) == (0.0, 0.0):
846 self.assertEqual(signal.getitimer(self.itimer), (0.0, 0.0))
854 self.itimer = signal.ITIMER_REAL
855 signal.setitimer(self.itimer, 1e-6)
865 @unittest.skipUnless(hasattr(signal, 'sigpending'),
866 'need signal.sigpending()')
868 self.assertEqual(signal.sigpending(), set())
870 @unittest.skipUnless(hasattr(signal, 'pthread_sigmask'),
871 'need signal.pthread_sigmask()')
872 @unittest.skipUnless(hasattr(signal, 'sigpending'),
873 'need signal.sigpending()')
877 import signal
882 signum = signal.SIGUSR1
883 signal.signal(signum, handler)
885 signal.pthread_sigmask(signal.SIG_BLOCK, [signum])
887 pending = signal.sigpending()
889 assert isinstance(sig, signal.Signals), repr(pending)
893 signal.pthread_sigmask(signal.SIG_UNBLOCK, [signum])
901 @unittest.skipUnless(hasattr(signal, 'pthread_kill'),
902 'need signal.pthread_kill()')
906 import signal
910 signum = signal.SIGUSR1
915 signal.signal(signum, handler)
919 signal.pthread_kill(tid, signum)
927 @unittest.skipUnless(hasattr(signal, 'pthread_sigmask'),
928 'need signal.pthread_sigmask()')
932 blocked: number of the blocked signal
935 import signal
937 from signal import Signals
945 signum = signal.SIGALRM
947 # child: block and wait the signal
949 signal.signal(signum, handler)
950 signal.pthread_sigmask(signal.SIG_BLOCK, [blocked])
957 signal.pthread_sigmask(signal.SIG_UNBLOCK, [blocked])
959 print("the signal handler has been called",
968 # sig*wait* must be called with the signal blocked: since the current
973 @unittest.skipUnless(hasattr(signal, 'sigwait'),
974 'need signal.sigwait()')
976 self.wait_helper(signal.SIGALRM, '''
978 signal.alarm(1)
979 received = signal.sigwait([signum])
980 assert isinstance(received, signal.Signals), received
985 @unittest.skipUnless(hasattr(signal, 'sigwaitinfo'),
986 'need signal.sigwaitinfo()')
988 self.wait_helper(signal.SIGALRM, '''
990 signal.alarm(1)
991 info = signal.sigwaitinfo([signum])
996 @unittest.skipUnless(hasattr(signal, 'sigtimedwait'),
997 'need signal.sigtimedwait()')
999 self.wait_helper(signal.SIGALRM, '''
1001 signal.alarm(1)
1002 info = signal.sigtimedwait([signum], 10.1000)
1007 @unittest.skipUnless(hasattr(signal, 'sigtimedwait'),
1008 'need signal.sigtimedwait()')
1011 self.wait_helper(signal.SIGALRM, '''
1015 info = signal.sigtimedwait([signum], 0)
1020 @unittest.skipUnless(hasattr(signal, 'sigtimedwait'),
1021 'need signal.sigtimedwait()')
1023 self.wait_helper(signal.SIGALRM, '''
1025 received = signal.sigtimedwait([signum], 1.0)
1030 @unittest.skipUnless(hasattr(signal, 'sigtimedwait'),
1031 'need signal.sigtimedwait()')
1033 signum = signal.SIGALRM
1034 self.assertRaises(ValueError, signal.sigtimedwait, [signum], -1.0)
1036 @unittest.skipUnless(hasattr(signal, 'sigwait'),
1037 'need signal.sigwait()')
1038 @unittest.skipUnless(hasattr(signal, 'pthread_sigmask'),
1039 'need signal.pthread_sigmask()')
1047 import os, threading, sys, time, signal
1050 signum = signal.SIGUSR1
1057 # the signal must be blocked by all the threads
1058 signal.pthread_sigmask(signal.SIG_BLOCK, [signum])
1061 received = signal.sigwait([signum])
1067 # unblock the signal, which should have been cleared by sigwait()
1068 signal.pthread_sigmask(signal.SIG_UNBLOCK, [signum])
1071 @unittest.skipUnless(hasattr(signal, 'pthread_sigmask'),
1072 'need signal.pthread_sigmask()')
1074 self.assertRaises(TypeError, signal.pthread_sigmask)
1075 self.assertRaises(TypeError, signal.pthread_sigmask, 1)
1076 self.assertRaises(TypeError, signal.pthread_sigmask, 1, 2, 3)
1077 self.assertRaises(OSError, signal.pthread_sigmask, 1700, [])
1079 signal.pthread_sigmask(signal.SIG_BLOCK, [signal.NSIG])
1081 signal.pthread_sigmask(signal.SIG_BLOCK, [0])
1083 signal.pthread_sigmask(signal.SIG_BLOCK, [1<<1000])
1085 @unittest.skipUnless(hasattr(signal, 'pthread_sigmask'),
1086 'need signal.pthread_sigmask()')
1088 s = signal.pthread_sigmask(signal.SIG_BLOCK, signal.valid_signals())
1089 self.addCleanup(signal.pthread_sigmask, signal.SIG_SETMASK, s)
1091 s = signal.pthread_sigmask(signal.SIG_UNBLOCK, signal.valid_signals())
1092 self.assertLessEqual(s, signal.valid_signals())
1094 @unittest.skipUnless(hasattr(signal, 'pthread_sigmask'),
1095 'need signal.pthread_sigmask()')
1099 import signal
1110 assert isinstance(sig, signal.Signals), repr(sig)
1113 sigmask = signal.pthread_sigmask(signal.SIG_BLOCK, [])
1117 signum = signal.SIGUSR1
1119 # Install our signal handler
1120 old_handler = signal.signal(signum, handler)
1122 # Unblock SIGUSR1 (and copy the old mask) to test our signal handler
1123 old_mask = signal.pthread_sigmask(signal.SIG_UNBLOCK, [signum])
1132 # Block and then raise SIGUSR1. The signal is blocked: the signal
1133 # handler is not called, and the signal is now pending
1134 mask = signal.pthread_sigmask(signal.SIG_BLOCK, [signum])
1148 # unblock the pending signal calls immediately the signal handler
1149 signal.pthread_sigmask(signal.SIG_UNBLOCK, [signum])
1172 @unittest.skipUnless(hasattr(signal, 'pthread_kill'),
1173 'need signal.pthread_kill()')
1176 # Test that a signal can be sent to the main thread with pthread_kill()
1180 import signal
1186 signal.signal(signal.SIGUSR1, handler)
1187 signal.pthread_kill(threading.get_ident(), signal.SIGUSR1)
1201 Stress signal delivery, especially when a signal arrives in
1202 the middle of recomputing the signal state or executing
1203 previously tripped signal handlers.
1207 old_handler = signal.signal(signum, handler)
1208 self.addCleanup(signal.signal, signum, old_handler)
1220 signal.setitimer(signal.ITIMER_REAL, 1e-6)
1222 self.addCleanup(signal.setitimer, signal.ITIMER_REAL, 0)
1223 self.setsig(signal.SIGALRM, handler)
1248 @unittest.skipUnless(hasattr(signal, "setitimer"),
1252 This test uses dependent signal handlers.
1260 # triggering a race condition. Ideally the signal is received
1261 # when inside critical signal-handling routines such as
1263 signal.setitimer(signal.ITIMER_REAL, 1e-6 + random.random() * 1e-5)
1271 self.setsig(signal.SIGPROF, first_handler)
1272 self.setsig(signal.SIGUSR1, first_handler)
1273 self.setsig(signal.SIGALRM, second_handler) # for ITIMER_REAL
1279 os.kill(os.getpid(), signal.SIGPROF)
1281 # Wait for handlers to run to avoid signal coalescing
1285 os.kill(os.getpid(), signal.SIGUSR1)
1294 @unittest.skipUnless(hasattr(signal, "setitimer"),
1298 This test uses simultaneous signal handlers.
1306 self.setsig(signal.SIGUSR1, handler)
1307 self.setsig(signal.SIGALRM, handler) # for ITIMER_REAL
1315 signal.setitimer(signal.ITIMER_REAL, 1e-6 + random.random() * 1e-5)
1316 os.kill(os.getpid(), signal.SIGUSR1)
1319 # Wait for handlers to run to avoid signal coalescing
1327 @unittest.skipUnless(hasattr(signal, "SIGUSR1"),
1331 # bpo-43406: race condition between trip_signal() and signal.signal
1332 signum = signal.SIGUSR1
1344 signal.raise_signal(signum)
1351 for handler in [custom_handler, signal.SIG_IGN]:
1352 signal.signal(signum, handler)
1354 old_handler = signal.signal(signum, custom_handler)
1355 self.addCleanup(signal.signal, signum, old_handler)
1368 # a signal is ignored due to the aforementioned
1391 signal.raise_signal(signal.SIGINT)
1397 signal.raise_signal(SIGHUP)
1410 old_signal = signal.signal(signal.SIGINT, handler)
1411 self.addCleanup(signal.signal, signal.SIGINT, old_signal)
1413 signal.raise_signal(signal.SIGINT)
1435 hasattr(signal, "pidfd_send_signal"),
1440 signal.pidfd_send_signal(0, signal.SIGINT)
1449 signal.pidfd_send_signal(my_pidfd, signal.SIGINT, object(), 0)
1451 signal.pidfd_send_signal(my_pidfd, signal.SIGINT)