403Webshell
Server IP : 121.121.20.254  /  Your IP : 216.73.216.202
Web Server : Microsoft-IIS/10.0
System : Windows NT WEB-SERVER 10.0 build 20348 (Windows Server 2022) AMD64
User : IUSR ( 0)
PHP Version : 8.3.28
Disable Function : NONE
MySQL : ON  |  cURL : ON  |  WGET : OFF  |  Perl : OFF  |  Python : OFF  |  Sudo : OFF  |  Pkexec : OFF
Directory :  /Python313/Lib/test/__pycache__/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Command :


[ Back ]     

Current File : /Python313/Lib/test/__pycache__/test_signal.cpython-313.pyc
�

��i���	��SSKrSSKrSSKrSSKrSSKrSSKrSSKrSSKrSSKrSSK	r	SSK
r
SSKrSSKrSSK
r
SSKJr SSKJrJrJrJr SSKJrJr SSKr"SS\
R45r\
R8"\
R:S:HS5"S	S
\
R455r\
R>"\
R:S:HS5"SS
\
R455r "SS\
R45r!\
R8"\
R:S:HS5"SS\
R455r"\
R>"\#"\S5S5"SS\
R455r$\
R8"\
R:S:HS5\
R>"\#"\S5S5\RJ"5\
R>"\#"\S5S5"SS\
R455555r&\
R8"\
R:S:HS5\
R>"\#"\S5=(a	 \#"\S5S5"SS \
R4555r'"S!S"\
R45r("S#S$\
R45r)"S%S&\
R45r*"S'S(\
R45r+S)r,\-S*:Xa\
R\"5 gg!\a SrGNjf=f)+�N)�support)�is_apple�is_apple_mobile�	os_helper�threading_helper)�assert_python_ok�spawn_pythonc� �\rSrSrSrSrSrg)�GenericTests�c�,�[[5GH
n[[U5nUS;a"URU[R5 M<US;a"URU[R
5 MdUR
S5(a8UR
S5(d"URU[R5 M�UR
S5(dM�URU[R5 UR[RS5 GM
 [R"[RSSS	[S
9n[R"U[R5 [R"[RSSS[S
9n[R"U[R5 [[S
S5nUbB[R"[RS
SS[S
9n[R"Xe5 gg)N>�SIG_DFL�SIG_IGN>�	SIG_BLOCK�SIG_SETMASK�SIG_UNBLOCK�SIG�SIG_�CTRL_�win32�Signals�signalc��UR5=(a. URS5=(a URS5(+=(d URS5$)Nrrr)�isupper�
startswith��names �%C:\Python313\\Lib\test\test_signal.py�<lambda>�)GenericTests.test_enums.<locals>.<lambda>+sD���L�L�N�Q�����/�O�����8O�4O�0����w�/�0�)�source�Handlersc��US;$)N)rr�rs rrr 5s
��T�%;�;r!�Sigmasksc��US;$)N)rrrr%rs rrr >s
���)T�!Tr!)�dirr�getattr�assertIsInstancer#r&rr�assertEqual�sys�platform�enum�
_old_convert_�IntEnum�_test_simple_enum)�selfr�sig�CheckedSignals�CheckedHandlersr&�CheckedSigmaskss       r�
test_enums�GenericTests.test_enumss|����K�D��&�$�'�C��-�-��%�%�c�6�?�?�;��D�D��%�%�c�6�?�?�;�����'�'�����0G�0G��%�%�c�6�>�>�:�����)�)��%�%�c�6�>�>�:�� � ����w�7� ��+�+����i��0��
��	
���~�v�~�~�>��,�,����j�(�;����
	
�������@��6�:�t�4����"�0�0��L�L�*�h�T�!��O�

�"�"�?�=�
 r!c��[[5Hin[[U5n[R"U5(dM0[R
"U5(aMMUR
URS5 Mk g)Nr)r(rr)�inspect�	isroutine�	isbuiltinr+�
__module__)r2r�values   r�test_functions_module_attr�'GenericTests.test_functions_module_attrCsU����K�D��F�D�)�E�� � ��'�'��0A�0A�%�0H�0H�� � ��!1�!1�8�<� r!r%N)�__name__r=�__qualname__�__firstlineno__r7r?�__static_attributes__r%r!rrrs
��%>�N=r!rrzNot valid on Windowsc�P�\rSrSrSrSrSrSrSrSr	\
R"\RRS5S	5S
5rSr\
R""\"\S5S
5S5r\
R""\R*S5\R."5S55rSrg)�
PosixTests�Lc��g�Nr%�r2�argss  r�trivial_signal_handler�!PosixTests.trivial_signal_handlerNs��r!c�D�[R"URU5$rI)�	functools�partialrL)r2�arguments  r�create_handler_with_partial�&PosixTests.create_handler_with_partialQs��� � ��!<�!<�h�G�Gr!c��UR[[RS5 UR[[RSUR5 UR[[R
S5 g)Ni�)�assertRaises�
ValueErrorr�	getsignalrL�	strsignal�r2s r�,test_out_of_range_signal_number_raises_error�7PosixTests.test_out_of_range_signal_number_raises_errorTsU�����*�f�&6�&6��=����*�f�m�m�T��5�5�	7�	
���*�f�&6�&6��=r!c�l�UR[[R[RS5 grI)rU�	TypeErrorr�SIGUSR1rYs r�0test_setting_signal_handler_to_none_raises_error�;PosixTests.test_setting_signal_handler_to_none_raises_error\s!�����)�V�]�]� �.�.�$�	0r!c���[R"[RUR5nURU[R5 UR[R"[R5UR5 [R"[RU5 UR[R"[R5U5 grI)r�SIGHUPrLr*r#r+rW)r2�hups  r�test_getsignal�PosixTests.test_getsignal`s����m�m�F�M�M�4�+F�+F�G�����c�6�?�?�3�����)�)�&�-�-�8��4�4�	6��
�
�f�m�m�S�)�����)�)�&�-�-�8�#�>r!c�\�"SS5nU"5nURSUR5 URU5n[R"[RU5nURU[R5 UR[R"[R5U5 [R"[RU5 UR[R"[R5U5 URSUR5 g)Nc�.^�\rSrSrSrU4SjrSrU=r$)�GPosixTests.test_no_repr_is_called_on_signal_handler.<locals>.MyArgument�kc��SUlg�Nr��
repr_countrYs r�__init__�PPosixTests.test_no_repr_is_called_on_signal_handler.<locals>.MyArgument.__init__ls	��"#��r!c�J>�U=RS-
sl[TU]	5$�N�)rm�super�__repr__)r2�	__class__s �rrt�PPosixTests.test_no_repr_is_called_on_signal_handler.<locals>.MyArgument.__repr__os������1�$���w�'�)�)r!rl)rAr=rBrCrnrtrD�
__classcell__)rus@r�
MyArgumentrhks���
$�
*�
*r!rxr)r+rmrRrrbr*r#rW)r2rxrQ�handlerrcs     r�(test_no_repr_is_called_on_signal_handler�3PosixTests.test_no_repr_is_called_on_signal_handlerhs���	*�	*��<������H�/�/�0��2�2�8�<���m�m�F�M�M�7�3�����c�6�?�?�3�����)�)�&�-�-�8�'�B��
�
�f�m�m�S�)�����)�)�&�-�-�8�#�>�����H�/�/�0r!�netbsdz/gh-124083: strsignal is not supported on NetBSDc�<�URS[R"[R55 URS[R"[R55 URS[R"[R
55 g)N�	Interrupt�
Terminated�Hangup)�assertInrrX�SIGINT�SIGTERMrbrYs r�test_strsignal�PosixTests.test_strsignal~s[��	
�
�
�k�6�#3�#3�F�M�M�#B�C��
�
�l�F�$4�$4�V�^�^�$D�E��
�
�h�� 0� 0���� ?�@r!c��[RR[5n[RR	US5n[U5 g)Nzsignalinterproctester.py)�os�path�dirname�__file__�joinr)r2r��scripts   r�test_interprocess_signal�#PosixTests.test_interprocess_signal�s1���'�'�/�/�(�+�������g�'A�B���� r!�
valid_signalszrequires signal.valid_signalsc��[R"5nURU[5 UR	[R
RU5 UR	[R
RU5 URSU5 UR[RU5 UR[U5[R5 [[5H}nURS5(dMUS;aM#URUS9 [[U5nUR!US5 URU[R5 SSS5 M g!,(df   M�=f)Nrr>rrr)rr�r*�setr�rr��SIGALRM�assertNotIn�NSIG�
assertLess�lenr(r�subTestr)�assertGreaterEqual)r2�sr�signums    r�test_valid_signals�PosixTests.test_valid_signals�s��

� � �"�����a��%��
�
�f�n�n�+�+�Q�/��
�
�f�n�n�,�,�a�0�����A��������a�(�����A�����,���K�D��?�?�5�)�)���-�-�����4��(� ���.���'�'���2��������4�)�(�
 �)�(�s
�AE,�,
E;	�sys.executable required.c��[R"[RSS/[RS9nURSUR5 URUR[R*5 g)z+KeyboardInterrupt triggers exit via SIGINT.�-czaimport os, signal, time
os.kill(os.getpid(), signal.SIGINT)
for _ in range(999): time.sleep(0.01)��stderr�KeyboardInterruptN)�
subprocess�runr,�
executable�PIPEr�r�r+�
returncoderr�)r2�processs  r�!test_keyboard_interrupt_exit_code�,PosixTests.test_keyboard_interrupt_exit_code�s_���.�.�����9�:�"���(��	
�
�
�*�G�N�N�;�����+�+�f�m�m�^�<r!r%N)rAr=rBrCrLrRrZr_rdrz�unittest�skipIfr,r-rr�r��
skipUnless�hasattrrr�r�r�requires_subprocessr�rDr%r!rrFrFLs���
�H�>�0�?�1�,�_�_�S�\�\�,�,�X�6�F�H�A�H�A�!�
������(�'��5�	�5�,������)C�D�� � �"�	=�#�E�	=r!rFzWindows specificc��\rSrSrSrSr\R"\RS5\
R"5S55rSr
g)�WindowsSignalTests�c��[R"5nURU[5 UR	[U5S5 UR
[RRU5 URSU5 UR[RU5 UR[U5[R5 g)N�r)rr�r*r�r�r�r�rr�r�r�r��r2r�s  rr��%WindowsSignalTests.test_valid_signals�s���� � �"�����a��%�����A���*��
�
�f�n�n�+�+�Q�/�����A��������a�(�����A�����,r!c���Sn[5n[R[R[R[R
[R[R[R4HXn[R"U5cM[R"U[R"X155 URU5 MZ URU5 UR[5 [R"SU5 SSS5 UR[5 [R"SU5 SSS5 g!,(df   ND=f!,(df   g=f)Nc��grIr%)�x�ys  rr�3WindowsSignalTests.test_issue9324.<locals>.<lambda>�s��tr!����)r�r�SIGABRT�SIGBREAK�SIGFPE�SIGILLr��SIGSEGVr�rW�add�
assertTruerUrV)r2ry�checkedr3s    r�test_issue9324�!WindowsSignalTests.test_issue9324�s���#���%���N�N�F�O�O�V�]�]��M�M�6�=�=�&�.�.��N�N�$�C�
����$�0��
�
�c�6�=�=��#>�?����C� �$�	
���� �
�
�
�z�
*��M�M�"�g�&�+��
�
�z�
*��M�M�!�W�%�+�
*�+�
*��+�
*�s�;E�0E"�
E�"
E0r�c���[R"[RSS/[RS9nURSUR5 SnURURU5 g)z?KeyboardInterrupt triggers an exit using STATUS_CONTROL_C_EXIT.r�zraise KeyboardInterruptr�r�l:N)	r�r�r,r�r�r�r�r+r�)r2r��STATUS_CONTROL_C_EXITs   rr��4WindowsSignalTests.test_keyboard_interrupt_exit_code�sZ���.�.�����'@�A�!���(��	
�
�
�*�G�N�N�;� *������+�+�-B�Cr!r%N)rAr=rBrCr�r�r�r�r,r�rr�r�rDr%r!rr�r��sF��-�&�*������)C�D�� � �"�D�#�E�Dr!r�c�2�\rSrSrSrSr\R"\RS5S5r
\R"\RS5\R"\
"\S5S5S	55r\R"\RS5\R"\RS5S
55r\R"\R$S:HS5\R"\RS5\R"\
"\S5S5S
555rSrg)�
WakeupFDTests��c�N�UR[5 [R"[RS9 SSS5 UR[5 [R"[RS5 SSS5 g!,(df   NR=f!,(df   g=f)N)r�F)rUr]r�
set_wakeup_fdr�rYs r�test_invalid_call�WakeupFDTests.test_invalid_call�se��
�
�
�y�
)�� � ��
�
�6�*��
�
�y�
)�� � �����6�*�
)�	*�
)��*�
)�s�#B�&B�
B�
B$c��[R"5nUR[[4[
RU5 grI)r�make_bad_fdrUrV�OSErrorrr�)r2�fds  r�test_invalid_fd�WakeupFDTests.test_invalid_fd�s0��
�
"�
"�
$�����:�w�/� �.�.��	4r!zneeds working sockets.c���[R"5nUR5nUR5 UR[[
4[RU5 grI)�socket�fileno�closerUrVr�rr�)r2�sockr�s   r�test_invalid_socket�!WakeupFDTests.test_invalid_socket�sA���}�}���
�[�[�]���
�
�����:�w�/� �.�.��	4r!zEmscripten cannot fstat pipes.�pipe�requires os.pipe()c��[R"5upUR[RU5 UR[RU5 [R"5up4UR[RU5 UR[RU5 [	[S5(a.[R
"US5 [R
"US5 [R"U5 UR[R"U5U5 UR[R"S5U5 UR[R"S5S5 g)N�set_blockingFr�)	r�r��
addCleanupr�r�r�rr�r+)r2�r1�w1�r2�w2s     r�test_set_wakeup_fd_result�'WakeupFDTests.test_set_wakeup_fd_results���������������"�%�������"�%�������������"�%�������"�%��2�~�&�&��O�O�B��&��O�O�B��&����R� �����-�-�b�1�2�6�����-�-�b�1�2�6�����-�-�b�1�2�6r!c�X�[R"5nURUR5 URS5 UR	5n[R"5nURUR5 URS5 UR	5n[
R"U5 UR[
R"U5U5 UR[
R"S5U5 UR[
R"S5S5 g)NFr�)r�r�r��setblockingr�rr�r+)r2�sock1�fd1�sock2�fd2s     r� test_set_wakeup_fd_socket_result�.WakeupFDTests.test_set_wakeup_fd_socket_results����
�
���������$�
���%� ��l�l�n���
�
���������$�
���%� ��l�l�n�����S�!�����-�-�c�2�C�8�����-�-�b�1�3�7�����-�-�b�1�2�6r!rztests specific to POSIXc�@�[R"5upUR[RU5 UR[RU5 [R"US5 UR[5n[R"U5 SSS5 UR[WR5SU-5 [R"US5 [R"U5 [R"S5 g!,(df   Nz=f)NTz&the fd %s must be in non-blocking modeFr�)r�r�r�r�r�rUrVrr�r+�str�	exception)r2�rfd�wfd�cms    r�test_set_wakeup_fd_blocking�)WakeupFDTests.test_set_wakeup_fd_blocking)s����7�7�9���������#�&�������#�&�	����T�"�
�
�
�z�
*�b�� � ��%�+�����R�\�\�*�A�C�G�	I�	����U�#����S�!����R� �+�
*�s�D�
Dr%N)rAr=rBrCr�r�r�r�r�has_socket_supportr�r��
is_emscriptenr�r�r�r�r,r-r�rDr%r!rr�r��s!��7�4�
����3�3�5M�N�4�O�4��_�_�W�*�*�,L�M�
�����V�,�.B�C�7�D�N�7�"�_�_�W�*�*�,L�M�
����3�3�5M�N�7�O�N�7�$�_�_�S�\�\�W�,�.G�H�
�_�_�W�*�*�,L�M�
�����V�,�.B�C�!�D�N�I�!r!r�c��\rSrSr\R
"\SLS5SS.Sj5r\R
"\SLS5\R"\	"\
S5S5S	55rS
rSr
Sr\R"\	"\S
5S5S5rSrg)�WakeupSignalTestsi>N�need _testcapiT��orderedc�n�SR[[[U55X!5n[	SU5 g)Naif 1:
        import _testcapi
        import os
        import signal
        import struct

        signals = {!r}

        def handler(signum, frame):
            pass

        def check_signum(signals):
            data = os.read(read, len(signals)+1)
            raised = struct.unpack('%uB' % len(data), data)
            if not {!r}:
                raised = set(raised)
                signals = set(signals)
            if raised != signals:
                raise Exception("%r != %r" % (raised, signals))

        {}

        signal.signal(signal.SIGALRM, handler)
        read, write = os.pipe()
        os.set_blocking(write, False)
        signal.set_wakeup_fd(write)

        test()
        check_signum(signals)

        os.close(read)
        os.close(write)
        r�)�format�tuple�map�intr)r2�	test_bodyr�signals�codes     r�check_wakeup�WakeupSignalTests.check_wakeup@s5�� �@
�F�5��S�'�*�+�W�@�A	
�D	��t�$r!r�r�c�z�Sn[R"5up#[R"US5 URS5 [R
"U5 [R
"U5 [
SU5 g![a NEf=f![R
"U5 [R
"U5 f=f)Na&if 1:
        import _testcapi
        import errno
        import os
        import signal
        import sys
        from test.support import captured_stderr

        def handler(signum, frame):
            1/0

        signal.signal(signal.SIGALRM, handler)
        r, w = os.pipe()
        os.set_blocking(r, False)

        # Set wakeup_fd a read-only file descriptor to trigger the error
        signal.set_wakeup_fd(r)
        try:
            with captured_stderr() as err:
                signal.raise_signal(signal.SIGALRM)
        except ZeroDivisionError:
            # An ignored exception should have been printed out on stderr
            err = err.getvalue()
            if ('Exception ignored when trying to write to the signal wakeup fd'
                not in err):
                raise AssertionError(err)
            if ('OSError: [Errno %d]' % errno.EBADF) not in err:
                raise AssertionError(err)
        else:
            raise AssertionError("ZeroDivisionError not raised")

        os.close(r)
        os.close(w)
        �xz9OS doesn't report write() error on the read end of a piper�)r�r��write�skipTestr�r�r)r2r�r�ws    r�test_wakeup_write_error�)WakeupSignalTests.test_wakeup_write_errorgs���!��D�w�w�y���	��H�H�Q���
�M�M�U�V��H�H�Q�K��H�H�Q�K���t�$���	��	��

�H�H�Q�K��H�H�Q�K�s(�A<�B�<
B	�B�B	�	B�.B:c�D�URS[R5 g)Na�def test():
            import select
            import time

            TIMEOUT_FULL = 10
            TIMEOUT_HALF = 5

            class InterruptSelect(Exception):
                pass

            def handler(signum, frame):
                raise InterruptSelect
            signal.signal(signal.SIGALRM, handler)

            signal.alarm(1)

            # We attempt to get a signal during the sleep,
            # before select is called
            try:
                select.select([], [], [], TIMEOUT_FULL)
            except InterruptSelect:
                pass
            else:
                raise Exception("select() was not interrupted")

            before_time = time.monotonic()
            select.select([read], [], [], TIMEOUT_FULL)
            after_time = time.monotonic()
            dt = after_time - before_time
            if dt >= TIMEOUT_HALF:
                raise Exception("%s >= %s" % (dt, TIMEOUT_HALF))
        �r	rr�rYs r�test_wakeup_fd_early�&WakeupSignalTests.test_wakeup_fd_early�s������>�^�^�?	r!c�D�URS[R5 g)Na`def test():
            import select
            import time

            TIMEOUT_FULL = 10
            TIMEOUT_HALF = 5

            class InterruptSelect(Exception):
                pass

            def handler(signum, frame):
                raise InterruptSelect
            signal.signal(signal.SIGALRM, handler)

            signal.alarm(1)
            before_time = time.monotonic()
            # We attempt to get a signal during the select call
            try:
                select.select([read], [], [], TIMEOUT_FULL)
            except InterruptSelect:
                pass
            else:
                raise Exception("select() was not interrupted")
            after_time = time.monotonic()
            dt = after_time - before_time
            if dt >= TIMEOUT_HALF:
                raise Exception("%s >= %s" % (dt, TIMEOUT_HALF))
        rrYs r�test_wakeup_fd_during�'WakeupSignalTests.test_wakeup_fd_during�s������6�^�^�7	r!c�b�URS[R[R5 g)Nz�def test():
            signal.signal(signal.SIGUSR1, handler)
            signal.raise_signal(signal.SIGUSR1)
            signal.raise_signal(signal.SIGALRM)
        )r	rr^r�rYs r�test_signum�WakeupSignalTests.test_signum�s$�������^�^�V�^�^�		-r!�pthread_sigmask�need signal.pthread_sigmask()c�`�URS[R[RSS9 g)Na�def test():
            signum1 = signal.SIGUSR1
            signum2 = signal.SIGUSR2

            signal.signal(signum1, handler)
            signal.signal(signum2, handler)

            signal.pthread_sigmask(signal.SIG_BLOCK, (signum1, signum2))
            signal.raise_signal(signum1)
            signal.raise_signal(signum2)
            # Unblocking the 2 signals calls the C signal handler twice
            signal.pthread_sigmask(signal.SIG_UNBLOCK, (signum1, signum2))
        Fr�)r	rr^�SIGUSR2rYs r�test_pending�WakeupSignalTests.test_pending�s-��	
�����n�n�f�n�n�e�	�	=r!r%)rAr=rBrCr�r��	_testcapir	r�r�r�rrrrrr!rDr%r!rr�r�>s���
�_�_�Y�$�&�(8�9�8<�$%�:�$%�L�_�_�Y�$�&�(8�9�
�����V�,�.B�C�1%�D�:�1%�f �D�<-������):�;�8�:�
=�:�
=r!r��
socketpairzneed socket.socketpairc��\rSrSr\R
"\SLS5S5r\R
"\SLS5S5r\R
"\SLS5S5r	Sr
g)�WakeupSocketSignalTestsi�Nr�c� �Sn[SU5 g)Na�if 1:
        import signal
        import socket
        import struct
        import _testcapi

        signum = signal.SIGINT
        signals = (signum,)

        def handler(signum, frame):
            pass

        signal.signal(signum, handler)

        read, write = socket.socketpair()
        write.setblocking(False)
        signal.set_wakeup_fd(write.fileno())

        signal.raise_signal(signum)

        data = read.recv(1)
        if not data:
            raise Exception("no signum written")
        raised = struct.unpack('B', data)
        if raised != signals:
            raise Exception("%r != %r" % (raised, signals))

        read.close()
        write.close()
        r��r�r2rs  r�test_socket�#WakeupSocketSignalTests.test_socket�s����>	��t�$r!c�l�[RS:XaSnOSnSRUS9n[SU5 g)N�nt�sendr
a+if 1:
        import errno
        import signal
        import socket
        import sys
        import time
        import _testcapi
        from test.support import captured_stderr

        signum = signal.SIGINT

        def handler(signum, frame):
            pass

        signal.signal(signum, handler)

        read, write = socket.socketpair()
        read.setblocking(False)
        write.setblocking(False)

        signal.set_wakeup_fd(write.fileno())

        # Close sockets: send() will fail
        read.close()
        write.close()

        with captured_stderr() as err:
            signal.raise_signal(signum)

        err = err.getvalue()
        if ('Exception ignored when trying to {action} to the signal wakeup fd'
            not in err):
            raise AssertionError(err)
        ��actionr��r�rrr�r2r0rs   r�test_send_error�'WakeupSocketSignalTests.test_send_errors@���7�7�d�?��F��F�!�B
�F�&�F�!�C	
�D	��t�$r!c�l�[RS:XaSnOSnSRUS9n[SU5 g)Nr-r.r
aJ
if 1:
        import errno
        import signal
        import socket
        import sys
        import time
        import _testcapi
        from test.support import captured_stderr

        signum = signal.SIGINT

        # This handler will be called, but we intentionally won't read from
        # the wakeup fd.
        def handler(signum, frame):
            pass

        signal.signal(signum, handler)

        read, write = socket.socketpair()

        # Fill the socketpair buffer
        if sys.platform == 'win32':
            # bpo-34130: On Windows, sometimes non-blocking send fails to fill
            # the full socketpair buffer, so use a timeout of 50 ms instead.
            write.settimeout(0.050)
        else:
            write.setblocking(False)

        written = 0
        if sys.platform == "vxworks":
            CHUNK_SIZES = (1,)
        else:
            # Start with large chunk size to reduce the
            # number of send needed to fill the buffer.
            CHUNK_SIZES = (2 ** 16, 2 ** 8, 1)
        for chunk_size in CHUNK_SIZES:
            chunk = b"x" * chunk_size
            try:
                while True:
                    write.send(chunk)
                    written += chunk_size
            except (BlockingIOError, TimeoutError):
                pass

        print(f"%s bytes written into the socketpair" % written, flush=True)

        write.setblocking(False)
        try:
            write.send(b"x")
        except BlockingIOError:
            # The socketpair buffer seems full
            pass
        else:
            raise AssertionError("%s bytes failed to fill the socketpair "
                                 "buffer" % written)

        # By default, we get a warning when a signal arrives
        msg = ('Exception ignored when trying to {action} '
               'to the signal wakeup fd')
        signal.set_wakeup_fd(write.fileno())

        with captured_stderr() as err:
            signal.raise_signal(signum)

        err = err.getvalue()
        if msg not in err:
            raise AssertionError("first set_wakeup_fd() test failed, "
                                 "stderr: %r" % err)

        # And also if warn_on_full_buffer=True
        signal.set_wakeup_fd(write.fileno(), warn_on_full_buffer=True)

        with captured_stderr() as err:
            signal.raise_signal(signum)

        err = err.getvalue()
        if msg not in err:
            raise AssertionError("set_wakeup_fd(warn_on_full_buffer=True) "
                                 "test failed, stderr: %r" % err)

        # But not if warn_on_full_buffer=False
        signal.set_wakeup_fd(write.fileno(), warn_on_full_buffer=False)

        with captured_stderr() as err:
            signal.raise_signal(signum)

        err = err.getvalue()
        if err != "":
            raise AssertionError("set_wakeup_fd(warn_on_full_buffer=False) "
                                 "test failed, stderr: %r" % err)

        # And then check the default again, to make sure warn_on_full_buffer
        # settings don't leak across calls.
        signal.set_wakeup_fd(write.fileno())

        with captured_stderr() as err:
            signal.raise_signal(signum)

        err = err.getvalue()
        if msg not in err:
            raise AssertionError("second set_wakeup_fd() test failed, "
                                 "stderr: %r" % err)

        r/r�r1r2s   r�test_warn_on_full_buffer�0WakeupSocketSignalTests.test_warn_on_full_bufferGsA���7�7�d�?��F��F�g�N
�F�&�F�!�O	
�P	��t�$r!r%)rAr=rBrCr�r�r#r*r3r6rDr%r!rr&r&�su���_�_�Y�$�&�(8�9�!%�:�!%�F�_�_�Y�$�&�(8�9�(%�:�(%�T�_�_�Y�$�&�(8�9�n%�:�n%r!r&�siginterruptzneeds signal.siginterrupt()r�r�c�p�\rSrSr\R
4SjrSrSr\R"S5S5r
Srg)	�SiginterruptTesti�c�~�SU<S3n[SU5nURR5nURUS9upgXV-nUR	5nUS;a[SU<SU<35eUS:HsS	S	S	5 $![Ra UR5 S	S	S	5 g
f=f!,(df   g	=f)z�Perform a read during which a signal will arrive.  Return True if the
read is interrupted by the signal and raises an exception.  Return False
if it returns normally.
zif 1:
            import errno
            import os
            import signal
            import sys

            interrupt = aq
            r, w = os.pipe()

            def handler(signum, frame):
                1 / 0

            signal.signal(signal.SIGALRM, handler)
            if interrupt is not None:
                signal.siginterrupt(signal.SIGALRM, interrupt)

            print("ready")
            sys.stdout.flush()

            # run the test twice
            try:
                for loop in range(2):
                    # send a SIGALRM in a second (during the read)
                    signal.alarm(1)
                    try:
                        # blocking call: read from a pipe without data
                        os.read(r, 1)
                    except ZeroDivisionError:
                        pass
                    else:
                        sys.exit(2)
                sys.exit(3)
            finally:
                os.close(r)
                os.close(w)
        r���timeout)���Child error (exit code �): r?NF)	r	�stdout�readline�communicate�wait�	Exceptionr��TimeoutExpired�kill)	r2�	interruptr=rr��
first_linerBr��exitcodes	         r�readpipe_interrupted�%SiginterruptTest.readpipe_interrupted�s���T�G#��H�$��
%��
'�$�^�^�4�4�6�
�!(�!4�!4�W�!4�!E���
$�,��"�<�<�>���6�)�#�'/��%9�:�:� �A�
�&�
%���,�,�
������&�
%�
��
&�
%�s.�B.�+A<�1B.�<$B+� B.�*B+�+B.�.
B<c�H�URS5nURU5 grI�rLr��r2�interrupteds  r�test_without_siginterrupt�*SiginterruptTest.test_without_siginterrupt�� ���/�/��5������$r!c�H�URS5nURU5 g�NTrOrPs  r�test_siginterrupt_on�%SiginterruptTest.test_siginterrupt_onrTr!�walltimec�F�URSSS9nURU5 g)NFr>r<)rL�assertFalserPs  r�test_siginterrupt_off�&SiginterruptTest.test_siginterrupt_off	s'��
�/�/��q�/�A������%r!r%N)rAr=rBrCr�
SHORT_TIMEOUTrLrRrW�requires_resourcer\rDr%r!rr:r:�s<��7>�6K�6K�:'�x%�%�
���z�*�&�+�&r!r:�	getitimer�	setitimerz/needs signal.getitimer() and signal.setitimer()c��\rSrSrSrSrSrSrSrSr	Sr
\R"\
RS	;=(d \S
5S5rSrS
rSrg)�
ItimerTestic��SUlSUlSUl[R"[RUR
5Ulg)NFr)�hndl_called�
hndl_count�itimerrr��sig_alrm�	old_alarmrYs r�setUp�ItimerTest.setUps2�� ������������v�~�~�t�}�}�E��r!c��[R"[RUR5 URb"[R"URS5 ggrk)rr�rirgrarYs r�tearDown�ItimerTest.tearDowns;���
�
�f�n�n�d�n�n�5��;�;�"����T�[�[�!�,�#r!c��SUlgrV)rerJs  rrh�ItimerTest.sig_alrm"s
����r!c���SUlURS:�a[R"S5eURS:Xa%[R"[R
S5 U=RS-
slg)NTr?z.setitimer didn't disable ITIMER_VIRTUAL timer.rrr)rerfr�ItimerErrorra�ITIMER_VIRTUALrJs  r�
sig_vtalrm�ItimerTest.sig_vtalrm%s^������?�?�Q���$�$�&��
�
�_�_��
!����V�2�2�A�6����1��r!c�\�SUl[R"[RS5 g)NTr)rerra�ITIMER_PROFrJs  r�sig_prof�ItimerTest.sig_prof2s ���������+�+�Q�/r!c�d�UR[R[RSS5 g)Nr�r)rUrrrra�ITIMER_REALrYs r�test_itimer_exc�ItimerTest.test_itimer_exc6s'��	
���&�,�,�f�.>�.>��A�F�r!c���[RUl[R"URS5 [R"5 URURS5 g)Ng�?T)rr{rgra�pauser+rerYs r�test_itimer_real�ItimerTest.test_itimer_real?sB���(�(���������c�*���������)�)�4�0r!)�netbsd5zDitimer not reliable (does not mix well with threading) on some BSDs.c�@�[RUl[R"[RUR5 [R
"URSS5 [R"[R5HDn[S[S555n[R"UR5S:XdMD O UR[R"UR5S5 URURS5 g)N���MbP?c3�*# �UH	oU-v� M g7frIr%��.0�is  r�	<genexpr>�1ItimerTest.test_itimer_virtual.<locals>.<genexpr>O����0�<�a��E�<���順��r�T)rrsrg�	SIGVTALRMrtrar�
busy_retry�LONG_TIMEOUT�sum�ranger`r+re�r2�_s  r�test_itimer_virtual�ItimerTest.test_itimer_virtualFs����+�+����
�
�f�&�&����8�������e�U�3��#�#�G�$8�$8�9�A��0�5��<�0�0�A�������,�
�:��:�	
����)�)�$�+�+�6�
�C�����)�)�4�0r!c�@�[RUl[R"[RUR5 [R
"URSS5 [R"[R5HDn[S[S555n[R"UR5S:XdMD O UR[R"UR5S5 URURS5 g)Ng�������?c3�*# �UH	oU-v� M g7frIr%r�s  rr��.ItimerTest.test_itimer_prof.<locals>.<genexpr>`r�r�r�r�T)rrwrg�SIGPROFrxrarr�r�r�r�r`r+rer�s  r�test_itimer_prof�ItimerTest.test_itimer_profYs����(�(����
�
�f�n�n�d�m�m�4�������c�3�/��#�#�G�$8�$8�9�A��0�5��<�0�0�A�������,�
�:��:�	
����)�)�$�+�+�6�
�C�����)�)�4�0r!c���[RUl[R"URS5 [R
"S5 UR
URS5 g)N���ư>rrT)rr{rgra�time�sleepr+rerYs r�test_setitimer_tiny�ItimerTest.test_setitimer_tinyjsF���(�(���������d�+��
�
�1�
�����)�)�4�0r!)rerfrgriN)rAr=rBrCrjrmrhrtrxr|r�r�r�r,r-rr�r�r�rDr%r!rrcrcsc��F�-� ��0�H�1��_�_�S�\�\�\�1�D�_�N�P�1�P�1�"1�"1r!rcc���\rSrSrSr\R"\"\S5S5S5r	\R"\"\S5S5\R"\"\S5S5S55r
\R"\"\S	5S
5\R"5S55r
\R"\"\S5S5S5r\R"\"\S
5S5S5r\R"\"\S5S5S5r\R"\"\S5S5S5r\R"\"\S5S5S5r\R"\"\S5S5S5r\R"\"\S5S5S5r\R"\"\S
5S5\R"\"\S5S5\R"5S555r\R"\"\S5S5S5r\R"\"\S5S5S5r\R"\"\S5S5\R"5S55r\R"\"\S	5S
5\R"5S55rSrg) �PendingSignalsTestsitzO
Test pthread_sigmask(), pthread_kill(), sigpending() and sigwait()
functions.
�
sigpendingzneed signal.sigpending()c�^�UR[R"5[55 grI)r+rr�r�rYs r�test_sigpending_empty�)PendingSignalsTests.test_sigpending_emptyys��	
����*�*�,�c�e�4r!rrc� �Sn[SU5 g)Na
if 1:
            import os
            import signal

            def handler(signum, frame):
                1/0

            signum = signal.SIGUSR1
            signal.signal(signum, handler)

            signal.pthread_sigmask(signal.SIG_BLOCK, [signum])
            os.kill(os.getpid(), signum)
            pending = signal.sigpending()
            for sig in pending:
                assert isinstance(sig, signal.Signals), repr(pending)
            if pending != {signum}:
                raise Exception('%s != {%s}' % (pending, signum))
            try:
                signal.pthread_sigmask(signal.SIG_UNBLOCK, [signum])
            except ZeroDivisionError:
                pass
            else:
                raise Exception("ZeroDivisionError not raised")
        r�r(r)s  r�test_sigpending�#PendingSignalsTests.test_sigpending~s��
��0	��t�$r!�pthread_killzneed signal.pthread_kill()c� �Sn[SU5 g)Na�if 1:
            import signal
            import threading
            import sys

            signum = signal.SIGUSR1

            def handler(signum, frame):
                1/0

            signal.signal(signum, handler)

            tid = threading.get_ident()
            try:
                signal.pthread_kill(tid, signum)
            except ZeroDivisionError:
                pass
            else:
                raise Exception("ZeroDivisionError not raised")
        r�r(r)s  r�test_pthread_kill�%PendingSignalsTests.test_pthread_kill�s����(	��t�$r!c�N�SUR5<SU<S3n[SU5 g)zW
test: body of the "def test(signum):" function.
blocked: number of the blocked signal
z�if 1:
        import signal
        import sys
        from signal import Signals

        def handler(signum, frame):
            1/0

        z

        blocked = a�
        signum = signal.SIGALRM

        # child: block and wait the signal
        try:
            signal.signal(signum, handler)
            signal.pthread_sigmask(signal.SIG_BLOCK, [blocked])

            # Do the tests
            test(signum)

            # The handler must not be called on unblock
            try:
                signal.pthread_sigmask(signal.SIG_UNBLOCK, [blocked])
            except ZeroDivisionError:
                print("the signal handler has been called",
                      file=sys.stderr)
                sys.exit(1)
        except BaseException as err:
            print("error: {}".format(err), file=sys.stderr)
            sys.stderr.flush()
            sys.exit(1)
        r�N)�stripr)r2�blocked�testrs    r�wait_helper�PendingSignalsTests.wait_helper�s%��N�z�z�|�W�A &��J	��t�$r!�sigwaitzneed signal.sigwait()c�D�UR[RS5 g)Na 
        def test(signum):
            signal.alarm(1)
            received = signal.sigwait([signum])
            assert isinstance(received, signal.Signals), received
            if received != signum:
                raise Exception('received %s, not %s' % (received, signum))
        �r�rr�rYs r�test_sigwait� PendingSignalsTests.test_sigwait�s��	
������*�	
r!�sigwaitinfozneed signal.sigwaitinfo()c�D�UR[RS5 g)Nz�
        def test(signum):
            signal.alarm(1)
            info = signal.sigwaitinfo([signum])
            if info.si_signo != signum:
                raise Exception("info.si_signo != %s" % signum)
        r�rYs r�test_sigwaitinfo�$PendingSignalsTests.test_sigwaitinfo����	
������*�	
r!�sigtimedwaitzneed signal.sigtimedwait()c�D�UR[RS5 g)Nz�
        def test(signum):
            signal.alarm(1)
            info = signal.sigtimedwait([signum], 10.1000)
            if info.si_signo != signum:
                raise Exception('info.si_signo != %s' % signum)
        r�rYs r�test_sigtimedwait�%PendingSignalsTests.test_sigtimedwait�r�r!c�D�UR[RS5 g)Nz�
        def test(signum):
            import os
            os.kill(os.getpid(), signum)
            info = signal.sigtimedwait([signum], 0)
            if info.si_signo != signum:
                raise Exception('info.si_signo != %s' % signum)
        r�rYs r�test_sigtimedwait_poll�*PendingSignalsTests.test_sigtimedwait_polls��	
������*�	
r!c�D�UR[RS5 g)Nz�
        def test(signum):
            received = signal.sigtimedwait([signum], 1.0)
            if received is not None:
                raise Exception("received=%r" % (received,))
        r�rYs r�test_sigtimedwait_timeout�-PendingSignalsTests.test_sigtimedwait_timeouts��	
������*�	
r!c�r�[RnUR[[RU/S5 g)Ng�)rr�rUrVr�)r2r�s  r�"test_sigtimedwait_negative_timeout�6PendingSignalsTests.test_sigtimedwait_negative_timeouts)���������*�f�&9�&9�F�8�T�Jr!c��[SS5 g)Nr�a�if True:
            import os, threading, sys, time, signal

            # the default handler terminates the process
            signum = signal.SIGUSR1

            def kill_later():
                # wait until the main thread is waiting in sigwait()
                time.sleep(1)
                os.kill(os.getpid(), signum)

            # the signal must be blocked by all the threads
            signal.pthread_sigmask(signal.SIG_BLOCK, [signum])
            killer = threading.Thread(target=kill_later)
            killer.start()
            received = signal.sigwait([signum])
            if received != signum:
                print("sigwait() received %s, not %s" % (received, signum),
                      file=sys.stderr)
                sys.exit(1)
            killer.join()
            # unblock the signal, which should have been cleared by sigwait()
            signal.pthread_sigmask(signal.SIG_UNBLOCK, [signum])
        r(rYs r�test_sigwait_thread�'PendingSignalsTests.test_sigwait_thread$s��	�� �	
r!c�P�UR[[R5 UR[[RS5 UR[[RSSS5 UR[[RS/5 UR[
5 [R"[R[R/5 SSS5 UR[
5 [R"[RS/5 SSS5 UR[
5 [R"[RSS-/5 SSS5 g!,(df   N�=f!,(df   Ng=f!,(df   g=f)Nrrr>r?i�ri�)rUr]rrr�rVrr�rYs r�test_pthread_sigmask_arguments�2PendingSignalsTests.test_pthread_sigmask_argumentsGs��	
���)�V�%;�%;�<����)�V�%;�%;�Q�?����)�V�%;�%;�Q��1�E����'�6�#9�#9�4��D�
�
�
�z�
*��"�"�6�#3�#3�f�k�k�]�C�+�
�
�
�z�
*��"�"�6�#3�#3�a�S�9�+�
�
�
�z�
*��"�"�6�#3�#3�a��g�Y�?�+�
*�	+�
*��
*�
*��
*�
*�s$�,5E5�>'F�*F�5
F�
F�
F%c��[R"[R[R"55nUR	[R[R
U5 [R"[R[R"55nURU[R"55 grI)rrrr�r�rr�assertLessEqualr�s  r�"test_pthread_sigmask_valid_signals�6PendingSignalsTests.test_pthread_sigmask_valid_signalsUs{��
�"�"�6�#3�#3�V�5I�5I�5K�L������.�.��0B�0B�A�F��"�"�6�#5�#5�v�7K�7K�7M�N�����Q�� 4� 4� 6�7r!c� �Sn[SU5 g)Na-	if 1:
        import signal
        import os; import threading

        def handler(signum, frame):
            1/0

        def kill(signum):
            os.kill(os.getpid(), signum)

        def check_mask(mask):
            for sig in mask:
                assert isinstance(sig, signal.Signals), repr(sig)

        def read_sigmask():
            sigmask = signal.pthread_sigmask(signal.SIG_BLOCK, [])
            check_mask(sigmask)
            return sigmask

        signum = signal.SIGUSR1

        # Install our signal handler
        old_handler = signal.signal(signum, handler)

        # Unblock SIGUSR1 (and copy the old mask) to test our signal handler
        old_mask = signal.pthread_sigmask(signal.SIG_UNBLOCK, [signum])
        check_mask(old_mask)
        try:
            kill(signum)
        except ZeroDivisionError:
            pass
        else:
            raise Exception("ZeroDivisionError not raised")

        # Block and then raise SIGUSR1. The signal is blocked: the signal
        # handler is not called, and the signal is now pending
        mask = signal.pthread_sigmask(signal.SIG_BLOCK, [signum])
        check_mask(mask)
        kill(signum)

        # Check the new mask
        blocked = read_sigmask()
        check_mask(blocked)
        if signum not in blocked:
            raise Exception("%s not in %s" % (signum, blocked))
        if old_mask ^ blocked != {signum}:
            raise Exception("%s ^ %s != {%s}" % (old_mask, blocked, signum))

        # Unblock SIGUSR1
        try:
            # unblock the pending signal calls immediately the signal handler
            signal.pthread_sigmask(signal.SIG_UNBLOCK, [signum])
        except ZeroDivisionError:
            pass
        else:
            raise Exception("ZeroDivisionError not raised")
        try:
            kill(signum)
        except ZeroDivisionError:
            pass
        else:
            raise Exception("ZeroDivisionError not raised")

        # Check the new mask
        unblocked = read_sigmask()
        if signum in unblocked:
            raise Exception("%s in %s" % (signum, unblocked))
        if blocked ^ unblocked != {signum}:
            raise Exception("%s ^ %s != {%s}" % (blocked, unblocked, signum))
        if old_mask != unblocked:
            raise Exception("%s != %s" % (old_mask, unblocked))
        r�r(r)s  r�test_pthread_sigmask�(PendingSignalsTests.test_pthread_sigmask^s��G��P	��t�$r!c���Sn[SU5nUR5up4UR5nUS:wa[SU<SU<35eSSS5 g!,(df   g=f)Na7if True:
            import threading
            import signal
            import sys

            def handler(signum, frame):
                sys.exit(3)

            signal.signal(signal.SIGUSR1, handler)
            signal.pthread_kill(threading.get_ident(), signal.SIGUSR1)
            sys.exit(2)
        r�r?r@rA)r	rDrErF)r2rr�rBr�rKs      r�test_pthread_kill_main_thread�1PendingSignalsTests.test_pthread_kill_main_thread�sa�����$��
%��$�0�0�2�N�F��|�|�~�H��1�}��!)�6�!3�4�4��&�
%�
%�s�<A�
A#r%N)rAr=rBrC�__doc__r�r�r�rr�r�r�requires_working_threadingr�r�r�r�r�r�r�r�r�r�r�r�r�rDr%r!rr�r�ts���������6�3�5�5�5�5������):�;�8�:�
������6�3�5�%�5�:�%�6������8�5�7��0�0�2�%�3�7�%�.�����):�;�8�:�*%�:�*%�X������3�0�2�
�2�
�������7�4�6�
�6�
�������8�5�7�
�7�
�������8�5�7�	
�7�	
�������8�5�7�
�7�
�������8�5�7�K�7�K�������3�0�2�
�����):�;�8�:��0�0�2�
�3�:�2�

�<�����):�;�8�:�
@�:�
@������):�;�8�:�8�:�8������):�;�8�:��0�0�2�I%�3�:�I%�V������8�5�7��0�0�2�4�3�7�4r!r�c�>�\rSrSrSrSrSrSr\R"\
"\S5S5S5r\R"\
"\S5S5S	5r
\R"\S
5\R"\
"\S5S5\R""5S
555rSrg)�
StressTesti�z�
Stress signal delivery, especially when a signal arrives in
the middle of recomputing the signal state or executing
previously tripped signal handlers.
c�p�[R"X5nUR[RX5 grI)rr�)r2r�ry�old_handlers    r�setsig�StressTest.setsig�s"���m�m�F�4������
�
�v�;r!c� ^^�Sm/mSUU4SjjnUR[R[RS5 UR	[R
U5 U"5 [
T5T:a'[R"S5 [
T5T:aM'[[
T5S-
5Vs/sHnTUS-TU-
PM nn[R"U5n[R(a[SU4-5 U$s snf)N�c�>�[T5T:aJTR[R"55 [R
"[RS5 gg)Nr�)r��appendr��perf_counterrrar{)r��frame�N�timess  ��rry�5StressTest.measure_itimer_resolution.<locals>.handler�s@����5�z�A�~����T�.�.�0�1�� � ��!3�!3�T�:�r!rr�rrz,detected median itimer() resolution: %.6f s.�NN)r�rrar{r�r�r�r�r�r��
statistics�medianr�verbose�print)r2ryr��	durations�medr�r�s     @@r�measure_itimer_resolution�$StressTest.measure_itimer_resolution�s��������	;�	;�	
����(�(�&�*<�*<�a�@����F�N�N�G�,��	��%�j�1�n��J�J�t���%�j�1�n�5:�#�e�*�q�.�4I�J�4I�q�U�1�Q�3�Z�%��(�*�4I�	�J����	�*���?�?��@�C�6�I�J��
��	Ks�5Dc�j�UR5nUS::agUS::agURSU4-5 g)Ng-C��6?i'g{�G�z�?�dz^detected itimer resolution (%.3f s.) too high (> 10 ms.) on this platform (or system too busy))r�r)r2�resos  r�decide_itimer_count�StressTest.decide_itimer_count�sB���-�-�/���4�<��
�T�\���M�M�M�!�G�$�
%r!raztest needs setitimer()c�8^�UR5n/mSnSU4SjjnUR[RU5 UR[RU5 UR[R
U5 Sn[R"5[R-nXA:GaR[R"[R"5[R5 US-
n[T5U:aY[R"5U:a@[R"S5 [T5U:a[R"5U:aM@[R"[R"5[R5 US-
n[T5U:aY[R"5U:a@[R"S5 [T5U:a[R"5U:aM@XA:aGMRUR[T5US5 g)	z+
This test uses dependent signal handlers.
c��[R"[RS[R"5S--5 g)Nr���h㈵��>)rrar{�random)r�r�s  r�
first_handler�@StressTest.test_stress_delivery_dependent.<locals>.first_handlers*��
���V�/�/���
�
��$�8N�1N�Or!Nc�(>�TRU5 grI�r��r�r��sigss  �r�second_handler�AStressTest.test_stress_delivery_dependent.<locals>.second_handler	�����K�K��r!rrrr�Some signals were lostr�)r�r�rr�r^r�r��	monotonicrr^r�rH�getpidr�r�r+)r2r�rr�
expected_sigs�deadliners      @r�test_stress_delivery_dependent�)StressTest.test_stress_delivery_dependent�sh���
�$�$�&����	P�	 �	
���F�N�N�M�2����F�N�N�M�2����F�N�N�N�3��
��>�>�#�g�&;�&;�;�����G�G�B�I�I�K����0��Q��M��d�)�m�+����0@�8�0K��
�
�4� ��d�)�m�+����0@�8�0K�
�G�G�B�I�I�K����0��Q��M��d�)�m�+����0@�8�0K��
�
�4� ��d�)�m�+����0@�8�0K���	
����T��A�'?�@r!c�x^�UR5n/mU4SjnUR[RU5 UR[RU5 SnX1:a�[R
"[RS[R"5S--5 [R"[R"5[R5 US-
n[R"[R5Hn[T5U:�dM O X1:aM�UR[T5US5 g)z.
This test uses simultaneous signal handlers.
c�(>�TRU5 grIrrs  �rry�=StressTest.test_stress_delivery_simultaneous.<locals>.handler/r
r!rr�rr>rN)r�r�rr r�rar{rr�rHr
r�sleeping_retryr^r�r+)r2r�ryrr�rs     @r�!test_stress_delivery_simultaneous�,StressTest.test_stress_delivery_simultaneous&s����
�$�$�&����	 �	
���F�N�N�G�,����F�N�N�G�,��
���
���V�/�/���
�
��$�8N�1N�O��G�G�B�I�I�K����0��Q��M��+�+�G�,A�,A�B���t�9�
�-��C���	
����T��A�'?�@r!z&crashes due to system bug (FB13453490)r^ztest needs SIGUSR1c�8^^^	^
^�[RmSm
Sm	SmU	4SjmUU
U4SjnUU	U
U4Sjn[R"TT5nUR[RTU5 [R"US9nSn[
R"5nUR5 U"5 SmUR5 URb`URURR[5 URSTS	S
3[URR55 SnSSS5 U(dURT	S5 UR!T	T
5 SmUR5 g!,(df   NL=f!SmUR5 f=f)NrFc�>�TS-
mgrqr%)r�r��num_received_signalss  �r�custom_handler�AStressTest.test_stress_modifying_handlers.<locals>.custom_handlerTs��� �A�%� r!c�^>�T(d%[R"T5 TS-
mT(dM$ggrq)r�raise_signal)�do_stop�num_sent_signalsr�s���r�set_interrupts�AStressTest.test_stress_modifying_handlers.<locals>.set_interruptsXs&�����#�#�F�+� �A�%� ��gr!c��>�TS:dTS:aS[S5H3nT[R4Hn[R"TU5 M M5 TS:aMJTS:aMRgg)Nr�rri N)r�rr)r�ryrrr r�s  ����r�cycle_handlers�AStressTest.test_stress_modifying_handlers.<locals>.cycle_handlers^sU���"�S�(�,@�1�,D��u��A�$2�F�N�N�#C���
�
�f�g�6�$D�&�#�S�(�,@�1�,Dr!)�targetTzSignal �dz ignored due to race condition)rr^r��	threading�Threadr�catch_unraisable_exception�startr��
unraisabler*�	exc_valuer�r�r��
assertGreaterr�)r2r!r$r��t�ignoredr�rrrr r�s       @@@@@r�test_stress_modifying_handlers�)StressTest.test_stress_modifying_handlersIsM��������� ����	&�	&�	7�	7��m�m�F�N�;������
�
�v�{�;����N�3��	��G��3�3�5�����	�� ��������=�=�,��)�)�"�-�-�*A�*A�7�K��M�M�!�&���+I�J��B�M�M�3�3�4�6�#�G�6�$��"�"�#7��;�� � �!5�7G�H��G�
�F�F�H�16�5��.�G�
�F�F�H�s%�F�BE4�.3F�4
F�>F�Fr%N)rAr=rBrCr�r�r�r�r�r�r�rrrr�rrr�r1rDr%r!rr�r��s����<��0%�������5�1�3�*A�3�*A�X������5�1�3�A�3�A�B�_�_�X�G�H�
������3�-�/��0�0�2�6�3�/�I�6r!r�c�r�\rSrSrSr\R"\RS:gS5S5r	Sr
SrSrg	)
�RaiseSignalTesti�c��UR[5 [R"[R5 SSS5 g!,(df   g=frI)rU�KeyboardInterruptrrr�rYs r�test_sigint�RaiseSignalTest.test_sigint�s/��
�
�
�0�
1�����
�
�.�2�
1�
1�s�%A�
ArzWindows specific testc���Sn[R"U5 URS5 g![a)nUR[R
:XaSnAgeSnAff=f)Nrrz#OSError (Invalid argument) expected)rr�failr��errno�EINVAL)r2rb�es   r�test_invalid_argument�%RaiseSignalTest.test_invalid_argument�sM��	��F�����'��I�I�;�<���	��w�w�%�,�,�&����		�s�),�
A�A�A�Ac�(^�SmU4Sjn[R"[RU5nUR[R[RU5 [R"[R5 UR	T5 g)NFc�
>�SmgrVr%)�a�b�is_oks  �rry�-RaiseSignalTest.test_handler.<locals>.handler�s����Er!)rr�r�rr�)r2ry�
old_signalrDs   @r�test_handler�RaiseSignalTest.test_handler�sY�����	��]�]�6�=�=�'�:�
�����
�
�v�}�}�j�A����F�M�M�*�����r!c�J�Sn[SU5up#nURSU5 g)Nz�if 1:
        import _thread
        class Foo():
            def __del__(self):
                _thread.interrupt_main()

        x = Foo()
        r�s/OSError: Signal 2 ignored due to race condition)rr�)r2r�rc�out�errs     r�test__thread_interrupt_main�+RaiseSignalTest.test__thread_interrupt_main�s*����(��d�3�����
�
�H�#�Nr!r%N)
rAr=rBrCr7r�r�r,r-r>rGrMrDr%r!rr4r4�s<��/��_�_�S�\�\�W�,�.E�F�	�G�	�	�Or!r4c�T�\rSrSr\R
"\"\S5S5S5rSr	g)�PidfdSignalTesti��pidfd_send_signalzpidfd support not built inc��UR[5n[R"S[R5 SSS5 WR
R[R:XaURS5 O9UR
R[R:XaURS5 URUR
R[R5 [R"S[R"53[R5nUR![R"U5 UR%[&S5 [R"U[R[)5S5 SSS5 UR[*5 [R"U[R5 SSS5 g!,(df   GN�=f!,(df   Nd=f!,(df   g=f)Nrzkernel does not support pidfdsz"Not enough privileges to use pidfsz/proc/z^siginfo must be None$)rUr�rrQr�r�r;�ENOSYSr�EPERMr+�EBADFr��openr
�O_DIRECTORYr�r��assertRaisesRegexr]�objectr6)r2r��my_pidfds   r�test_pidfd_send_signal�&PidfdSignalTest.test_pidfd_send_signal�s:��
�
�
�w�
'�2��$�$�Q��
�
�6�(�
�<�<������-��M�M�:�;�
�\�\�
�
�5�;�;�
.��M�M�>�?�������+�+�U�[�[�9��7�7�V�B�I�I�K�=�1�2�>�>�B��������(�+�
�
#�
#�I�/G�
H��$�$�X�v�}�}�f�h��J�I�
�
�
�0�
1��$�$�X�v�}�}�=�2�
1�(�
'��I�
H��
1�
1�s#�&G�0G*�)&G;�
G'�*
G8�;
H	r%N)
rAr=rBrCr�r�r�rr[rDr%r!rrPrP�s-��
�����+�,�$��
>�	�
>r!rPc�.�[R"5 grI)r�
reap_childrenr%r!r�tearDownModuler_�s�����r!�__main__)/r.r;rOr:r�rrr�r�r�r,r(r�r�r�r�test.supportrrrr�test.support.script_helperrr	r#�ImportError�TestCaserr�r-rFr�r�r�r�r�r&r�r:rcr�r�r4rPr_rA�mainr%r!r�<module>rfs�������	�
�
�
���
�������F���
/=�8�$�$�/=�d
�������(�*@�A�c=��"�"�c=�B�c=�T
���S�\�\�W�,�.@�A�-D��*�*�-D�B�-D�`S!�H�%�%�S!�l
�������(�*@�A�s=��)�)�s=�B�s=�l
���W�V�\�2�4L�M�@%�h�/�/�@%�N�@%�F
�������(�*@�A�	���W�V�^�4�6S�T�����	���W�R��(�*>�?�R&�x�(�(�R&�@��U�B�R&�j
�������(�*@�A�	���W�V�[�1�R�g�f�k�6R�J�L�\1��"�"�\1�L�B�\1�~P4�(�+�+�P4�f
|��"�"�|�~)O�h�'�'�)O�Z>�h�'�'�>�*��z���M�M�O���k-���I��s�J7�7K�K

Youez - 2016 - github.com/yon3zu
LinuXploit