Sindbad~EG File Manager

Current Path : /proc/2568807/root/usr/local/lib/python3.12/test/__pycache__/
Upload File :
Current File : //proc/2568807/root/usr/local/lib/python3.12/test/__pycache__/test_signal.cpython-312.pyc

�

'ΜgE��	�~�ddlZddlZddlZddlZddlZddlZddlZddlZddlZddl	Z	ddl
Z
ddlZddlZddl
Z
ddlmZddlmZddlmZmZddlmZ	ddlZGd�de
j0�Ze
j4e
j6dk(d	�Gd
�de
j0��Ze
j:e
j6dk(d�Gd
�de
j0��ZGd�de
j0�Ze
j4e
j6dk(d	�Gd�de
j0��Z e
j:e!ed�d�Gd�de
j0��Z"e
j4e
j6dk(d	�e
j:e!ed�d�ejF�e
j:e!ed�d�Gd�de
j0�����Z$e
j4e
j6dk(d	�e
j:e!ed�xr	e!ed�d�Gd �d!e
j0���Z%Gd"�d#e
j0�Z&Gd$�d%e
j0�Z'Gd&�d'e
j0�Z(Gd(�d)e
j0�Z)d*�Z*e+d+k(re
jX�yy#e$rdZY��cwxYw),�N)�support)�	os_helper)�assert_python_ok�spawn_python)�threading_helperc��eZdZd�Zd�Zy)�GenericTestsc��tt�D]�}tt|�}|dvr!|j|tj��8|dvr!|j|tj
��]|j
d�r2|j
d�s!|j|tj���|j
d�s��|j|tj�|jtjd���tjtjddd	�t�
�}tj|tj�tjtjddd�t�
�}tj|tj�ttd
d�}|�Dtjtjd
dd�t�
�}tj||�yy)N>�SIG_DFL�SIG_IGN>�	SIG_BLOCK�SIG_SETMASK�SIG_UNBLOCK�SIG�SIG_�CTRL_�win32�Signals�signalc��|j�xr%|jd�xr|jd�xs|jd�S)Nrrr)�isupper�
startswith��names �-/usr/local/lib/python3.12/test/test_signal.py�<lambda>z)GenericTests.test_enums.<locals>.<lambda>*sD���L�L�N�Q�����/�O�����8O�4O�0����w�/�0�)�source�Handlersc�
�|dvS)N)rr�rs rrz)GenericTests.test_enums.<locals>.<lambda>4s
��T�%;�;r�Sigmasksc�
�|dvS)N)r
rrr!rs rrz)GenericTests.test_enums.<locals>.<lambda>=s
���)T�!Tr)�dirr�getattr�assertIsInstancerr"rr�assertEqual�sys�platform�enum�
_old_convert_�IntEnum�_test_simple_enum)�selfr�sig�CheckedSignals�CheckedHandlersr"�CheckedSigmaskss       r�
test_enumszGenericTests.test_enumssu����K�D��&�$�'�C��-�-��%�%�c�6�?�?�;��D�D��%�%�c�6�?�?�;�����'�����0G��%�%�c�6�>�>�:�����)��%�%�c�6�>�>�:�� � ����w�7� ��+�+����i��0��
��	
���~�v�~�~�>��,�,����j�(�;����
	
�������@��6�:�t�4����"�0�0��L�L�*�h�T�!��O�

�"�"�?�H�=�
 rc���tt�D]Z}tt|�}tj|�s�)tj
|�r�?|j
|jd��\y)Nr)r$rr%�inspect�	isroutine�	isbuiltinr'�
__module__)r.r�values   r�test_functions_module_attrz'GenericTests.test_functions_module_attrBsO����K�D��F�D�)�E�� � ��'��0A�0A�%�0H�� � ��!1�!1�8�<� rN)�__name__r8�__qualname__r3r:r!rrr	r	s
��%>�N=rr	rzNot valid on Windowsc�H�eZdZd�Zd�Zd�Zd�Zd�Zd�Ze	jejjd�d�d	��Zd
�Ze	j eed�d�d
��Ze	j ej(d�ej,�d���Zy)�
PosixTestsc��y�Nr!�r.�argss  r�trivial_signal_handlerz!PosixTests.trivial_signal_handlerMs��rc�B�tj|j|�Sr@)�	functools�partialrC)r.�arguments  r�create_handler_with_partialz&PosixTests.create_handler_with_partialPs��� � ��!<�!<�h�G�Grc��|jttjd�|jttjd|j�|jttj
d�y)Ni�)�assertRaises�
ValueErrorr�	getsignalrC�	strsignal�r.s r�,test_out_of_range_signal_number_raises_errorz7PosixTests.test_out_of_range_signal_number_raises_errorSsU�����*�f�&6�&6��=����*�f�m�m�T��5�5�	7�	
���*�f�&6�&6��=rc�l�|jttjtjd�yr@)rJ�	TypeErrorr�SIGUSR1rNs r�0test_setting_signal_handler_to_none_raises_errorz;PosixTests.test_setting_signal_handler_to_none_raises_error[s!�����)�V�]�]� �.�.�$�	0rc���tjtj|j�}|j|tj�|jtjtj�|j�tjtj|�|jtjtj�|�yr@)r�SIGHUPrCr&rr'rL)r.�hups  r�test_getsignalzPosixTests.test_getsignal_s����m�m�F�M�M�4�+F�+F�G�����c�6�?�?�3�����)�)�&�-�-�8��4�4�	6��
�
�f�m�m�S�)�����)�)�&�-�-�8�#�>rc�T�Gd�d�}|�}|jd|j�|j|�}tjtj|�}|j|tj�|jtjtj�|�tjtj|�|jtjtj�|�|jd|j�y)Nc�$��eZdZd�Z�fd�Z�xZS)�GPosixTests.test_no_repr_is_called_on_signal_handler.<locals>.MyArgumentc��d|_y�Nr)�
repr_countrNs r�__init__zPPosixTests.test_no_repr_is_called_on_signal_handler.<locals>.MyArgument.__init__ks	��"#��rc�J��|xjdz
c_t�|�	�S�N�)r]�super�__repr__)r.�	__class__s �rrczPPosixTests.test_no_repr_is_called_on_signal_handler.<locals>.MyArgument.__repr__ns������1�$���w�'�)�)r)r;r8r<r^rc�
__classcell__)rds@r�
MyArgumentrZjs���
$�
*�
*rrfr)r'r]rHrrUr&rrL)r.rfrG�handlerrVs     r�(test_no_repr_is_called_on_signal_handlerz3PosixTests.test_no_repr_is_called_on_signal_handlergs���	*�	*��<������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�6�|jdtjtj��|jdtjtj��|jdtjtj
��y)N�	Interrupt�
Terminated�Hangup)�assertInrrM�SIGINT�SIGTERMrUrNs r�test_strsignalzPosixTests.test_strsignal}s[��	
�
�
�k�6�#3�#3�F�M�M�#B�C��
�
�l�F�$4�$4�V�^�^�$D�E��
�
�h�� 0� 0���� ?�@rc��tjjt�}tjj	|d�}t|�y)Nzsignalinterproctester.py)�os�path�dirname�__file__�joinr)r.ru�scripts   r�test_interprocess_signalz#PosixTests.test_interprocess_signal�s1���'�'�/�/�(�+�������g�'A�B���� r�
valid_signalszrequires signal.valid_signalsc���tj�}|j|t�|j	tj
j|�|j	tj
j|�|jd|�|jtj|�|jt|�tj�tt�D]v}|jd�s�|dvr�|j|��5tt|�}|j!|d�|j|tj�ddd��xy#1swY��xYw)Nrr>rrr)rrzr&�setrnrro�SIGALRM�assertNotIn�NSIG�
assertLess�lenr$r�subTestr%�assertGreaterEqual)r.�sr�signums    r�test_valid_signalszPosixTests.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��tjtjddgtj��}|jd|j�|j|jtj�y)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�PIPErnr�r'�
returncoderro)r.�processs  r�!test_keyboard_interrupt_exit_codez,PosixTests.test_keyboard_interrupt_exit_code�s_���.�.�����9�:�"���(��	
�
�
�*�G�N�N�;�����+�+�f�m�m�^�<rN)r;r8r<rCrHrOrSrWrh�unittest�skipIfr(r)rrqry�
skipUnless�hasattrrr�r�r�requires_subprocessr�r!rrr>r>Ks���
�H�>�0�?�1�,�X�_�_�S�\�\�,�,�X�6�F�H�A�H�A�!�
�X������(�'��5�	�5�,�X������)C�D� �W� � �"�	=�#�E�	=rr>zWindows specificc��eZdZd�Zd�Zejejd�e	j�d���Zy)�WindowsSignalTestsc��tj�}|j|t�|j	t|�d�|j
tjj|�|jd|�|jtj|�|jt|�tj�y)N�r)rrzr&r|r�r�rnrror~rr��r.r�s  rr�z%WindowsSignalTests.test_valid_signals�s���� � �"�����a��%�����A���*��
�
�f�n�n�+�+�Q�/�����A��������a�(�����A�����,rc���d�}t�}tjtjtjtj
tjtjtjfD]S}tj|���tj|tj||��|j|��U|j|�|jt�5tjd|�ddd�|jt�5tjd|�ddd�y#1swY�>xYw#1swYyxYw)Nc��yr@r!)�x�ys  rrz3WindowsSignalTests.test_issue9324.<locals>.<lambda>�s��tr����)r|r�SIGABRT�SIGBREAK�SIGFPE�SIGILLro�SIGSEGVrprL�add�
assertTruerJrK)r.rg�checkedr/s    r�test_issue9324z!WindowsSignalTests.test_issue9324�s���#���%���N�N�F�O�O�V�]�]��M�M�6�=�=�&�.�.��N�N�$�C�
����$�0��
�
�c�6�=�=��g�#>�?����C� �$�	
���� �
�
�
�z�
*��M�M�"�g�&�+��
�
�z�
*��M�M�!�W�%�+�
*�+�
*��+�
*�s�5E	�)E�	E�Er�c���tjtjddgtj��}|jd|j�d}|j|j|�y)z?KeyboardInterrupt triggers an exit using STATUS_CONTROL_C_EXIT.r�zraise KeyboardInterruptr�r�l:N)	r�r�r(r�r�rnr�r'r�)r.r��STATUS_CONTROL_C_EXITs   rr�z4WindowsSignalTests.test_keyboard_interrupt_exit_code�sZ���.�.�����'@�A�!���(��	
�
�
�*�G�N�N�;� *������+�+�-B�CrN)r;r8r<r�r�r�r�r(r�rr�r�r!rrr�r��sJ��-�&�*�X������)C�D� �W� � �"�D�#�E�Drr�c�*�eZdZd�Zd�Zejejd�d��Z	ejejd�ejee
d�d�d���Zejejd�ejejd�d	���Zejej"d
k(d�ejejd�ejee
d�d�d����Zy
)�
WakeupFDTestsc�<�|jt�5tjtj��ddd�|jt�5tjtjd�ddd�y#1swY�LxYw#1swYyxYw)N)r�F)rJrQr�
set_wakeup_fdrorNs r�test_invalid_callzWakeupFDTests.test_invalid_call�se��
�
�
�y�
)�� � ��
�
�6�*��
�
�y�
)�� � �����6�*�
)�	*�
)��*�
)�s�%B�%B�B�Bc��tj�}|jttft
j|�yr@)r�make_bad_fdrJrK�OSErrorrr�)r.�fds  r�test_invalid_fdzWakeupFDTests.test_invalid_fd�s0��
�
"�
"�
$�����:�w�/� �.�.��	4rzneeds working sockets.c���tj�}|j�}|j�|jtt
ftj|�yr@)�socket�fileno�closerJrKr�rr�)r.�sockr�s   r�test_invalid_socketz!WakeupFDTests.test_invalid_socket�sA���}�}���
�[�[�]���
�
�����:�w�/� �.�.��	4rzEmscripten cannot fstat pipes.�pipe�requires os.pipe()c���tj�\}}|jtj|�|jtj|�tj�\}}|jtj|�|jtj|�t	td�r,tj
|d�tj
|d�t
j|�|jt
j|�|�|jt
jd�|�|jt
jd�d�y)N�set_blockingFr�)	rsr��
addCleanupr�r�r�rr�r')r.�r1�w1�r2�w2s     r�test_set_wakeup_fd_resultz'WakeupFDTests.test_set_wakeup_fd_results���������B�������"�%�������"�%�������B�������"�%�������"�%��2�~�&��O�O�B��&��O�O�B��&����R� �����-�-�b�1�2�6�����-�-�b�1�2�6�����-�-�b�1�2�6rc�L�tj�}|j|j�|jd�|j	�}tj�}|j|j�|jd�|j	�}tj|�|jtj|�|�|jtjd�|�|jtjd�d�y)NFr�)r�r�r��setblockingr�rr�r')r.�sock1�fd1�sock2�fd2s     r� test_set_wakeup_fd_socket_resultz.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�6rrztests specific to POSIXc�,�tj�\}}|jtj|�|jtj|�tj|d�|jt�5}tj|�ddd�|jtj�d|z�tj|d�tj|�tjd�y#1swY�rxYw)NTz&the fd %s must be in non-blocking modeFr�)rsr�r�r�r�rJrKrr�r'�str�	exception)r.�rfd�wfd�cms    r�test_set_wakeup_fd_blockingz)WakeupFDTests.test_set_wakeup_fd_blocking(s����7�7�9���S�������#�&�������#�&�	����T�"�
�
�
�z�
*�b�� � ��%�+�����R�\�\�*�A�C�G�	I�	����U�#����S�!����R� �+�
*�s�D
�
DN)r;r8r<r�r�r�r�r�has_socket_supportr�r��
is_emscriptenr�rsr�r�r(r)r�r!rrr�r��s1��7�4�
�X����3�3�5M�N�4�O�4��X�_�_�W�*�*�,L�M��X�����V�,�.B�C�7�D�N�7�"�X�_�_�W�*�*�,L�M��X����3�3�5M�N�7�O�N�7�$�X�_�_�S�\�\�W�,�.G�H��X�_�_�W�*�*�,L�M��X�����V�,�.B�C�!�D�N�I�!rr�c�
�eZdZejedud�dd�d��Zejedud�ejee	d�d�d���Z
d	�Zd
�Zd�Z
ejeed�d
�d��Zy)�WakeupSignalTestsN�need _testcapiT��orderedc�p�djttt|��||�}t	d|�y)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)r.�	test_bodyr��signals�codes     r�check_wakeupzWakeupSignalTests.check_wakeup?s7�� �@
�F�5��S�'�*�+�W�i�@�A	
�D	��t�$rr�r�c�n�d}tj�\}}	tj|d�|jd�tj
|�tj
|�t
d|�y#t$rY�BwxYw#tj
|�tj
|�wxYw)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�)rsr��write�skipTestr�r�r)r.r��r�ws    r�test_wakeup_write_errorz)WakeupSignalTests.test_wakeup_write_errorfs���!��D�w�w�y���1�	��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(�A9�B�9	B�B�B�B�,B4c�D�|jdtj�y)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}rNs r�test_wakeup_fd_earlyz&WakeupSignalTests.test_wakeup_fd_early�s������>�^�^�?	rc�D�|jdtj�y)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))
        r�rNs r�test_wakeup_fd_duringz'WakeupSignalTests.test_wakeup_fd_during�s������6�^�^�7	rc�b�|jdtjtj�y)Nz�def test():
            signal.signal(signal.SIGUSR1, handler)
            signal.raise_signal(signal.SIGUSR1)
            signal.raise_signal(signal.SIGALRM)
        )r�rrRr}rNs r�test_signumzWakeupSignalTests.test_signum�s$�������^�^�V�^�^�		-r�pthread_sigmask�need signal.pthread_sigmask()c�f�|jdtjtjd��y)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�rrR�SIGUSR2rNs r�test_pendingzWakeupSignalTests.test_pending�s-��	
�����n�n�f�n�n�e�	�	=r)r;r8r<r�r��	_testcapir�r�r�rsr�r�r�r�rr�r!rrr�r�=s����X�_�_�Y�$�&�(8�9�8<�$%�:�$%�L�X�_�_�Y�$�&�(8�9��X�����V�,�.B�C�1%�D�:�1%�f �D�<-��X�����):�;�8�:�
=�:�
=rr��
socketpairzneed socket.socketpairc��eZdZejedud�d��Zejedud�d��Zejedud�d��Zy)�WakeupSocketSignalTestsNr�c� �d}td|�y)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�r.r�s  r�test_socketz#WakeupSocketSignalTests.test_socket�s����>	��t�$rc�p�tjdk(rd}nd}dj|��}td|�y)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��rsrr�r�r.rr�s   r�test_send_errorz'WakeupSocketSignalTests.test_send_errors@���7�7�d�?��F��F�!�B
�F�&�F�!�C	
�D	��t�$rc�p�tjdk(rd}nd}dj|��}td|�y)Nrrr�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)

        rr�rrs   r�test_warn_on_full_bufferz0WakeupSocketSignalTests.test_warn_on_full_bufferFsA���7�7�d�?��F��F�g�N
�F�&�F�!�O	
�P	��t�$r)	r;r8r<r�r�r�rr	rr!rrr�r��s{���X�_�_�Y�$�&�(8�9�!%�:�!%�F�X�_�_�Y�$�&�(8�9�(%�:�(%�T�X�_�_�Y�$�&�(8�9�n%�:�n%rr��siginterruptzneeds signal.siginterrupt()r�r�c�f�eZdZejfd�Zd�Zd�Zejd�d��Z	y)�SiginterruptTestc�r�d|�d�}td|�5}	|jj�}|j|��\}}||z}|j	�}|dvrtd|�d|����|dk(cd	d	d	�S#tj$r|j�Yd	d	d	�y
wxYw#1swYy	xYw)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 �): rNF)	r�stdout�readline�communicate�wait�	Exceptionr��TimeoutExpired�kill)	r.�	interruptrr�r��
first_linerr��exitcodes	         r�readpipe_interruptedz%SiginterruptTest.readpipe_interrupted�s���T�G#��H�$��
%��
'�$�^�^�4�4�6�
�!(�!4�!4�W�!4�!E����
$�f�,��"�<�<�>���6�)�#�'/��%9�:�:� �A�
�&�
%���,�,�
������&�
%�
��
&�
%�s.�B-�/A<�.B-�<#B*�B-�)B*�*B-�-B6c�H�|jd�}|j|�yr@�r r��r.�interrupteds  r�test_without_siginterruptz*SiginterruptTest.test_without_siginterrupt�� ���/�/��5������$rc�H�|jd�}|j|�y�NTr"r#s  r�test_siginterrupt_onz%SiginterruptTest.test_siginterrupt_onr&r�walltimec�L�|jdd��}|j|�y)NFrr)r �assertFalser#s  r�test_siginterrupt_offz&SiginterruptTest.test_siginterrupt_offs'��
�/�/��q�/�A������%rN)
r;r8r<r�
SHORT_TIMEOUTr r%r)�requires_resourcer-r!rrrr�s>��7>�6K�6K�:'�x%�%��W���z�*�&�+�&rr�	getitimer�	setitimerz/needs signal.getitimer() and signal.setitimer()c��eZdZd�Zd�Zd�Zd�Zd�Zd�Zd�Z	e
jejdvd	�d
��Zd�Zd�Zy
)�
ItimerTestc��d|_d|_d|_tjtj|j
�|_y)NFr)�hndl_called�
hndl_count�itimerrr}�sig_alrm�	old_alarmrNs r�setUpzItimerTest.setUps2�� ������������v�~�~�t�}�}�E��rc��tjtj|j�|j�!tj|jd�yyr\)rr}r9r7r1rNs r�tearDownzItimerTest.tearDowns;���
�
�f�n�n�d�n�n�5��;�;�"����T�[�[�!�,�#rc��d|_yr()r5rAs  rr8zItimerTest.sig_alrm!s
����rc���d|_|jdkDrtjd��|jdk(r$tjtj
d�|xjdz
c_y)NTrz.setitimer didn't disable ITIMER_VIRTUAL timer.rra)r5r6r�ItimerErrorr1�ITIMER_VIRTUALrAs  r�
sig_vtalrmzItimerTest.sig_vtalrm$s^������?�?�Q���$�$�&��
�
�_�_��
!����V�2�2�A�6����1��rc�Z�d|_tjtjd�y)NTr)r5rr1�ITIMER_PROFrAs  r�sig_profzItimerTest.sig_prof1s ���������+�+�Q�/rc�d�|jtjtjdd�y)Nr�r)rJrr?r1�ITIMER_REALrNs r�test_itimer_exczItimerTest.test_itimer_exc5s'��	
���&�,�,�f�.>�.>��A�F�rc���tj|_tj|jd�tj�|j|jd�y)Ng�?T)rrFr7r1�pauser'r5rNs r�test_itimer_realzItimerTest.test_itimer_real>sB���(�(���������c�*���������)�)�4�0r)�netbsd5zDitimer not reliable (does not mix well with threading) on some BSDs.c��tj|_tjtj|j�tj
|jdd�t
jtj�D]3}tddd�}tj|j�dk(s�3n|jtj|j�d�|j|jd�y)Ng333333�?皙�����?�90�2	铖���rRT)
rr@r7�	SIGVTALRMrAr1r�
busy_retry�LONG_TIMEOUT�powr0r'r5�r.�_s  r�test_itimer_virtualzItimerTest.test_itimer_virtualEs����+�+����
�
�f�&�&����8�������c�3�/��#�#�G�$8�$8�9�A��E�5�(�+�A�������,�
�:��:�	
����)�)�$�+�+�6�
�C�����)�)�4�0rc��tj|_tjtj|j�tj
|jdd�t
jtj�D]3}tddd�}tj|j�dk(s�3n|jtj|j�d�|j|jd�y)NrMrNrOrPrQT)
rrCr7�SIGPROFrDr1rrTrUrVr0r'r5rWs  r�test_itimer_profzItimerTest.test_itimer_profXs����(�(����
�
�f�n�n�d�m�m�4�������c�3�/��#�#�G�$8�$8�9�A��E�5�(�+�A�������,�
�:��:�	
����)�)�$�+�+�6�
�C�����)�)�4�0rc���tj|_tj|jd�t	j
d�|j
|jd�y)N���ư>raT)rrFr7r1�time�sleepr'r5rNs r�test_setitimer_tinyzItimerTest.test_setitimer_tinyisF���(�(���������d�+��
�
�1�
�����)�)�4�0rN)r;r8r<r:r<r8rArDrGrJr�r�r(r)rYr\rar!rrr3r3s`��F�-� ��0�H�1��X�_�_�S�\�\�\�1�N�P�1�P�1�"1�"1rr3c���eZdZdZej
eed�d�d��Zej
eed�d�ej
eed�d�d���Z	ej
eed�d	�e
j�d
���Zej
eed�d�d��Z
ej
eed�d
�d��Zej
eed�d�d��Zej
eed�d�d��Zej
eed�d�d��Zej
eed�d�d��Zej
eed�d�d��Zej
eed�d
�ej
eed�d�e
j�d����Zej
eed�d�d��Zej
eed�d�d��Zej
eed�d�e
j�d���Zej
eed�d	�e
j�d���Zy)�PendingSignalsTestsz[
    Test pthread_sigmask(), pthread_kill(), sigpending() and sigwait()
    functions.
    �
sigpendingzneed signal.sigpending()c�\�|jtj�t��yr@)r'rrdr|rNs r�test_sigpending_emptyz)PendingSignalsTests.test_sigpending_emptyxs��	
����*�*�,�c�e�4rr�r�c� �d}td|�y)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�rs  r�test_sigpendingz#PendingSignalsTests.test_sigpending}s��
��0	��t�$r�pthread_killzneed signal.pthread_kill()c� �d}td|�y)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�rs  r�test_pthread_killz%PendingSignalsTests.test_pthread_kill�s����(	��t�$rc�J�d|j��d|�d�}td|�y)zo
        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)r.�blocked�testr�s    r�wait_helperzPendingSignalsTests.wait_helper�s%��N�z�z�|�W�A &��J	��t�$r�sigwaitzneed signal.sigwait()c�D�|jtjd�y)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))
        �rprr}rNs r�test_sigwaitz PendingSignalsTests.test_sigwait�s��	
������*�	
r�sigwaitinfozneed signal.sigwaitinfo()c�D�|jtjd�y)Nz�
        def test(signum):
            signal.alarm(1)
            info = signal.sigwaitinfo([signum])
            if info.si_signo != signum:
                raise Exception("info.si_signo != %s" % signum)
        rsrNs r�test_sigwaitinfoz$PendingSignalsTests.test_sigwaitinfo����	
������*�	
r�sigtimedwaitzneed signal.sigtimedwait()c�D�|jtjd�y)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)
        rsrNs r�test_sigtimedwaitz%PendingSignalsTests.test_sigtimedwait�rxrc�D�|jtjd�y)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)
        rsrNs r�test_sigtimedwait_pollz*PendingSignalsTests.test_sigtimedwait_polls��	
������*�	
rc�D�|jtjd�y)Nz�
        def test(signum):
            received = signal.sigtimedwait([signum], 1.0)
            if received is not None:
                raise Exception("received=%r" % (received,))
        rsrNs r�test_sigtimedwait_timeoutz-PendingSignalsTests.test_sigtimedwait_timeouts��	
������*�	
rc�r�tj}|jttj|gd�y)Ng�)rr}rJrKry)r.r�s  r�"test_sigtimedwait_negative_timeoutz6PendingSignalsTests.test_sigtimedwait_negative_timeouts)���������*�f�&9�&9�F�8�T�Jrc��tdd�y)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�rNs r�test_sigwait_threadz'PendingSignalsTests.test_sigwait_thread#s��	�� �	
rc�,�|jttj�|jttjd�|jttjddd�|jttjdg�|jt
�5tjtjtjg�ddd�|jt
�5tjtjdg�ddd�|jt
�5tjtjddzg�ddd�y#1swY��xYw#1swY�\xYw#1swYyxYw)Nrarri�ri�)rJrQrr�r�rKr
rrNs r�test_pthread_sigmask_argumentsz2PendingSignalsTests.test_pthread_sigmask_argumentsFs��	
���)�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$�,4E2�=&E>�)F
�2E;�>F�
Fc��tjtjtj��}|j	tjtj
|�tjtjtj��}|j|tj��yr@)rr�r
rzr�rr�assertLessEqualr�s  r�"test_pthread_sigmask_valid_signalsz6PendingSignalsTests.test_pthread_sigmask_valid_signalsTs{��
�"�"�6�#3�#3�V�5I�5I�5K�L������.�.��0B�0B�A�F��"�"�6�#5�#5�v�7K�7K�7M�N�����Q�� 4� 4� 6�7rc� �d}td|�y)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�rs  r�test_pthread_sigmaskz(PendingSignalsTests.test_pthread_sigmask]s��G��P	��t�$rc��d}td|�5}|j�\}}|j�}|dk7rtd|�d|����	ddd�y#1swYyxYw)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�rrr)rrrr)r.r�r�rr�rs      r�test_pthread_kill_main_threadz1PendingSignalsTests.test_pthread_kill_main_thread�sc�����$��
%��$�0�0�2�N�F�F��|�|�~�H��1�}��!)�6�!3�4�4��&�
%�
%�s�:A�AN)r;r8r<�__doc__r�r�r�rrfrhr�requires_working_threadingrkrprtrwr{r}rr�r�r�r�r�r�r!rrrcrcssJ����X������6�3�5�5�5�5��X�����):�;�8�:��X������6�3�5�%�5�:�%�6�X������8�5�7�0��0�0�2�%�3�7�%�.�X�����):�;�8�:�*%�:�*%�X�X������3�0�2�
�2�
��X������7�4�6�
�6�
��X������8�5�7�
�7�
��X������8�5�7�	
�7�	
��X������8�5�7�
�7�
��X������8�5�7�K�7�K��X������3�0�2��X�����):�;�8�:�0��0�0�2�
�3�:�2�

�<�X�����):�;�8�:�
@�:�
@��X�����):�;�8�:�8�:�8��X�����):�;�8�:�0��0�0�2�I%�3�:�I%�V�X������8�5�7�0��0�0�2�4�3�7�4rrcc�P�eZdZdZd�Zd�Zd�Zeje	e
d�d�d��Zeje	e
d�d�d��Zejejd	k(d
�eje	e
d�d�ej"�d
����Zy)�
StressTestz�
    Stress signal delivery, especially when a signal arrives in
    the middle of recomputing the signal state or executing
    previously tripped signal handlers.
    c�r�tj||�}|jtj||�yr@)rr�)r.r�rg�old_handlers    r�setsigzStressTest.setsig�s&���m�m�F�G�4������
�
�v�{�;rc����d�g�d��fd�	}|jtjtjd�|j	tj
|�|�t
���kr$tjd�t
���kr�$tt
��dz
�D�cgc]}�|dz�|z
��}}tj|�}tjrtd|fz�|Scc}w)N�c���t���krH�jtj��t	j
tjd�yy)Nr^)r��appendr_�perf_counterrr1rF)r��frame�N�timess  ��rrgz5StressTest.measure_itimer_resolution.<locals>.handler�s@����5�z�A�~����T�.�.�0�1�� � ��!3�!3�T�:�rrg����MbP?raz,detected median itimer() resolution: %.6f s.�NN)r�rr1rFr�r}r�r_r`�range�
statistics�medianr�verbose�print)r.rg�i�	durations�medr�r�s     @@r�measure_itimer_resolutionz$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�/C<c�f�|j�}|dkry|dkry|jd|fz�y)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�)r.�resos  r�decide_itimer_countzStressTest.decide_itimer_count�sB���-�-�/���4�<��
�T�\���M�M�M�!�G�$�
%rr1ztest needs setitimer()c���|j�}g�d�}d�fd�	}|jtj|�|jtj|�|jtj
|�d}t
j�tjz}||k�r=tjtj�tj�|dz
}t��|krRt
j�|kr;t
jd�t��|krt
j�|kr�;tjtj�tj�|dz
}t��|krRt
j�|kr;t
jd�t��|krt
j�|kr�;||kr��=|jt��|d�y)	z;
        This test uses dependent signal handlers.
        c�|�tjtjdtj�dzz�y)Nr^��h㈵��>)rr1rF�random)r�r�s  r�
first_handlerz@StressTest.test_stress_delivery_dependent.<locals>.first_handlers*��
���V�/�/���
�
��$�8N�1N�OrNc�(���j|�yr@�r��r�r��sigss  �r�second_handlerzAStressTest.test_stress_delivery_dependent.<locals>.second_handler�����K�K��rrrar��Some signals were lostr�)r�r�rr[rRr}r_�	monotonicrr.rsr�getpidr�r`r')r.r�r�r��
expected_sigs�deadliner�s      @r�test_stress_delivery_dependentz)StressTest.test_stress_delivery_dependent�sl���
�$�$�&����	P�	 �	
���F�N�N�M�2����F�N�N�M�2����F�N�N�N�3��
��>�>�#�g�&;�&;�;���a���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��a��	
����T��A�'?�@rc�d��|j�}g��fd�}|jtj|�|jtj|�d}||kr�tj
tjdtj�dzz�tjtj�tj�|dz
}tjtj�D]}t��|k\s�n||kr��|jt��|d�y)z>
        This test uses simultaneous signal handlers.
        c�(���j|�yr@r�r�s  �rrgz=StressTest.test_stress_delivery_simultaneous.<locals>.handler.r�rrr^r�rr�N)r�r�rrRr}r1rFr�rsrr�r�sleeping_retryr.r�r')r.r�rgr�rXr�s     @r�!test_stress_delivery_simultaneousz,StressTest.test_stress_delivery_simultaneous%s����
�$�$�&����	 �	
���F�N�N�G�,����F�N�N�G�,��
��a��
���V�/�/���
�
��$�8N�1N�O��G�G�B�I�I�K����0��Q��M��+�+�G�,A�,A�B���t�9�
�-��C��a��	
����T��A�'?�@r�darwinz&crashes due to system bug (FB13453490)rRztest needs SIGUSR1c����	�
��tj�d�
d�	d��	fd����
�fd�}��	�
�fd�}tj���}|jtj�|�tj|��}	d}tj�5}|j�|�d�|j�|j�`|j|jjt�|jd�d	�d
�t|jj��d}ddd�|s|j�	d�|j!�	�
�d�|j�y#1swY�BxYw#d�|j�wxYw)NrFc����dz
�yr`r!)r�r��num_received_signalss  �r�custom_handlerzAStressTest.test_stress_modifying_handlers.<locals>.custom_handlerPs��� �A�%� rc�F���stj���dz
��s�yyr`)r�raise_signal)�do_stop�num_sent_signalsr�s���r�set_interruptszAStressTest.test_stress_modifying_handlers.<locals>.set_interruptsTs$�����#�#�F�+� �A�%� �rc����dks�dkrJtd�D]/}�tjfD]}tj�|���1�dkr�C�dkr�Iyy)Nr�rai N)r�rr)r�rgr�r�r�r�s  ����r�cycle_handlerszAStressTest.test_stress_modifying_handlers.<locals>.cycle_handlersZsU���"�S�(�,@�1�,D��u��A�$2�F�N�N�#C���
�
�f�g�6�$D�&�#�S�(�,@�1�,Dr)�targetTzSignal �dz ignored due to race condition)rrRr��	threading�Threadr�catch_unraisable_exception�startrw�
unraisabler&�	exc_valuer�rnr��
assertGreaterr�)r.r�r�r��t�ignoredr�r�r�r�r�r�s       @@@@@r�test_stress_modifying_handlersz)StressTest.test_stress_modifying_handlersEsH��������� ����	&�	&�	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%�>E7�BE+�*.E7�+E4�0E7�7FN)r;r8r<r�r�r�r�r�r�r�rr�r�r�r(r)rr�r�r!rrr�r��s����<��0%��X������5�1�3�*A�3�*A�X�X������5�1�3�A�3�A�<�X�_�_�S�\�\�X�-�/W�X��X������3�-�/�0��0�0�2�6�3�/�Y�6rr�c�j�eZdZd�Zej
ejdk7d�d��Zd�Z	d�Z
y)�RaiseSignalTestc��|jt�5tjtj�ddd�y#1swYyxYwr@)rJ�KeyboardInterruptrr�rorNs r�test_sigintzRaiseSignalTest.test_sigint�s/��
�
�
�0�
1�����
�
�.�2�
1�
1�s�$A�ArzWindows specific testc��	d}tj|�|jd�y#t$r)}|jtj
k(rn�Yd}~yd}~wwxYw)Nraz#OSError (Invalid argument) expected)rr��failr��errno�EINVAL)r.rU�es   r�test_invalid_argumentz%RaiseSignalTest.test_invalid_argument�sR��	��F�����'��I�I�;�<���	��w�w�%�,�,�&�����	�s�(+�	A�A�Ac�"��d��fd�}tjtj|�}|jtjtj|�tjtj�|j	��y)NFc�
��d�yr(r!)�a�b�is_oks  �rrgz-RaiseSignalTest.test_handler.<locals>.handler�s����Er)rror�r�r�)r.rg�
old_signalr�s   @r�test_handlerzRaiseSignalTest.test_handler�sY�����	��]�]�6�=�=�'�:�
�����
�
�v�}�}�j�A����F�M�M�*�����rc�L�d}td|�\}}}|jd|�y)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)rrn)r.r��rc�out�errs     r�test__thread_interrupt_mainz+RaiseSignalTest.test__thread_interrupt_main�s,����(��d�3���C���
�
�H�#�NrN)r;r8r<r�r�r�r(r)r�r�r�r!rrr�r��s>��/��X�_�_�S�\�\�W�,�.E�F�	�G�	�	�Orr�c�L�eZdZejeed�d�d��Zy)�PidfdSignalTest�pidfd_send_signalzpidfd support not built inc���|jt�5}tjdtj�ddd�j
jtjk(r|jd�n8|j
jtjk(r|jd�|j|j
jtj�tjdtj���tj�}|j!tj"|�|j%t&d�5tj|tjt)�d�ddd�|jt*�5tj|tj�ddd�y#1swY���xYw#1swY�YxYw#1swYyxYw)Nrzkernel does not support pidfdsz"Not enough privileges to use pidfsz/proc/z^siginfo must be None$)rJr�rr�ror�r��ENOSYSr��EPERMr'�EBADFrs�openr��O_DIRECTORYr�r��assertRaisesRegexrQ�objectr�)r.r��my_pidfds   r�test_pidfd_send_signalz&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�/G�#%G*�G�G'�*G3N)r;r8r<r�r�r�rr�r!rrr�r��s/���X�����+�,�$��
>�	�
>rr�c�,�tj�yr@)r�
reap_childrenr!rr�tearDownModuler��s�����r�__main__)-r*r�rEr5rsr�rr�r�r�r(r�r_r�ror�test.supportr�test.support.script_helperrrrr��ImportError�TestCaser	r�r)r>r�r�r�r�r�r�r�rr3rcr�r�r�r�r;�mainr!rr�<module>rs�������	�
�
�
���
�����"�E�)���
/=�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
y��"�"�y�x)O�h�'�'�)O�Z>�h�'�'�>�*��z���H�M�M�O���e-���I��s�J1�1J<�;J<

Sindbad File Manager Version 1.0, Coded By Sindbad EG ~ The Terrorists