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-1.pyc



��Yfj��@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
�5/opt/alt/python35/lib64/python3.5/test/test_signal.pyrsrcCstjd�dS)z�Use os._exit(0) to exit the current subprocess.

    Otherwise, the test catches the SystemExit and continues executing
    in parallel with the original test, so you wind up with an
    exponential number of tests running concurrently.
    rN)�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�HandlersZSigmasks�
startswithZSignals�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)r1r/�enable)r&r
r
r�tearDownIs	z InterProcessSignalTests.tearDownNcCsdjtj|d|��S)N��limit)�join�	traceback�format_stack)r&�framer7r
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)z)Wait for child to finish, ignoring EINTR.N)�waitrrr)r&�childrr
r
rrBWs
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�SIGHUPr?�SIGUSR1rA�SIGUSR2r�SIGALRM�default_int_handlerr=r@r�getpidr�
subprocess�Popen�strrB�time�sleep�
assertTrue�assertFalse�failr�alarm�pause�KeyboardInterruptr9�
format_exc)r&�pidrCr
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�closerY�pickle�dumpr9rW�print�	print_excr�select�MAX_DURATION�loadrSrDr�SIGKILL)
r&Z	os_done_rZ	os_done_wZdone_rZdone_wrC�r�w�x�tbr
r
r�	test_main�s4	



'	z!InterProcessSignalTests.test_main)rrr	rfr3r5r<r?rArBrYr*r+r$r%rmr
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�	getsignalro)r&r
r
r�,test_out_of_range_signal_number_raises_error�sz7PosixTests.test_out_of_range_signal_number_raises_errorcCs |jttjtjd�dS)N)rp�	TypeErrorrrG)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)rrFror r!r#rr)r&Zhupr
r
r�test_getsignal�s
zPosixTests.test_getsignalN)rrr	rorsrurvr
r
r
rrn�srnzWindows 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
)rk�yr
r
r�<lambda>�sz3WindowsSignalTests.test_issue9324.<locals>.<lambda>rE����)�setr�SIGABRTZSIGBREAK�SIGFPE�SIGILL�SIGINT�SIGSEGV�SIGTERMrr�addrQrprq)r&ZhandlerZcheckedr(r
r
r�test_issue9324�s	
z!WindowsSignalTests.test_issue9324N)rrr	r�r
r
r
rrw�srwc@sgeZdZdd�Zdd�Zdd�Zdd�Zeje	j
d	kd
�dd��Zd
S)�
WakeupFDTestscCs,tj�}|jttftj|�dS)N)rZmake_bad_fdrprqrr�
set_wakeup_fd)r&�fdr
r
r�test_invalid_fd�szWakeupFDTests.test_invalid_fdcCsBtj�}|j�}|j�|jttftj|�dS)N)�socket�filenor`rprqrrr�)r&Zsockr�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_blockingFrEr{r{r{)	rr]�
addCleanupr`�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)NFrEr{r{r{)r�r�r`Zsetblockingr�rr�r#)r&Zsock1Zfd1Zsock2Zfd2r
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 modeFrEr{)rr]r�r`r�rprqrr�r#rNZ	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�skipTestr`r)r&r�rirjr
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�rrI)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�rrI)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�rrGrI)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�rrGrH)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�Z
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��|dkSWd	QRXd	S)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.
        a�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-cZtimeoutg@F��zChild error (exit code %s): %rN)r�r�)	r�stdout�readline�communicaterLZTimeoutExpiredrDrB�	Exception)r&Z	interruptr��processZ
first_liner��stderr�exitcoder
r
r�readpipe_interruptedNs*

	
z%SiginterruptTest.readpipe_interruptedcCs |jd�}|j|�dS)N)r�rQ)r&�interruptedr
r
r�test_without_siginterrupt�sz*SiginterruptTest.test_without_siginterruptcCs |jd�}|j|�dS)NT)r�rQ)r&r�r
r
r�test_siginterrupt_on�sz%SiginterruptTest.test_siginterrupt_oncCs |jd�}|j|�dS)NF)r�rR)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�itimerrrI�sig_alrm�	old_alarm)r&r
r
rr3�s			zItimerTest.setUpcCs<tjtj|j�|jdk	r8tj|jd�dS)Nr)rrIr�r��	setitimer)r&r
r
rr5�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.rrE)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)NrErr{)rprr�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�rUr#r�)r&r
r
r�test_itimer_real�s
zItimerTest.test_itimer_realrZ�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�rO�	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�rOr�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���ư>rET)rr�r�r�rOrPr#r�)r&r
r
r�test_setitimer_tiny�s
zItimerTest.test_setitimer_tinyN)rZr�)rrr	r3r5r�r�r�r�r�r*r+r$r%r�r�r�r
r
r
rr��s
	r�c@s�eZdZdZejeed�d�dd��Zejeed�d�ejeed�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�d d!��Zejeed�d�ejeed�d�ejed"kd#�d$d%����Zejeed�d�d&d'��Zejeed�d�d(d)��Zejejd*kd+�ejeed
�d�d,d-���Zd"S).�PendingSignalsTestsz[
    Test pthread_sigmask(), pthread_kill(), sigpending() and sigwait()
    functions.
    �
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)zo
        test: body of the "def test(signum):" function.
        blocked: number of the blocked signal
        awif 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-cN)�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�rrI)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�rrI)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�rrI)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�rrI)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�rrI)r&r
r
r�test_sigtimedwait_timeout�sz-PendingSignalsTests.test_sigtimedwait_timeoutcCs)tj}|jttj|gd�dS)Ng�?g�)rrIrprqr�)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)NrEr�r�i�)rprtrr�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_sigmaskrZzpissue #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�rBr�)r&r�r�r�r�r�r
r
r�test_pthread_kill_main_thread:sz1PendingSignalsTests.test_pthread_kill_main_thread)rrr	�__doc__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�	sH"-

	*Lr�cCstj�dS)N)rZ
reap_childrenr
r
r
r�tearDownModuleWsr��__main__).r*r�r�
contextlibrZenumr/rarerr�ZstructrLr9r$rrOrZtest.support.script_helperrrr,�ImportErrorr�r�rrrZTestCaserr+r%r-rnr�rwr�r�r�r�r�r�r�r�r�mainr
r
r
r�<module>sZ0

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