Your IP : 216.73.216.213

Current Path : /opt/alt/python35/lib64/python3.5/test/__pycache__/
Upload File :
Current File : //opt/alt/python35/lib64/python3.5/test/__pycache__/test_signal.cpython-35.opt-2.pyc



���]j��@s?ddlZddlmZddlmZddlZddlZddlZddlZddl	Z	ddl
Z
ddlZddlZddl
Z
ddlZddlZddlZddlZddlmZmZyddlZWnek
rdZYnXyddlZWnek
r3dZYnXGdd�de�Zdd�Zd	d
�ZGdd�dej�Zejejd
kd�Gdd�dej��Z ejejd
kd�Gdd�dej��Z!ej"ejd
kd�Gdd�dej��Z#Gdd�dej�Z$ejejd
kd�Gdd�dej��Z%ej"e&e
d�d�Gdd�dej��Z'ejejd
kd�Gdd�dej��Z(ejejd
kd�Gd d!�d!ej��Z)Gd"d#�d#ej�Z*d$d%�Z+e,d&kr;ej-�dS)'�N)�support)�closing)�assert_python_ok�spawn_pythonc@seZdZdS)�HandlerBCalledN)�__name__�
__module__�__qualname__�r
r
�0/opt/alt/python35/lib64/python3.5/test_signal.pyrsrcCstjd�dS)Nr)�os�_exitr
r
r
r�exit_subprocesssrcOsVy|||�SWn>tk
rQ}z|jtjkr;�dSWYdd}~XnXdS)N)�OSError�errno�EINTR)Z__func�args�kwargs�er
r
r�ignoring_eintr'src@s4eZdZejedkd�dd��ZdS)�GenericTestsNztest needs threading modulecCs�x�tt�D]�}tt|�}|d
krD|j|tj�q
|dkrf|j|tj�q
|jd�r�|jd�r�|j|tj�q
|jd�r
|j|tj�|jt	j
d	�q
WdS)N�SIG_DFL�SIG_IGN�	SIG_BLOCK�SIG_UNBLOCK�SIG_SETMASKZSIGZSIG_ZCTRL_�win32>rr>rrr)�dir�signal�getattr�assertIsInstance�Handlers�Sigmasks�
startswith�Signals�assertEqual�sys�platform)�self�name�sigr
r
r�
test_enums2szGenericTests.test_enums)rrr	�unittest�skipIf�	threadingr+r
r
r
rr0srrzNot valid on Windowsc@s�eZdZdZdd�Zdd�Zddd�Zd	d
�Zdd�Zd
d�Z	dd�Z
eje
jdkd�dd��ZdS)�InterProcessSignalTests�cCstj�|_tj�dS)N)�gc�	isenabled�using_gc�disable)r(r
r
r�setUpEszInterProcessSignalTests.setUpcCs|jrtj�dS)N)r3r1�enable)r(r
r
r�tearDownIs	z InterProcessSignalTests.tearDownNcCsdjtj|d|��S)N��limit)�join�	traceback�format_stack)r(�framer9r
r
r�format_frameMsz$InterProcessSignalTests.format_framecCs
d|_dS)NT)�a_called)r(�signumr=r
r
r�handlerAPsz InterProcessSignalTests.handlerAcCs%d|_t||j|���dS)NT)�b_calledrr>)r(r@r=r
r
r�handlerBSs	z InterProcessSignalTests.handlerBcCsZxSy|j�dSWqtk
rQ}z|jtjkr?�WYdd}~XqXqWdS)N)�waitrrr)r(�childrr
r
rrDWs
zInterProcessSignalTests.waitcCs
tjtj|j�tjtj|j�tjtjtj�tjtjtj�d|_	d|_
tj�}t
tjddt|�g�}|r�|j|�|j	s�tjd�|j|j	�|j|j
�d|_	~yItjddt|�g�}|j|�tjd�|jd�Wn2tk
ri|j|j
�|j|j	�YnXt
tjddt|�g�}|r�|j|�y(tjd�tj�tjd�Wn0tk
r�Yn,|jdtj��YnX|jd	�dS)
NF�killz-HUP�z-USR1z#HandlerBCalled exception not raisedz-USR2z+Some other exception woke us from pause: %szTpause returned of its own accord, and the signal didn't arrive after another second.)r�SIGHUPrA�SIGUSR1rC�SIGUSR2r�SIGALRM�default_int_handlerr?rBr�getpidr�
subprocess�Popen�strrD�time�sleep�
assertTrue�assertFalse�failr�alarm�pause�KeyboardInterruptr;�
format_exc)r(�pidrEr
r
r�run_testasJ		!
	
	


!



	z InterProcessSignalTests.run_test�freebsd6zOinter process signals not reliable (do not mix well with threading) on freebsd6c
,Cs�tj�\}}ttj|d���Y}ttj|d���7}tj�}|dkr�z�ya|j�t|��Dy|j�Wntjt	j
�|�YnXtjd|�WdQRXWntd�t	j�YnXWdt
�X|j�tj|ggg|j�\}}}||krQtj|�}	|	rx|j|	�n'tj|tj�|jd|j�WdQRXWdQRXdS)N�rb�wbrzUh oh, raised from pickle.z!Test deadlocked after %d seconds.)r�piper�fdopen�fork�closer[�pickle�dumpr;rY�print�	print_excr�select�MAX_DURATION�loadrUrFr�SIGKILL)
r(Z	os_done_rZ	os_done_wZdone_rZdone_wrE�r�w�x�tbr
r
r�	test_main�s4	



'	z!InterProcessSignalTests.test_main)rrr	rhr5r7r>rArCrDr[r,r-r&r'ror
r
r
rr/As
=r/c@s@eZdZdd�Zdd�Zdd�Zdd�Zd	S)
�
PosixTestscGsdS)Nr
)r(rr
r
r�trivial_signal_handler�sz!PosixTests.trivial_signal_handlercCs6|jttjd�|jttjd|j�dS)Ni�)�assertRaises�
ValueErrorr�	getsignalrq)r(r
r
r�,test_out_of_range_signal_number_raises_error�sz7PosixTests.test_out_of_range_signal_number_raises_errorcCs |jttjtjd�dS)N)rr�	TypeErrorrrI)r(r
r
r�0test_setting_signal_handler_to_none_raises_error�sz;PosixTests.test_setting_signal_handler_to_none_raises_errorcCs}tjtj|j�}|j|tj�|jtjtj�|j�tjtj|�|jtjtj�|�dS)N)rrHrqr r!r%rt)r(Zhupr
r
r�test_getsignal�s
zPosixTests.test_getsignalN)rrr	rqrurwrxr
r
r
rrp�srpzWindows specificc@seZdZdd�ZdS)�WindowsSignalTestscCs�dd�}t�}xvtjtjtjtjtjtjtjfD]D}tj	|�dk	rFtj|tj||��|j
|�qFW|j|�|jt
��tjd|�WdQRX|jt
��tjd|�WdQRXdS)NcSsdS)Nr
)rm�yr
r
r�<lambda>�sz3WindowsSignalTests.test_issue9324.<locals>.<lambda>rG����)�setr�SIGABRTZSIGBREAK�SIGFPE�SIGILL�SIGINT�SIGSEGV�SIGTERMrt�addrSrrrs)r(�handlerZcheckedr*r
r
r�test_issue9324�s	
z!WindowsSignalTests.test_issue9324N)rrr	r�r
r
r
rry�sryc@sgeZdZdd�Zdd�Zdd�Zdd�Zeje	j
d	kd
�dd��Zd
S)�
WakeupFDTestscCs,tj�}|jttftj|�dS)N)rZmake_bad_fdrrrsrr�
set_wakeup_fd)r(�fdr
r
r�test_invalid_fd�szWakeupFDTests.test_invalid_fdcCsBtj�}|j�}|j�|jttftj|�dS)N)�socket�filenorbrrrsrrr�)r(�sockr�r
r
r�test_invalid_sockets

z!WakeupFDTests.test_invalid_socketcCs�tj�\}}|jtj|�|jtj|�tj�\}}|jtj|�|jtj|�ttd�r�tj|d�tj|d�tj|�|jtj|�|�|jtjd�|�|jtjd�d�dS)N�set_blockingFrGr}r}r})	rr_�
addCleanuprb�hasattrr�rr�r%)r(Zr1Zw1Zr2Zw2r
r
r�test_set_wakeup_fd_result
s
z'WakeupFDTests.test_set_wakeup_fd_resultcCs�tj�}|j|j�|jd�|j�}tj�}|j|j�|jd�|j�}tj|�|jtj|�|�|jtjd�|�|jtjd�d�dS)NFrGr}r}r})r�r�rb�setblockingr�rr�r%)r(Zsock1�fd1Zsock2�fd2r
r
r� test_set_wakeup_fd_socket_results


z.WakeupFDTests.test_set_wakeup_fd_socket_resultrztests specific to POSIXcCs�tj�\}}|jtj|�|jtj|�tj|d�|jt��}tj|�WdQRX|j	t
|j�d|�tj|d�tj|�tjd�dS)NTz&the fd %s must be in non-blocking modeFrGr})rr_r�rbr�rrrsrr�r%rP�	exception)r(ZrfdZwfd�cmr
r
r�test_set_wakeup_fd_blocking-s
z)WakeupFDTests.test_set_wakeup_fd_blockingN)rrr	r�r�r�r�r,r-r&r'r�r
r
r
rr��s
r�c@s�eZdZejedkd�dddd��Zejedkd�dd��Zd	d
�Zdd�Z	d
d�Z
ejee
d�d�dd��ZdS)�WakeupSignalTestsNzneed _testcapi�orderedTcGs5djttt|��||�}td|�dS)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)
        z-c)�format�tuple�map�intr)r(Z	test_bodyr�Zsignals�coder
r
r�check_wakeupBs#$zWakeupSignalTests.check_wakeupcCs�d}tj�\}}z:ytj|d�Wntk
rCYnX|jd�Wdtj|�tj|�Xtd|�dS)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:
                _testcapi.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 pipez-c)rr_�writer�skipTestrbr)r(r�rkrlr
r
r�test_wakeup_write_erroris&

z)WakeupSignalTests.test_wakeup_write_errorcCs|jdtj�dS)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�rrK)r(r
r
r�test_wakeup_fd_early�sz&WakeupSignalTests.test_wakeup_fd_earlycCs|jdtj�dS)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�rrK)r(r
r
r�test_wakeup_fd_during�sz'WakeupSignalTests.test_wakeup_fd_duringcCs|jdtjtj�dS)Nz�def test():
            import _testcapi
            signal.signal(signal.SIGUSR1, handler)
            _testcapi.raise_signal(signal.SIGUSR1)
            _testcapi.raise_signal(signal.SIGALRM)
        )r�rrIrK)r(r
r
r�test_signum�szWakeupSignalTests.test_signum�pthread_sigmaskzneed signal.pthread_sigmask()cCs#|jdtjtjdd�dS)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))
            _testcapi.raise_signal(signum1)
            _testcapi.raise_signal(signum2)
            # Unblocking the 2 signals calls the C signal handler twice
            signal.pthread_sigmask(signal.SIG_UNBLOCK, (signum1, signum2))
        r�F)r�rrIrJ)r(r
r
r�test_pending�szWakeupSignalTests.test_pending)rrr	r,r-�	_testcapir�r�r�r�r��
skipUnlessr�rr�r
r
r
rr�@s&$4"r��
socketpairzneed socket.socketpairc@sXeZdZejedkd�dd��Zejedkd�dd��ZdS)�WakeupSocketSignalTestsNzneed _testcapicCsd}td|�dS)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()
        read.setblocking(False)
        write.setblocking(False)
        signal.set_wakeup_fd(write.fileno())

        _testcapi.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()
        z-c)r)r(r�r
r
r�test_socket�s!z#WakeupSocketSignalTests.test_socketcCsAtjdkrd}nd}djd|�}td|�dS)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:
            _testcapi.raise_signal(signum)

        err = err.getvalue()
        if ('Exception ignored when trying to {action} to the signal wakeup fd'
            not in err):
            raise AssertionError(err)
        �actionz-c)rr)r�r)r(r�r�r
r
r�test_send_errors
	"z'WakeupSocketSignalTests.test_send_error)rrr	r,r-r�r�r�r
r
r
rr��s$%r�c@s@eZdZdd�Zdd�Zdd�Zdd�Zd	S)
�SiginterruptTestcCs�d|f}td|���}y+|jj�}|jdd�\}}Wn#tjk
ro|j�dSYnCX||}|j�}|d	kr�td||f��|dkSWdQRXdS)
Na�if 1:
            import errno
            import os
            import signal
            import sys

            interrupt = %r
            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)
        z-c�timeoutg@F��zChild error (exit code %s): %r)r�r�)	r�stdout�readline�communicaterN�TimeoutExpiredrFrD�	Exception)r(Z	interruptr��processZ
first_liner��stderr�exitcoder
r
r�readpipe_interruptedNs*

	
z%SiginterruptTest.readpipe_interruptedcCs |jd�}|j|�dS)N)r�rS)r(�interruptedr
r
r�test_without_siginterrupt�sz*SiginterruptTest.test_without_siginterruptcCs |jd�}|j|�dS)NT)r�rS)r(r�r
r
r�test_siginterrupt_on�sz%SiginterruptTest.test_siginterrupt_oncCs |jd�}|j|�dS)NF)r�rT)r(r�r
r
r�test_siginterrupt_off�sz&SiginterruptTest.test_siginterrupt_offN)rrr	r�r�r�r�r
r
r
rr�Ks<r�c@s�eZdZdd�Zdd�Zdd�Zdd�Zd	d
�Zdd�Zd
d�Z	e
jej
dkd�dd��Ze
jej
dkd�dd��Zdd�ZdS)�
ItimerTestcCs:d|_d|_d|_tjtj|j�|_dS)NFr)�hndl_called�
hndl_count�itimerrrK�sig_alrm�	old_alarm)r(r
r
rr5�s			zItimerTest.setUpcCs<tjtj|j�|jdk	r8tj|jd�dS)Nr)rrKr�r��	setitimer)r(r
r
rr7�szItimerTest.tearDowncGs
d|_dS)NT)r�)r(rr
r
rr��szItimerTest.sig_alrmcGs_d|_|jdkr*tjd��n"|jdkrLtjtjd�|jd7_dS)NTr�z.setitimer didn't disable ITIMER_VIRTUAL timer.rrG)r�r�r�ItimerErrorr��ITIMER_VIRTUAL)r(rr
r
r�
sig_vtalrm�s	zItimerTest.sig_vtalrmcGs d|_tjtjd�dS)NTr)r�rr��ITIMER_PROF)r(rr
r
r�sig_prof�s	zItimerTest.sig_profcCs |jtjtjdd�dS)NrGrr})rrrr�r�)r(r
r
r�test_itimer_exc�szItimerTest.test_itimer_exccCs@tj|_tj|jd�tj�|j|jd�dS)Ng�?T)r�ITIMER_REALr�r�rWr%r�)r(r
r
r�test_itimer_real�s
zItimerTest.test_itimer_realr\�netbsd5zDitimer not reliable (does not mix well with threading) on some BSDs.cCs�tj|_tjtj|j�tj|jdd�tj�}xRtj�|dkr�tddd�}tj	|j�d
krGPqGW|j
d�|jtj	|j�d�|j|jd	�dS)Ng333333�?g�������?gN@i90i2	i����z8timeout: likely cause: machine too slow or load too highT)r�r�)r�r�)
rr�r��	SIGVTALRMr�r�rQ�	monotonic�pow�	getitimerr�r%r�)r(�
start_time�_r
r
r�test_itimer_virtual�s
zItimerTest.test_itimer_virtualzBitimer not reliable (does not mix well with threading) on freebsd6cCs�tj|_tjtj|j�tj|jdd�tj�}xRtj�|dkr�tddd�}tj	|j�d	krGPqGW|j
d�|jtj	|j�d
�|j|jd�dS)Ng�������?gN@i90i2	i����z8timeout: likely cause: machine too slow or load too highT)r�r�)r�r�)
rr�r��SIGPROFr�r�rQr�r�r�r�r%r�)r(r�r�r
r
r�test_itimer_prof�s
zItimerTest.test_itimer_profcCsCtj|_tj|jd�tjd�|j|jd�dS)Ng���ư>rGT)rr�r�r�rQrRr%r�)r(r
r
r�test_setitimer_tiny�s
zItimerTest.test_setitimer_tinyN)r\r�)rrr	r5r7r�r�r�r�r�r,r-r&r'r�r�r�r
r
r
rr��s
	r�c@s�eZdZejeed�d�dd��Zejeed�d�ejeed�d�dd���Zejeed	�d
�dd��Z	ejeed�d�d
d��Z
ejeed�d�dd��Zejeed�d�dd��Zejeed�d�dd��Z
ejeed�d�dd��Zejeed�d�dd��Zejeed�d�dd ��Zejeed�d�ejeed�d�ejed!kd"�d#d$����Zejeed�d�d%d&��Zejeed�d�d'd(��Zejejd)kd*�ejeed	�d
�d+d,���Zd!S)-�PendingSignalsTests�
sigpendingzneed signal.sigpending()cCs|jtj�t��dS)N)r%rr�r~)r(r
r
r�test_sigpending_emptysz)PendingSignalsTests.test_sigpending_emptyr�zneed signal.pthread_sigmask()cCsd}td|�dS)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")
        z-c)r)r(r�r
r
r�test_sigpendingsz#PendingSignalsTests.test_sigpending�pthread_killzneed signal.pthread_kill()cCsd}td|�dS)Naiif 1:
            import signal
            import threading
            import sys

            signum = signal.SIGUSR1

            def handler(signum, frame):
                1/0

            signal.signal(signum, handler)

            if sys.platform == 'freebsd6':
                # Issue #12392 and #12469: send a signal to the main thread
                # doesn't work before the creation of the first thread on
                # FreeBSD 6
                def noop():
                    pass
                thread = threading.Thread(target=noop)
                thread.start()
                thread.join()

            tid = threading.get_ident()
            try:
                signal.pthread_kill(tid, signum)
            except ZeroDivisionError:
                pass
            else:
                raise Exception("ZeroDivisionError not raised")
        z-c)r)r(r�r
r
r�test_pthread_kill2s z%PendingSignalsTests.test_pthread_killcCs'd|j�|f}td|�dS)Nawif 1:
        import signal
        import sys
        from signal import Signals

        def handler(signum, frame):
            1/0

        %s

        blocked = %s
        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)
        z-c)�stripr)r(Zblocked�testr�r
r
r�wait_helperUs'zPendingSignalsTests.wait_helper�sigwaitzneed signal.sigwait()cCs|jtjd�dS)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�rrK)r(r
r
r�test_sigwait�sz PendingSignalsTests.test_sigwait�sigwaitinfozneed signal.sigwaitinfo()cCs|jtjd�dS)Nz�
        def test(signum):
            signal.alarm(1)
            info = signal.sigwaitinfo([signum])
            if info.si_signo != signum:
                raise Exception("info.si_signo != %s" % signum)
        )r�rrK)r(r
r
r�test_sigwaitinfo�sz$PendingSignalsTests.test_sigwaitinfo�sigtimedwaitzneed signal.sigtimedwait()cCs|jtjd�dS)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�rrK)r(r
r
r�test_sigtimedwait�sz%PendingSignalsTests.test_sigtimedwaitcCs|jtjd�dS)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�rrK)r(r
r
r�test_sigtimedwait_poll�sz*PendingSignalsTests.test_sigtimedwait_pollcCs|jtjd�dS)Nz�
        def test(signum):
            received = signal.sigtimedwait([signum], 1.0)
            if received is not None:
                raise Exception("received=%r" % (received,))
        )r�rrK)r(r
r
r�test_sigtimedwait_timeout�sz-PendingSignalsTests.test_sigtimedwait_timeoutcCs)tj}|jttj|gd�dS)Ng�?g�)rrKrrrsr�)r(r@r
r
r�"test_sigtimedwait_negative_timeout�s	z6PendingSignalsTests.test_sigtimedwait_negative_timeoutNztest needs threading modulecCstdd�dS)Nz-ca�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)r(r
r
r�test_sigwait_thread�s
z'PendingSignalsTests.test_sigwait_threadcCsb|jttj�|jttjd�|jttjddd�|jttjdg�dS)NrGr�r�i�)rrrvrr�r)r(r
r
r�test_pthread_sigmask_arguments�sz2PendingSignalsTests.test_pthread_sigmask_argumentscCsd}td|�dS)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))
        z-c)r)r(r�r
r
r�test_pthread_sigmask�sJz(PendingSignalsTests.test_pthread_sigmaskr\zpissue #12392: send a signal to the main thread doesn't work before the creation of the first thread on FreeBSD 6cCscd}td|��G}|j�\}}|j�}|dkrXtd||f��WdQRXdS)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)
        z-cr�zChild error (exit code %s): %s)rr�rDr�)r(r�r�r�r�r�r
r
r�test_pthread_kill_main_thread:sz1PendingSignalsTests.test_pthread_kill_main_thread)rrr	r,r�r�rr�r�r�r�r�r�r�r�r�r�r-r.r�r�r�r&r'r�r
r
r
rr�	sF"-

	*Lr�cCstj�dS)N)rZ
reap_childrenr
r
r
r�tearDownModuleWsr��__main__).r,r�r�
contextlibr�enumr1rcrgrr��structrNr;r&rrQrZtest.support.script_helperrrr.�ImportErrorr�r�rrrZTestCaserr-r'r/rpr�ryr�r�r�r�r�r�r�r�r�mainr
r
r
r�<module>sZ0


	%�%%D%�%S%T%h�O