Your IP : 216.73.216.52

Current Path : /opt/alt/python36/lib64/python3.6/test/__pycache__/
Current File : //opt/alt/python36/lib64/python3.6/test/__pycache__/test_faulthandler.cpython-36.opt-2.pyc
3

��2aXn�@s$ddlmZddlZddlZddlZddlZddlZddlZddlZddl	m
Z
ddlmZm
Z
mZddlZddlZddlmZyddlZdZWnek
r�dZYnXyddlZWnek
r�dZYnXdZejd	kZddd�Zed
d��Zdd�ZGdd�dej�Zedk�r ej �dS)�)�contextmanagerN)�support)�
script_helper�
is_android�requires_android_level)�dedentTFg�?�nt�cCsL|}|d|7}|d|7}d|kr<d|d|d|Sd|dSdS)Nz#  File "<string>", line %s in func
z&  File "<string>", line %s in <module>r	�^�
�$�)Zlineno1Zlineno2�header�	min_count�regexr
r
�6/opt/alt/python36/lib64/python3.6/test_faulthandler.py�expected_tracebacksrccs$tj�}z
|VWdtj|�XdS)N)�tempfileZmktempr�unlink)�filenamer
r
r�temporary_filename%s
rcCsts|Stdd�|�S)N�zraise() is buggy)rr)�testr
r
r�requires_raise-src@s@eZdZd�dd�Zdddddd�dd�Zdd	�Zd
d�Zeje	j
jd�d
�dd��Ze
dd��Zejed�dd��Zdd�Zeje	j
dkd�dd��Zejedkd�ejeed�d�e
dd����Zejedkd�ejeed �d!�e
d"d#����Zd$d%�Zd&d'�Zeje	j
jd(��oed)�ejeed*�d+�d,d-���Ze
d.d/��Ze
d0d1��Zeje	j
dkd2�e
d3d4���Ze
d5d6��Z e
d7d8��Z!d9d:�Z"d;d<�Z#d=d>�Z$d?d@�Z%dddA�dBdC�Z&dDdE�Z'dFdG�Z(eje	j
dkd2�dHdI��Z)dJdK�Z*ejed�dLdM��Z+dNdO�Z,dPdQ�Z-ejeedR�dS�d�dddA�dVdW��Z.dXdY�Z/dZd[�Z0d\d]�Z1d^d_�Z2eje	j
dkd2�d`da��Z3dbdc�Z4ejeedd�de�d�dfdg��Z5dhdi�Z6djdk�Z7dldm�Z8eje	j
dkd2�dndo��Z9dpdq�Z:drds�Z;e<dtdu��Z=dvdw�Z>eje?dx�dydz��Z@eje?dx�d{d|��ZAeje?dx�d}d~��ZBeje?dx�dd���ZCdS)��FaultHandlerTestsNcCst|�j�}g}|dk	r"|j|�tj��:tjd||d�}|�|j�\}}|j�}WdQRXWdQRXtj	|�}	|	j
dd�}	|r�|j|	d�t|d��}
|
j
�}	WdQRX|	j
dd�}	nT|dk	�r|j|	d�tj|tjd�t|ddd	��}
|
j
�}	WdQRX|	j
dd�}	|	j�|fS)
Nz-c)�pass_fds�ascii�backslashreplace��rbrF)�closefd)r�strip�appendrZSuppressCrashReportrZspawn_pythonZcommunicate�waitZstrip_python_stderr�decode�assertEqual�open�read�os�lseek�SEEK_SET�
splitlines)�self�coder�fdrZprocess�stdout�stderr�exitcode�output�fpr
r
r�
get_output2s.




zFaultHandlerTests.get_outputT)r�all_threads�other_regexr.�know_current_threadc
Cs~|r|rd}	qd}	nd}	d}
t|
j|||	d��j�}
|rD|
d|7}
|j|||d�\}}dj|�}|j||
�|j|d	�dS)
NzCurrent thread 0x[0-9a-f]+zThread 0x[0-9a-f]+ZStackz�
            ^{fatal_error}

            {header} \(most recent call first\):
              File "<string>", line {lineno} in <module>
            )�lineno�fatal_errorr�|)rr.rr)r�formatr!r4�join�assertRegex�assertNotEqual)
r,r-�line_numberr9rr5r6r.r7rrr2r1r
r
r�check_errorTs 	
zFaultHandlerTests.check_errorcKsd|}|j|||f|�dS)NzFatal Python error: %s)r@)r,r-r?�
name_regex�kwr9r
r
r�check_fatal_errorusz#FaultHandlerTests.check_fatal_errorcKsd|}|j|||f|�dS)NzWindows fatal exception: %s)r@)r,r-r?rArBr9r
r
r�check_windows_exceptionysz)FaultHandlerTests.check_windows_exception�aixz5the first page of memory is a mapped read-only on AIXcCs&ts|jddd�n|jddd�dS)Nz�
                import faulthandler
                faulthandler.enable()
                faulthandler._read_null()
                �z4(?:Segmentation fault|Bus error|Illegal instruction)zaccess violation)�
MS_WINDOWSrCrD)r,r
r
r�test_read_null}sz FaultHandlerTests.test_read_nullcCs|jddd�dS)Nzs
            import faulthandler
            faulthandler.enable()
            faulthandler._sigsegv()
            rFzSegmentation fault)rC)r,r
r
r�test_sigsegv�szFaultHandlerTests.test_sigsegvzneed threadscCs|jddddd�dS)Nz�
            import faulthandler
            faulthandler.enable()
            faulthandler._fatal_error_c_thread()
            rFz
in new threadF)r7)rC)r,r
r
r�test_fatal_error_c_thread�s
z+FaultHandlerTests.test_fatal_error_c_threadcCs|jddd�dS)Nzs
            import faulthandler
            faulthandler.enable()
            faulthandler._sigabrt()
            rFZAborted)rC)r,r
r
r�test_sigabrt�szFaultHandlerTests.test_sigabrt�win32z"SIGFPE cannot be caught on WindowscCs|jddd�dS)Nzr
            import faulthandler
            faulthandler.enable()
            faulthandler._sigfpe()
            rFzFloating point exception)rC)r,r
r
r�test_sigfpe�szFaultHandlerTests.test_sigfpezneed _testcapi�SIGBUSzneed signal.SIGBUScCs|jddd�dS)Nz�
            import _testcapi
            import faulthandler
            import signal

            faulthandler.enable()
            _testcapi.raise_signal(signal.SIGBUS)
            �z	Bus error)rC)r,r
r
r�test_sigbus�szFaultHandlerTests.test_sigbus�SIGILLzneed signal.SIGILLcCs|jddd�dS)Nz�
            import _testcapi
            import faulthandler
            import signal

            faulthandler.enable()
            _testcapi.raise_signal(signal.SIGILL)
            rOzIllegal instruction)rC)r,r
r
r�test_sigill�szFaultHandlerTests.test_sigillcCs|jddd�dS)Nz[
            import faulthandler
            faulthandler._fatal_error(b'xyz')
            ��xyz)rC)r,r
r
r�test_fatal_error�sz"FaultHandlerTests.test_fatal_errorcCs|jddd�dS)Nza
            import faulthandler
            faulthandler._fatal_error(b'xyz', True)
            rSrT)rC)r,r
r
r�test_fatal_error_without_gil�sz.FaultHandlerTests.test_fatal_error_without_gilZopenbsdzVIssue #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()
            rFz (?:Segmentation fault|Bus error)z unable to raise a stack overflow)r6)rC)r,r
r
r�test_stack_overflow�s
z%FaultHandlerTests.test_stack_overflowcCs|jddd�dS)Nzw
            import faulthandler
            faulthandler.enable()
            faulthandler._sigsegv(True)
            rFzSegmentation fault)rC)r,r
r
r�test_gil_released�sz#FaultHandlerTests.test_gil_releasedc
Cs4t��$}|jdjt|�d�dd|d�WdQRXdS)Nz�
                import faulthandler
                output = open({filename}, 'wb')
                faulthandler.enable(output)
                faulthandler._sigsegv()
                )r�zSegmentation fault)rrCr;�repr)r,rr
r
r�test_enable_filesz"FaultHandlerTests.test_enable_filez.subprocess doesn't support pass_fds on Windowsc
Cs8tjd��$}|j�}|jd|dd|d�WdQRXdS)Nzwb+z�
                import faulthandler
                import sys
                faulthandler.enable(%s)
                faulthandler._sigsegv()
                rYzSegmentation fault)r.)r�
TemporaryFile�filenorC)r,r3r.r
r
r�test_enable_fdsz FaultHandlerTests.test_enable_fdcCs|jddddd�dS)Nz�
            import faulthandler
            faulthandler.enable(all_threads=False)
            faulthandler._sigsegv()
            rFzSegmentation faultF)r5)rC)r,r
r
r�test_enable_single_thread!s
z+FaultHandlerTests.test_enable_single_threadcCsHd}d}|j|�\}}dj|�}|j||kd||f�|j|d�dS)Nz�
            import faulthandler
            faulthandler.enable()
            faulthandler.disable()
            faulthandler._sigsegv()
            zFatal Python errorrz%r is present in %rr)r4r<�
assertTruer>)r,r-Znot_expectedr0r1r
r
r�test_disable,s

zFaultHandlerTests.test_disablecCsrtj}z^tjt_tj�}z0tj�|jtj��tj�|jtj��Wd|rXtj�ntj�XWd|t_XdS)N)	�sysr0�
__stderr__�faulthandlerZ
is_enabled�enabler`�disableZassertFalse)r,Zorig_stderrZwas_enabledr
r
r�test_is_enabled;s
z!FaultHandlerTests.test_is_enabledcCs\d}tdtjtjjrdndd|f�}tjj�}|jdd�t	j
||d�}|j|j�d�dS)Nz5import faulthandler; print(faulthandler.is_enabled())z-Erz-c�PYTHONFAULTHANDLER)�envsFalse)
�filterrb�
executable�flags�ignore_environmentr(�environ�copy�pop�
subprocess�check_outputr%�rstrip)r,r-�argsrir2r
r
r�test_disabled_by_defaultQs

z*FaultHandlerTests.test_disabled_by_defaultcCs`d}tdtjtjjrdndddd|f�}tjj�}|jdd�t	j
||d�}|j|j�d	�dS)
Nz5import faulthandler; print(faulthandler.is_enabled())z-Erz-Xrdz-crh)risTrue)
rjrbrkrlrmr(rnrorprqrrr%rs)r,r-rtrir2r
r
r�test_sys_xoptions]s
z#FaultHandlerTests.test_sys_xoptionscCstd}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-crrh)risFalse�1sTrue)	rbrkr(rnrorqrrr%rs)r,r-rtrir2r
r
r�test_env_varis

zFaultHandlerTests.test_env_var)rr.cCsld}|j||d�}|rd}n|dk	r*d}nd}dd|dd	g}|j|||�\}}|j||�|j|d
�dS)Na[
            import faulthandler

            filename = {filename!r}
            fd = {fd}

            def funcB():
                if filename:
                    with open(filename, "wb") as fp:
                        faulthandler.dump_traceback(fp, all_threads=False)
                elif fd is not None:
                    faulthandler.dump_traceback(fd,
                                                all_threads=False)
                else:
                    faulthandler.dump_traceback(all_threads=False)

            def funcA():
                funcB()

            funcA()
            )rr.�	��zStack (most recent call first):z#  File "<string>", line %s in funcBz#  File "<string>", line 17 in funcAz&  File "<string>", line 19 in <module>r)r;r4r%)r,rr.r-r8�expected�tracer1r
r
r�check_dump_tracebackys z&FaultHandlerTests.check_dump_tracebackcCs|j�dS)N)r~)r,r
r
r�test_dump_traceback�sz%FaultHandlerTests.test_dump_tracebackc
Cs"t��}|j|d�WdQRXdS)N)r)rr~)r,rr
r
r�test_dump_traceback_file�sz*FaultHandlerTests.test_dump_traceback_filec
Cs*tjd��}|j|j�d�WdQRXdS)Nzwb+)r.)rr\r~r])r,r3r
r
r�test_dump_traceback_fd�sz(FaultHandlerTests.test_dump_traceback_fdcCsdd}d|d}d|d}d}|j|d�}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;r4r%)r,�maxlenr�Z	truncatedr-r|r}r1r
r
r�
test_truncate�szFaultHandlerTests.test_truncatecCspd}|jt|�d�}|j||�\}}dj|�}|r8d}nd}d}t|j|d��j�}|j||�|j|d�dS)	Na�
            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��
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 0x[0-9a-f]+ \(most recent call first\):
              File "<string>", line {lineno} in dump
              File "<string>", line 28 in <module>$
            )r8r)r;rZr4r<rr!r=r%)r,rr-r2r1r8rr
r
r�check_dump_traceback_threads�s%
z.FaultHandlerTests.check_dump_traceback_threadscCs|jd�dS)N)r�)r,r
r
r�test_dump_traceback_threadssz-FaultHandlerTests.test_dump_traceback_threadsc	Cs t��}|j|�WdQRXdS)N)rr�)r,rr
r
r� test_dump_traceback_threads_filesz2FaultHandlerTests.test_dump_traceback_threads_file�dump_traceback_laterz(need faulthandler.dump_traceback_later()Fr	c
Cs�ttjtd��}d}|jt|||||d�}|j||�\}}	dj|�}|s~|}
|rX|
d9}
d|}tdd||
d	�}|j||�n|j	|d
�|j	|	d�dS)N)Zsecondsa�
            import faulthandler
            import time
            import sys

            timeout = {timeout}
            repeat = {repeat}
            cancel = {cancel}
            loops = {loops}
            filename = {filename!r}
            fd = {fd}

            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()

            if filename:
                file = open(filename, "wb")
            elif fd is not None:
                file = sys.stderr.fileno()
            else:
                file = None
            func(timeout, repeat, cancel, file, loops)
            if filename:
                file.close()
            )Ztimeout�repeat�cancel�loopsrr.rrSzATimeout \(%s\)!\nThread 0x[0-9a-f]+ \(most recent call first\):\n��)rrr)
�str�datetimeZ	timedelta�TIMEOUTr;r4r<rr=r%)
r,r�r�r�rr.Ztimeout_strr-r}r1�countrrr
r
r�check_dump_traceback_laters(
z,FaultHandlerTests.check_dump_traceback_latercCs|j�dS)N)r�)r,r
r
r�test_dump_traceback_laterOsz+FaultHandlerTests.test_dump_traceback_latercCs|jdd�dS)NT)r�)r�)r,r
r
r� test_dump_traceback_later_repeatRsz2FaultHandlerTests.test_dump_traceback_later_repeatcCs|jdd�dS)NT)r�)r�)r,r
r
r� test_dump_traceback_later_cancelUsz2FaultHandlerTests.test_dump_traceback_later_cancelc
Cs"t��}|j|d�WdQRXdS)N)r)rr�)r,rr
r
r�test_dump_traceback_later_fileXsz0FaultHandlerTests.test_dump_traceback_later_filec
Cs*tjd��}|j|j�d�WdQRXdS)Nzwb+)r.)rr\r�r])r,r3r
r
r�test_dump_traceback_later_fd\sz.FaultHandlerTests.test_dump_traceback_later_fdcCs|jdd�dS)NrS)r�)r�)r,r
r
r�test_dump_traceback_later_twicebsz1FaultHandlerTests.test_dump_traceback_later_twice�registerzneed faulthandler.registercCs�tj}d}|j||||||d�}|j||�\}}	dj|�}|sf|rHd}
nd}
tdd|
�}
|j||
�n|j|d�|r�|j|	d	�n|j|	d	�dS)
Nax
            import faulthandler
            import os
            import signal
            import sys

            all_threads = {all_threads}
            signum = {signum}
            unregister = {unregister}
            chain = {chain}
            filename = {filename!r}
            fd = {fd}

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

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

            if filename:
                file = open(filename, "wb")
            elif fd is not None:
                file = sys.stderr.fileno()
            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
            else:
                exitcode = 0
            if filename:
                file.close()
            sys.exit(exitcode)
            )r5�signum�
unregister�chainrr.rz8Current thread 0x[0-9a-f]+ \(most recent call first\):\nz#Stack \(most recent call first\):\nr{� rr)	�signal�SIGUSR1r;r4r<rr=r%r>)r,rr5r�r�r.r�r-r}r1rr
r
r�check_registeres*.
z FaultHandlerTests.check_registercCs|j�dS)N)r�)r,r
r
r�
test_register�szFaultHandlerTests.test_registercCs|jdd�dS)NT)r�)r�)r,r
r
r�test_unregister�sz!FaultHandlerTests.test_unregisterc
Cs"t��}|j|d�WdQRXdS)N)r)rr�)r,rr
r
r�test_register_file�sz$FaultHandlerTests.test_register_filec
Cs*tjd��}|j|j�d�WdQRXdS)Nzwb+)r.)rr\r�r])r,r3r
r
r�test_register_fd�sz"FaultHandlerTests.test_register_fdcCs|jdd�dS)NT)r5)r�)r,r
r
r�test_register_threads�sz'FaultHandlerTests.test_register_threadscCs|jdd�dS)NT)r�)r�)r,r
r
r�test_register_chain�sz%FaultHandlerTests.test_register_chainccsLtj}z8dt_|jt��}dVWdQRX|jt|j�d�Wd|t_XdS)Nzsys.stderr is None)rbr0ZassertRaises�RuntimeErrorr%r�Z	exception)r,r0�cmr
r
r�check_stderr_none�sz#FaultHandlerTests.check_stderr_nonecCs�|j��tj�WdQRX|j��tj�WdQRXttd�r`|j��tjd�WdQRXttd�r�|j��tjtj�WdQRXdS)Nr�g����MbP?r�)	r�rdreZdump_traceback�hasattrr�r�r�r�)r,r
r
r�test_stderr_None�s





z"FaultHandlerTests.test_stderr_Nonezspecific to WindowscCs,x&d
D]\}}|jd|�d�d	|�qWdS)N�EXCEPTION_ACCESS_VIOLATION�access violation�EXCEPTION_INT_DIVIDE_BY_ZERO�int divide by zero�EXCEPTION_STACK_OVERFLOW�stack overflowz�
                import faulthandler
                faulthandler.enable()
                faulthandler._raise_exception(faulthandler._z)
                rF�r�r��r�r��r�r�)r�r�r�)rD)r,�exc�namer
r
r�test_raise_exception�s
z&FaultHandlerTests.test_raise_exceptioncCsLxFdD]>}d|�d�}t|�}|j|�\}}|j|g�|j||�qWdS)N�cs�@�RC�@z�
                    import faulthandler
                    faulthandler.enable()
                    faulthandler._raise_exception(z)
                    )r�r�)rr4r%)r,Zexc_coder-r2r1r
r
r�test_ignore_exception�sz'FaultHandlerTests.test_ignore_exceptioncCsJxDdD]<}|jd|d�d	��\}}|j|g�|j|||d@f�qWdS)
Nr�xV4�@�@�p��z{
                import faulthandler
                faulthandler.enable()
                faulthandler._raise_exception(0xr�z)
                i)rr�r�r�r�r�i����)r4r%ZassertIn)r,r�r2r1r
r
r�test_raise_nonfatal_exceptionsz/FaultHandlerTests.test_raise_nonfatal_exceptioncCs2td�}|j|�\}}|j|g�|j|d�dS)Nz�
            import faulthandler
            faulthandler.enable()
            faulthandler.disable()
            code = faulthandler._EXCEPTION_ACCESS_VIOLATION
            faulthandler._raise_exception(code)
        l)rr4r%)r,r-r2r1r
r
r� test_disable_windows_exc_handler"s
z2FaultHandlerTests.test_disable_windows_exc_handler)NN)FFr	)FFFFN)D�__name__�
__module__�__qualname__r4r@rCrD�unittestZskipIfrb�platform�
startswithrHrrI�HAVE_THREADSrJrKrM�	_testcapiZ
skipUnlessr�r�rPrRrUrVrdrWrXr[r^r_rargrurvrxr~rr�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�rr�r�rGr�r�r�r�r
r
r
rr1s�
#
	




.<=Pr�__main__)r	)!�
contextlibrr�rdr(�rer�rqrbrrZtest.supportrrrrr��textwraprZ	threadingr��ImportErrorr�r�r�rGrrrZTestCaserr��mainr
r
r
r�<module>sF