Your IP : 216.73.216.213

Current Path : /proc/242857/root/opt/alt/python34/lib64/python3.4/test/__pycache__/
Upload File :
Current File : //proc/242857/root/opt/alt/python34/lib64/python3.4/test/__pycache__/test_signal.cpython-34.pyo

�
h fN��
@s�ddlZddlmZddlmZddlZddlZddlZddlZddl	Z	ddl
Z
ddlZddlZddl
Z
ddlZddlZddlmZmZyddlZWnek
r�dZYnXGdd�de�Zdd�Zd	d
�Zejejdkd�Gd
d�dej��Zejejdkd�Gdd�dej��Zejejdkd�Gdd�dej��ZGdd�dej�Z ejejdkd�Gdd�dej��Z!ejejdkd�Gdd�dej��Z"ejejdkd�Gdd�dej��Z#Gdd�dej�Z$dd�Z%e&d kr�e%�ndS)!�N)�support)�closing)�assert_python_ok�spawn_pythonc@seZdZdS)�HandlerBCalledN)�__name__�
__module__�__qualname__�r
r
�5/opt/alt/python34/lib64/python3.4/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_subprocesssrcOsYy|||�SWnAtk
rT}z!|jtjkr>�ndSWYdd}~XnXdS)N)�OSError�errno�EINTR)Z__func�args�kwargs�er
r
r�ignoring_eintr!sr�win32zNot 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)�selfr
r
r�setUp.szInterProcessSignalTests.setUpcCs|jrtj�ndS)N)rr�enable)rr
r
r�tearDown2s	z InterProcessSignalTests.tearDownNcCsdjtj|d|��S)N��limit)�join�	traceback�format_stack)r�framer"r
r
r�format_frame6sz$InterProcessSignalTests.format_framecCs
d|_dS)NT)�a_called)r�signumr&r
r
r�handlerA9sz InterProcessSignalTests.handlerAcCs%d|_t||j|���dS)NT)�b_calledrr')rr)r&r
r
r�handlerB<s	z InterProcessSignalTests.handlerBcCs]xVy|j�dSWqtk
rT}z|jtjkrB�nWYdd}~XqXqWdS)z)Wait for child to finish, ignoring EINTR.N)�waitrrr)r�childrr
r
rr-@s
zInterProcessSignalTests.waitcCstjtj|j�tjtj|j�tjtjtj�tjtjtj�d|_	d|_
tj�}t
tjddt|�g�}|r�|j|�|j	s�tjd�q�n|j|j	�|j|j
�d|_	~yItjddt|�g�}|j|�tjd�|jd�Wn2tk
ro|j|j
�|j|j	�YnXt
tjddt|�g�}|r�|j|�ny(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.)�signal�SIGHUPr*�SIGUSR1r,�SIGUSR2�SIG_IGN�SIGALRM�default_int_handlerr(r+r�getpidr�
subprocess�Popen�strr-�timeZsleep�
assertTrue�assertFalse�failr�alarm�pause�KeyboardInterruptr$�
format_exc)r�pidr.r
r
r�run_testJsJ		!
		


!


	z InterProcessSignalTests.run_test�freebsd6zOinter process signals not reliable (do not mix well with threading) on freebsd6c
+Cs�tj�\}}ttj|d���]}ttj|d���<}tj�}|dkr�z�y`|j�t|��Dy|j�Wntjt	j
�|�YnXtjd|�WdQXWntd�t	j�YnXWdt
�Xn|j�tj|ggg|j�\}}}||krVtj|�}	|	r}|j|	�q}n'tj|tj�|jd|j�WdQXWdQXdS)N�rb�wbrzUh oh, raised from pickle.z!Test deadlocked after %d seconds.)r�piper�fdopen�fork�closerE�pickle�dumpr$rC�print�	print_excr�select�MAX_DURATION�loadr?r/r1�SIGKILL)
rZ	os_done_rZ	os_done_wZdone_rZdone_wr.�r�w�x�tbr
r
r�	test_main�s4	



'	z!InterProcessSignalTests.test_main)rrr	rRrr r'r*r,r-rE�unittest�skipIf�sys�platformrYr
r
r
rr*s
=rc@s@eZdZdd�Zdd�Zdd�Zdd�Zd	S)
�
PosixTestscGsdS)Nr
)rrr
r
r�trivial_signal_handler�sz!PosixTests.trivial_signal_handlercCs6|jttjd�|jttjd|j�dS)Ni�)�assertRaises�
ValueErrorr1�	getsignalr_)rr
r
r�,test_out_of_range_signal_number_raises_error�sz7PosixTests.test_out_of_range_signal_number_raises_errorcCs |jttjtjd�dS)N)r`�	TypeErrorr1r3)rr
r
r�0test_setting_signal_handler_to_none_raises_error�sz;PosixTests.test_setting_signal_handler_to_none_raises_errorcCsjtjtj|j�}|jtjtj�|j�tjtj|�|jtjtj�|�dS)N)r1r2r_�assertEqualrb)rZhupr
r
r�test_getsignal�s

zPosixTests.test_getsignalN)rrr	r_rcrergr
r
r
rr^�sr^zWindows specificc@seZdZdd�ZdS)�WindowsSignalTestscCs�dd�}t�}xytjtjtjtjtjtjtjfD]G}tj	|�dk	rFtj|tj||��|j
|�qFqFW|j|�|jt
��tjd|�WdQX|jt
��tjd|�WdQXdS)NcSsdS)Nr
)rW�yr
r
r�<lambda>�sz3WindowsSignalTests.test_issue9324.<locals>.<lambda>r0����)�setr1�SIGABRTZSIGBREAK�SIGFPE�SIGILL�SIGINT�SIGSEGV�SIGTERMrb�addr=r`ra)rZhandlerZcheckedZsigr
r
r�test_issue9324�s	
z!WindowsSignalTests.test_issue9324N)rrr	rur
r
r
rrh�srhc@seZdZdd�ZdS)�
WakeupFDTestscCs&tj�}|jttj|�dS)N)rZmake_bad_fdr`rar1�
set_wakeup_fd)r�fdr
r
r�test_invalid_fd�szWakeupFDTests.test_invalid_fdN)rrr	ryr
r
r
rrv�srvc@syeZdZdddd�Zdd�Zdd�Zd	d
�Zdd�Zej	e
ed
�d�dd��ZdS)�WakeupSignalTests�orderedTcGs&dj|||�}td|�dS)Na�if 1:
        import fcntl
        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()
        for fd in (read, write):
            flags = fcntl.fcntl(fd, fcntl.F_GETFL, 0)
            flags = flags | os.O_NONBLOCK
            fcntl.fcntl(fd, fcntl.F_SETFL, flags)
        signal.set_wakeup_fd(write)

        test()
        check_signum(signals)

        os.close(read)
        os.close(write)
        z-c)�formatr)rZ	test_bodyr{Zsignals�coder
r
r�check_wakeup�s%zWakeupSignalTests.check_wakeupcCs�d}tj�\}}z:ytj|d�Wntk
rCYnX|jd�Wdtj|�tj|�Xtd|�dS)Naeif 1:
        import errno
        import fcntl
        import os
        import signal
        import sys
        import time
        from test.support import captured_stderr

        def handler(signum, frame):
            1/0

        signal.signal(signal.SIGALRM, handler)
        r, w = os.pipe()
        flags = fcntl.fcntl(r, fcntl.F_GETFL, 0)
        fcntl.fcntl(r, fcntl.F_SETFL, flags | os.O_NONBLOCK)

        # Set wakeup_fd a read-only file descriptor to trigger the error
        signal.set_wakeup_fd(r)
        try:
            with captured_stderr() as err:
                signal.alarm(1)
                time.sleep(5.0)
        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")
        �xz9OS doesn't report write() error on the read end of a pipez-c)rrI�writer�skipTestrLr)rr}rUrVr
r
r�test_wakeup_write_errors%

z)WakeupSignalTests.test_wakeup_write_errorcCs|jdtj�dS)Na�def test():
            import select
            import time

            TIMEOUT_FULL = 10
            TIMEOUT_HALF = 5

            signal.alarm(1)
            before_time = time.time()
            # We attempt to get a signal during the sleep,
            # before select is called
            time.sleep(TIMEOUT_FULL)
            mid_time = time.time()
            dt = mid_time - before_time
            if dt >= TIMEOUT_HALF:
                raise Exception("%s >= %s" % (dt, TIMEOUT_HALF))
            select.select([read], [], [], TIMEOUT_FULL)
            after_time = time.time()
            dt = after_time - mid_time
            if dt >= TIMEOUT_HALF:
                raise Exception("%s >= %s" % (dt, TIMEOUT_HALF))
        )r~r1r6)rr
r
r�test_wakeup_fd_earlyIsz&WakeupSignalTests.test_wakeup_fd_earlycCs|jdtj�dS)Na~def test():
            import select
            import time

            TIMEOUT_FULL = 10
            TIMEOUT_HALF = 5

            signal.alarm(1)
            before_time = time.time()
            # We attempt to get a signal during the select call
            try:
                select.select([read], [], [], TIMEOUT_FULL)
            except OSError:
                pass
            else:
                raise Exception("OSError not raised")
            after_time = time.time()
            dt = after_time - before_time
            if dt >= TIMEOUT_HALF:
                raise Exception("%s >= %s" % (dt, TIMEOUT_HALF))
        )r~r1r6)rr
r
r�test_wakeup_fd_duringasz'WakeupSignalTests.test_wakeup_fd_duringcCs|jdtjtj�dS)Nz�def test():
            signal.signal(signal.SIGUSR1, handler)
            os.kill(os.getpid(), signal.SIGUSR1)
            os.kill(os.getpid(), signal.SIGALRM)
        )r~r1r3r6)rr
r
r�test_signumxszWakeupSignalTests.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))
            os.kill(os.getpid(), signum1)
            os.kill(os.getpid(), signum2)
            # Unblocking the 2 signals calls the C signal handler twice
            signal.pthread_sigmask(signal.SIG_UNBLOCK, (signum1, signum2))
        r{F)r~r1r3r4)rr
r
r�test_pendingszWakeupSignalTests.test_pendingN)
rrr	r~r�r�r�r�rZ�
skipUnless�hasattrr1r�r
r
r
rrz�s)3rzc@s@eZdZdd�Zdd�Zdd�Zdd�Zd	S)
�SiginterruptTestcCs�d|f}td|���}y+|jj�}|jdd�\}}Wn#tjk
ro|j�dSYnFX||}|j�}|d
kr�td||f��n|dkSWd	QXd	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):
                pass

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

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

            # run the test twice
            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 OSError as err:
                    if err.errno != errno.EINTR:
                        raise
                else:
                    sys.exit(2)
            sys.exit(3)
        z-cZtimeoutg@F��zChild error (exit code %s): %rN)r�r�)	r�stdout�readline�communicater9ZTimeoutExpiredr/r-�	Exception)rZ	interruptr}�processZ
first_liner��stderr�exitcoder
r
r�readpipe_interrupted�s'

	
z%SiginterruptTest.readpipe_interruptedcCs |jd�}|j|�dS)N)r�r=)r�interruptedr
r
r�test_without_siginterrupt�sz*SiginterruptTest.test_without_siginterruptcCs |jd�}|j|�dS)NT)r�r=)rr�r
r
r�test_siginterrupt_on�sz%SiginterruptTest.test_siginterrupt_oncCs |jd�}|j|�dS)NF)r�r>)rr�r
r
r�test_siginterrupt_off�sz&SiginterruptTest.test_siginterrupt_offN)rrr	r�r�r�r�r
r
r
rr��s9r�c@s�eZdZdd�Zdd�Zdd�Zdd�Zd	d
�Zdd�Zd
d�Z	e
jej
dkd�dd��Ze
jej
dkd�dd��ZdS)�
ItimerTestcCs:d|_d|_d|_tjtj|j�|_dS)NFr)�hndl_called�
hndl_count�itimerr1r6�sig_alrm�	old_alarm)rr
r
rr�s			zItimerTest.setUpcCs?tjtj|j�|jdk	r;tj|jd�ndS)Nr)r1r6r�r��	setitimer)rr
r
rr �szItimerTest.tearDowncGs
d|_dS)NT)r�)rrr
r
rr��szItimerTest.sig_alrmcGsbd|_|jdkr*tjd��n%|jdkrOtjtjd�n|jd7_dS)NTr�z.setitimer didn't disable ITIMER_VIRTUAL timer.rr0)r�r�r1�ItimerErrorr��ITIMER_VIRTUAL)rrr
r
r�
sig_vtalrm�s	zItimerTest.sig_vtalrmcGs d|_tjtjd�dS)NTr)r�r1r��ITIMER_PROF)rrr
r
r�sig_profs	zItimerTest.sig_profcCs |jtjtjdd�dS)Nr0rrl)r`r1r�r�)rr
r
r�test_itimer_excszItimerTest.test_itimer_exccCs@tj|_tj|jd�tj�|j|jd�dS)Ng�?T)r1�ITIMER_REALr�r�rArfr�)rr
r
r�test_itimer_reals
zItimerTest.test_itimer_realrF�netbsd5zDitimer not reliable (does not mix well with threading) on some BSDs.cCs�tj|_tjtj|j�tj|jdd�tj�}xUtj�|dkr�tddd�}tj|j�d
krGPqGqGW|j	d�|j
tj|j�d�|j
|jd	�dS)Ng333333�?g�������?gN@i90i2	i����z8timeout: likely cause: machine too slow or load too highT)r�r�)r�r�)r1r�r��	SIGVTALRMr�r�r<�pow�	getitimerr�rfr�)r�
start_time�_r
r
r�test_itimer_virtuals
zItimerTest.test_itimer_virtualzBitimer not reliable (does not mix well with threading) on freebsd6cCs�tj|_tjtj|j�tj|jdd�tj�}xUtj�|dkr�tddd�}tj|j�d	krGPqGqGW|j	d�|j
tj|j�d
�|j
|jd�dS)Ng�������?gN@i90i2	i����z8timeout: likely cause: machine too slow or load too highT)r�r�)r�r�)r1r�r��SIGPROFr�r�r<r�r�r�rfr�)rr�r�r
r
r�test_itimer_prof,s
zItimerTest.test_itimer_profN)zfreebsd6r�)rrr	rr r�r�r�r�r�rZr[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�ejejjd"�d#�d$d%���Zejeed�d�ejeed�d�ejed&kd'�d(d)����Zejeed�d�d*d+��Zejeed�d�d,d-��Zejejd.kd/�ejeed
�d�d0d1���Zd&S)2�PendingSignalsTestsz[
    Test pthread_sigmask(), pthread_kill(), sigpending() and sigwait()
    functions.
    �
sigpendingzneed signal.sigpending()cCs|jtj�t��dS)N)rfr1r�rm)rr
r
r�test_sigpending_emptyHsz)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()
            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)rr}r
r
r�test_sigpendingMsz#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)rr}r
r
r�test_pthread_killjs 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
        aTif 1:
        import signal
        import sys

        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)rZblocked�testr}r
r
r�wait_helper�s&zPendingSignalsTests.wait_helper�sigwaitzneed signal.sigwait()cCs|jtjd�dS)Nz�
        def test(signum):
            signal.alarm(1)
            received = signal.sigwait([signum])
            if received != signum:
                raise Exception('received %s, not %s' % (received, signum))
        )r�r1r6)rr
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�r1r6)rr
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�r1r6)rr
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�r1r6)rr
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�r1r6)rr
r
r�test_sigtimedwait_timeout�sz-PendingSignalsTests.test_sigtimedwait_timeoutcCs)tj}|jttj|gd�dS)Ng�?g�)r1r6r`rar�)rr)r
r
r�"test_sigtimedwait_negative_timeout�s	z6PendingSignalsTests.test_sigtimedwait_negative_timeout�aixz1signal.sigwaitinfo() cannot be interrupted on AIXcCs|jtjd�dS)Na�
        def test(signum):
            import errno

            hndl_called = True
            def alarm_handler(signum, frame):
                hndl_called = False

            signal.signal(signal.SIGALRM, alarm_handler)
            signal.alarm(1)
            try:
                signal.sigwaitinfo([signal.SIGUSR1])
            except OSError as e:
                if e.errno == errno.EINTR:
                    if not hndl_called:
                        raise Exception("SIGALRM handler not called")
                else:
                    raise Exception("Expected EINTR to be raised by sigwaitinfo")
            else:
                raise Exception("Expected EINTR to be raised by sigwaitinfo")
        )r�r1r3)rr
r
r�test_sigwaitinfo_interrupted�sz0PendingSignalsTests.test_sigwaitinfo_interruptedNztest 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)rr
r
r�test_sigwait_threads
z'PendingSignalsTests.test_sigwait_threadcCsb|jttj�|jttjd�|jttjddd�|jttjdg�dS)Nr0r�r�i�)r`rdr1r�r)rr
r
r�test_pthread_sigmask_arguments8sz2PendingSignalsTests.test_pthread_sigmask_argumentscCsd}td|�dS)Naif 1:
        import signal
        import os; import threading

        def handler(signum, frame):
            1/0

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

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

        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])
        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
        signal.pthread_sigmask(signal.SIG_BLOCK, [signum])
        kill(signum)

        # Check the new mask
        blocked = read_sigmask()
        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)rr}r
r
r�test_pthread_sigmask@sAz(PendingSignalsTests.test_pthread_sigmaskrFzpissue #12392: send a signal to the main thread doesn't work before the creation of the first thread on FreeBSD 6cCsed}td|��J}|j�\}}|j�}|dkr[td||f��nWdQXdS)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�r-r�)rr}r�r�r�r�r
r
r�test_pthread_kill_main_thread�sz1PendingSignalsTests.test_pthread_kill_main_thread)rrr	�__doc__rZr�r�r1r�r�r�r�r�r�r�r�r�r�r[r\r]�
startswithr��	threadingr�r�r�r�r
r
r
rr�CsP",


	*Cr�cCs8z&tjtttttttt	�Wdtj
�XdS)N)rZrun_unittestr^rrvrzr�r�rhr�Z
reap_childrenr
r
r
rrY�s	rY�__main__)'rZr�r�
contextlibrrrMrQr1Zstructr9r$r\rr<rZtest.script_helperrrr��ImportErrorr�rrrr[r]ZTestCaserr^r�rhrvrzr�r�r�rYrr
r
r
r�<module>sH0

	%�%%%�%Q%_�_