Your IP : 216.73.216.213

Current Path : /opt/alt/python34/lib64/python3.4/test/__pycache__/
Current File : //opt/alt/python34/lib64/python3.4/test/__pycache__/test_faulthandler.cpython-34.pyc
�
f f�T�@s@ddlmZddlZddlZddlZddlZddlZddlZddlZddl	m
Z
mZddlm
Z
ddlZddlZddlmZyddlZdZWnek
r�dZYnXdZd	d
d�Zedd
��ZGdd�dej�Zedkr<ej�ndS)�)�contextmanagerN)�support�
script_helper)�assert_python_ok)�dedentTFg�?�cCsV|}|d|7}|d|7}d|krFd|d|d|Sd|dSdS)Nz#  File "<string>", line %s in func
z&  File "<string>", line %s in <module>r�^�
�$�)Zlineno1Zlineno2�header�	min_count�regexrr�;/opt/alt/python34/lib64/python3.4/test/test_faulthandler.py�expected_tracebacksrccs*tj�}z	|VWdtj|�XdS)N)�tempfileZmktempr�unlink)�filenamerrr�temporary_filename s	rc@seZdZddd�Zddddd�Zejejj	d�d�d	d
��Z
dd�Zd
d�Zejejdkd�dd��Z
ejeed�d�dd��Zejeed�d�dd��Zdd�Zejejj	d�oed�ejeed�d �d!d"���Zd#d$�Zd%d&�Zd'd(�Zd)d*�Zd+d,�Zd-d.�Zd/d0�Zd1d2�Zd3d4�Zd5d6�Zd7d8�Zd9d:�Z ejed;�d<d=��Z!d>d?�Z"d@dA�Z#dBdC�Z$ejeedD�dE�dFdFdFdFdGdH��Z%dIdJ�Z&dKdL�Z'dMdN�Z(dOdP�Z)dQdR�Z*ejeedS�dT�dFdFdFdFdUdV��Z+dWdX�Z,dYdZ�Z-d[d\�Z.d]d^�Z/d_d`�Z0e1dadb��Z2dcdd�Z3dS)e�FaultHandlerTestsNc	Cs�t|�j�}tj��tjd|�}WdQX|j�\}}|j�}tj|�}|j	dd�}|r�|j
|d�t|d��}|j�}WdQX|j	dd�}nt
jdd|�}|j�|fS)	a{
        Run the specified code in Python (in a new child process) and read the
        output from the standard error or from a file (if filename is set).
        Return the output lines as a list.

        Strip the reference count from the standard error for Python debug
        build, and replace "Current thread 0x00007f8d8fbd9700" by "Current
        thread XXX".
        z-cN�ascii�backslashreplace��rbzCurrent thread 0x[0-9a-f]+zCurrent thread XXX)r�striprZSuppressCrashReportrZspawn_pythonZcommunicate�waitZstrip_python_stderr�decode�assertEqual�open�read�re�sub�
splitlines)	�self�coderZprocess�stdout�stderr�exitcode�output�fprrr�
get_output)s 

		zFaultHandlerTests.get_outputTc	Cs�|rd}nd}d}t|jd|d|dtj|���j�}|re|d|7}n|j||�\}	}
dj|	�}	|j|	|�|j|
d	�d
S)z�
        Check that the fault handler for fatal errors is enabled and check the
        traceback from the child process output.

        Raise an error if the output doesn't match the expected format.
        z+Current thread XXX (most recent call first)zStack (most recent call first)z�
            ^Fatal Python error: {name}

            {header}:
              File "<string>", line {lineno} in <module>
            �lineno�namer�|r	rN)	r�formatr �escaperr*�join�assertRegex�assertNotEqual)r#r$Zline_numberZ
name_regexr�all_threads�other_regexrrr(r'rrr�check_fatal_errorDs	z#FaultHandlerTests.check_fatal_error�aixz5the first page of memory is a mapped read-only on AIXcCs|jddd�dS)Nzu
            import faulthandler
            faulthandler.enable()
            faulthandler._read_null()
            �z4(?:Segmentation fault|Bus error|Illegal instruction))r5)r#rrr�test_read_nullasz FaultHandlerTests.test_read_nullcCs|jddd�dS)Nzs
            import faulthandler
            faulthandler.enable()
            faulthandler._sigsegv()
            r7zSegmentation fault)r5)r#rrr�test_sigsegvmszFaultHandlerTests.test_sigsegvcCs|jddd�dS)Nzs
            import faulthandler
            faulthandler.enable()
            faulthandler._sigabrt()
            r7ZAborted)r5)r#rrr�test_sigabrtvszFaultHandlerTests.test_sigabrt�win32z"SIGFPE cannot be caught on WindowscCs|jddd�dS)Nzr
            import faulthandler
            faulthandler.enable()
            faulthandler._sigfpe()
            r7zFloating point exception)r5)r#rrr�test_sigfpeszFaultHandlerTests.test_sigfpeZ_sigbuszneed faulthandler._sigbus()cCs|jddd�dS)Nzr
            import faulthandler
            faulthandler.enable()
            faulthandler._sigbus()
            r7z	Bus error)r5)r#rrr�test_sigbus�szFaultHandlerTests.test_sigbusZ_sigillzneed faulthandler._sigill()cCs|jddd�dS)Nzr
            import faulthandler
            faulthandler.enable()
            faulthandler._sigill()
            r7zIllegal instruction)r5)r#rrr�test_sigill�szFaultHandlerTests.test_sigillcCs|jddd�dS)Nz[
            import faulthandler
            faulthandler._fatal_error(b'xyz')
            �Zxyz)r5)r#rrr�test_fatal_error�sz"FaultHandlerTests.test_fatal_errorZopenbsdzVIssue #12868: sigaltstack() doesn't work on OpenBSD if Python is compiled with pthreadZ_stack_overflowz#need faulthandler._stack_overflow()cCs|jddddd�dS)Nzz
            import faulthandler
            faulthandler.enable()
            faulthandler._stack_overflow()
            r7z (?:Segmentation fault|Bus error)r4z unable to raise a stack overflow)r5)r#rrr�test_stack_overflow�s
z%FaultHandlerTests.test_stack_overflowcCs|jddd�dS)Nzw
            import faulthandler
            faulthandler.enable()
            faulthandler._sigsegv(True)
            r7zSegmentation fault)r5)r#rrr�test_gil_released�sz#FaultHandlerTests.test_gil_releasedc
CsAt��2}|jdjdt|��ddd|�WdQXdS)Nz�
                import faulthandler
                output = open({filename}, 'wb')
                faulthandler.enable(output)
                faulthandler._sigsegv()
                r�zSegmentation fault)rr5r.�repr)r#rrrr�test_enable_file�sz"FaultHandlerTests.test_enable_filecCs|jddddd�dS)Nz�
            import faulthandler
            faulthandler.enable(all_threads=False)
            faulthandler._sigsegv()
            r7zSegmentation faultr3F)r5)r#rrr�test_enable_single_thread�s
z+FaultHandlerTests.test_enable_single_threadcCsdd}d}|j|�\}}dj|�}|j||kd||f�|j|d�dS)Nz�
            import faulthandler
            faulthandler.enable()
            faulthandler.disable()
            faulthandler._sigsegv()
            zFatal Python errorr	z%r is present in %rr)r*r0�
assertTruer2)r#r$Znot_expectedr&r'rrr�test_disable�szFaultHandlerTests.test_disablecCs�tj}z{tjt_tj�}z>tj�|jtj��tj�|jtj��Wd|rxtj�n
tj�XWd|t_XdS)N)	�sysr&�
__stderr__�faulthandlerZ
is_enabled�enablerG�disableZassertFalse)r#Zorig_stderrZwas_enabledrrr�test_is_enabled�s	


z!FaultHandlerTests.test_is_enabledcCs�d}tdtjtjjr$dndd|f�}tjj�}|jdd�t	j
|d|�}|j|j�d�dS)Nz5import faulthandler; print(faulthandler.is_enabled())z-Erz-c�PYTHONFAULTHANDLER�envsFalse)
�filterrI�
executable�flags�ignore_environment�os�environ�copy�pop�
subprocess�check_outputr�rstrip)r#r$�argsrPr(rrr�test_disabled_by_default�sz*FaultHandlerTests.test_disabled_by_defaultcCs�d}tdtjtjjr$dndddd|f�}tjj�}|jdd�t	j
|d|�}|j|j�d	�dS)
Nz5import faulthandler; print(faulthandler.is_enabled())z-Erz-XrKz-crOrPsTrue)
rQrIrRrSrTrUrVrWrXrYrZrr[)r#r$r\rPr(rrr�test_sys_xoptionssz#FaultHandlerTests.test_sys_xoptionscCs�d}tjd|f}tjj�}d|d<tj|d|�}|j|j�d�tjj�}d|d<tj|d|�}|j|j�d�dS)	Nz5import faulthandler; print(faulthandler.is_enabled())z-crrOrPsFalse�1sTrue)	rIrRrUrVrWrYrZrr[)r#r$r\rPr(rrr�test_env_vars

zFaultHandlerTests.test_env_varcCs�d}|jdt|�dt|��}|r9d}nd}dd|dd	g}|j||�\}}|j||�|j|d
�dS)z�
        Explicitly call dump_traceback() function and check its output.
        Raise an error if the output doesn't match the expected format.
        a�
            import faulthandler

            def funcB():
                if {has_filename}:
                    with open({filename}, "wb") as fp:
                        faulthandler.dump_traceback(fp, all_threads=False)
                else:
                    faulthandler.dump_traceback(all_threads=False)

            def funcA():
                funcB()

            funcA()
            r�has_filename��zStack (most recent call first):z#  File "<string>", line %s in funcBz#  File "<string>", line 11 in funcAz&  File "<string>", line 13 in <module>rN)r.rD�boolr*r)r#rr$r+�expected�tracer'rrr�check_dump_traceback"s			z&FaultHandlerTests.check_dump_tracebackcCs|jd�dS)N)rg)r#rrr�test_dump_tracebackHsz%FaultHandlerTests.test_dump_tracebackc	Cs#t��}|j|�WdQXdS)N)rrg)r#rrrr�test_dump_traceback_fileKsz*FaultHandlerTests.test_dump_traceback_filecCs�d}d|d}d|d}d}|jd|�}dd|d	g}|j|�\}}|j||�|j|d
�dS)Ni��x�2z...z�
            import faulthandler

            def {func_name}():
                faulthandler.dump_traceback(all_threads=False)

            {func_name}()
            �	func_namezStack (most recent call first):z  File "<string>", line 4 in %sz%  File "<string>", line 6 in <module>r)r.r*r)r#�maxlenrlZ	truncatedr$rerfr'rrr�
test_truncateOs			zFaultHandlerTests.test_truncatezneed threadscCs�d}|jdt|��}|j||�\}}dj|�}|rTd}nd}d}t|jd|��j�}|j||�|j|d�d	S)
z�
        Call explicitly dump_traceback(all_threads=True) and check the output.
        Raise an error if the output doesn't match the expected format.
        a�
            import faulthandler
            from threading import Thread, Event
            import time

            def dump():
                if {filename}:
                    with open({filename}, "wb") as fp:
                        faulthandler.dump_traceback(fp, all_threads=True)
                else:
                    faulthandler.dump_traceback(all_threads=True)

            class Waiter(Thread):
                # avoid blocking if the main thread raises an exception.
                daemon = True

                def __init__(self):
                    Thread.__init__(self)
                    self.running = Event()
                    self.stop = Event()

                def run(self):
                    self.running.set()
                    self.stop.wait()

            waiter = Waiter()
            waiter.start()
            waiter.running.wait()
            dump()
            waiter.stop.set()
            waiter.join()
            rr	rc�
a�
            ^Thread 0x[0-9a-f]+ \(most recent call first\):
            (?:  File ".*threading.py", line [0-9]+ in [_a-z]+
            ){{1,3}}  File "<string>", line 23 in run
              File ".*threading.py", line [0-9]+ in _bootstrap_inner
              File ".*threading.py", line [0-9]+ in _bootstrap

            Current thread XXX \(most recent call first\):
              File "<string>", line {lineno} in dump
              File "<string>", line 28 in <module>$
            r+rN)r.rDr*r0rrr1r)r#rr$r(r'r+rrrr�check_dump_traceback_threadsgs%	z.FaultHandlerTests.check_dump_traceback_threadscCs|jd�dS)N)rp)r#rrr�test_dump_traceback_threads�sz-FaultHandlerTests.test_dump_traceback_threadsc	Cs#t��}|j|�WdQXdS)N)rrp)r#rrrr� test_dump_traceback_threads_file�sz2FaultHandlerTests.test_dump_traceback_threads_filecCs�ttjdt��}d}|jdtd|d|d|dt|�dt|��}|j||�\}}d	j|�}|s�|}	|r�|	d
9}	nd|}
t	dd
|
d|	�}|j
||�n|j|d�|j|d�dS)a
        Check how many times the traceback is written in timeout x 2.5 seconds,
        or timeout x 3.5 seconds if cancel is True: 1, 2 or 3 times depending
        on repeat and cancel options.

        Raise an error if the output doesn't match the expect format.
        Zsecondsa;
            import faulthandler
            import time

            def func(timeout, repeat, cancel, file, loops):
                for loop in range(loops):
                    faulthandler.dump_traceback_later(timeout, repeat=repeat, file=file)
                    if cancel:
                        faulthandler.cancel_dump_traceback_later()
                    time.sleep(timeout * 5)
                    faulthandler.cancel_dump_traceback_later()

            timeout = {timeout}
            repeat = {repeat}
            cancel = {cancel}
            loops = {loops}
            if {has_filename}:
                file = open({filename}, "wb")
            else:
                file = None
            func(timeout, repeat, cancel, file, loops)
            if file is not None:
                file.close()
            Ztimeout�repeat�cancel�loopsrarr	r?zATimeout \(%s\)!\nThread 0x[0-9a-f]+ \(most recent call first\):\n�	�r
rrN)�str�datetimeZ	timedelta�TIMEOUTr.rdrDr*r0rr1r)r#rsrtrruZtimeout_strr$rfr'�countrrrrr�_check_dump_traceback_later�s(	
z-FaultHandlerTests._check_dump_traceback_later�dump_traceback_laterz(need faulthandler.dump_traceback_later()FcCs`|rd}nd}|rFt��}|j||||�WdQXn|j||d|�dS)Nr?r)rr|)r#rsrt�file�twicerurrrr�check_dump_traceback_later�s	z,FaultHandlerTests.check_dump_traceback_latercCs|j�dS)N)r�)r#rrr�test_dump_traceback_later�sz+FaultHandlerTests.test_dump_traceback_latercCs|jdd�dS)NrsT)r�)r#rrr� test_dump_traceback_later_repeat�sz2FaultHandlerTests.test_dump_traceback_later_repeatcCs|jdd�dS)NrtT)r�)r#rrr� test_dump_traceback_later_cancel�sz2FaultHandlerTests.test_dump_traceback_later_cancelcCs|jdd�dS)Nr~T)r�)r#rrr�test_dump_traceback_later_file�sz0FaultHandlerTests.test_dump_traceback_later_filecCs|jdd�dS)NrT)r�)r#rrr�test_dump_traceback_later_twice�sz1FaultHandlerTests.test_dump_traceback_later_twice�registerzneed faulthandler.registerc

Cs�tj}d}|jdt|�dt|�d|d|d|d|�}|j||�\}}dj|�}|s�|r�d	}	nd
}	tdd|	�}	|j||	�n|j	|d
�|r�|j
|d�n|j	|d�dS)a
        Register a handler displaying the traceback on a user signal. Raise the
        signal and check the written traceback.

        If chain is True, check that the previous signal handler is called.

        Raise an error if the output doesn't match the expected format.
        a�
            import faulthandler
            import os
            import signal
            import sys

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

            def handler(signum, frame):
                handler.called = True
            handler.called = False

            exitcode = 0
            signum = {signum}
            unregister = {unregister}
            chain = {chain}

            if {has_filename}:
                file = open({filename}, "wb")
            else:
                file = None
            if chain:
                signal.signal(signum, handler)
            faulthandler.register(signum, file=file,
                                  all_threads={all_threads}, chain={chain})
            if unregister:
                faulthandler.unregister(signum)
            func(signum)
            if chain and not handler.called:
                if file is not None:
                    output = file
                else:
                    output = sys.stderr
                print("Error: signal handler not called!", file=output)
                exitcode = 1
            if file is not None:
                file.close()
            sys.exit(exitcode)
            rrar3�signum�
unregister�chainr	z/Current thread XXX \(most recent call first\):
z"Stack \(most recent call first\):
��rrN)�signal�SIGUSR1r.rDrdr*r0rr1rr2)
r#rr3r�r�r�r$rfr'rrrr�check_register�s*	(			z FaultHandlerTests.check_registercCs|j�dS)N)r�)r#rrr�
test_registerLszFaultHandlerTests.test_registercCs|jdd�dS)Nr�T)r�)r#rrr�test_unregisterOsz!FaultHandlerTests.test_unregisterc
Cs&t��}|jd|�WdQXdS)Nr)rr�)r#rrrr�test_register_fileRsz$FaultHandlerTests.test_register_filecCs|jdd�dS)Nr3T)r�)r#rrr�test_register_threadsVsz'FaultHandlerTests.test_register_threadscCs|jdd�dS)Nr�T)r�)r#rrr�test_register_chainYsz%FaultHandlerTests.test_register_chainccs]tj}zCdt_|jt��}dVWdQX|jt|j�d�Wd|t_XdS)Nzsys.stderr is None)rIr&ZassertRaises�RuntimeErrorrrxZ	exception)r#r&�cmrrr�check_stderr_none\s		z#FaultHandlerTests.check_stderr_nonecCs�|j��tj�WdQX|j��tj�WdQXttd�rl|j��tjd�WdQXnttd�r�|j��tjtj�WdQXndS)Nr}g����MbP?r�)	r�rKrLZdump_traceback�hasattrr}r�r�r�)r#rrr�test_stderr_Nonegs



z"FaultHandlerTests.test_stderr_None)4�__name__�
__module__�__qualname__r*r5�unittestZskipIfrI�platform�
startswithr8r9r:r<r�rKr=r>r@�HAVE_THREADSrArBrErFrHrNr]r^r`rgrhrirnrprqrrr|r�r�r�r�r�r�r�r�r�r�r�r�rr�r�rrrrr(sj		


	
&<7Jr�__main__)�
contextlibrryrKrUr r�rYrIZtestrrZtest.script_helperrrr��textwraprZ	threadingr��ImportErrorrzrrZTestCaserr��mainrrrr�<module>s2

	��P