Your IP : 216.73.216.85

Current Path : /opt/alt/python39/lib64/python3.9/test/__pycache__/
Upload File :
Current File : //opt/alt/python39/lib64/python3.9/test/__pycache__/test_faulthandler.cpython-39.opt-2.pyc

a

XC?h�p�@s�ddlmZddlZddlZddlZddlZddlZddlZddlm	Z	ddl
mZmZddl
m
Z
ddlZddlZddlmZzddlZWney�dZYn0dZejdkZdd
d�Zdd
�Zedd��ZGdd�dej�Zedkr�e��dS)�)�contextmanagerN)�support)�
script_helper�
is_android)�skip_if_sanitizer)�dedentg�?�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
�;/opt/alt/python39/lib64/python3.9/test/test_faulthandler.py�expected_tracebacksrcCst�td�|�S)Nz(raising SIGSEGV on Android is unreliable)�unittest�skipIfr)�testr
r
r�skip_segfault_on_android!s
��rc	cs.t��}z|VWt�|�nt�|�0dS�N)�tempfileZmktempr�unlink��filenamer
r
r�temporary_filename&src@s2eZdZd�dd�Zddddddd�dd�Zd�d	d
�Zdd�Ze�e	j
�d
�d�dd��Ze
dd��Zdd�Zdd�Ze�e	j
dkd�dd��Ze�edud�e�eed�d�e
dd����Ze�edud�e�eed �d!�e
d"d#����Zd$d%�Zd&d'�Ze�e	j
�d(�d)�e�eed*�d+�d,d-���Ze
d.d/��Zeddd0d1�e
d2d3���Ze�e	j
dkd4�eddd0d1�e
d5d6����Ze
d7d8��Z e
d9d:��Z!d;d<�Z"d=d>�Z#d?d@�Z$dAdB�Z%dddC�dDdE�Z&dFdG�Z'dHdI�Z(e�e	j
dkd4�dJdK��Z)dLdM�Z*dNdO�Z+dPdQ�Z,dRdS�Z-d�dddC�dUdV�Z.dWdX�Z/dYdZ�Z0d[d\�Z1d]d^�Z2e�e	j
dkd4�d_d`��Z3dadb�Z4e�eedc�dd�d�dedf��Z5dgdh�Z6didj�Z7dkdl�Z8e�e	j
dkd4�dmdn��Z9dodp�Z:dqdr�Z;e<dsdt��Z=dudv�Z>e�e?dw�dxdy��Z@e�e?dw�dzd{��ZAe�e?dw�d|d}��ZBe�e?dw�d~d��ZCd�d��ZDdS)��FaultHandlerTestsNc
	Csdt|���}g}|dur"|�|�t���Xtjd||d�}|�$|��\}}|��}Wd�n1sj0YWd�n1s�0Y|�	dd�}|r�|�
|d�t|d��}	|	��}Wd�n1s�0Y|�	dd�}nj|du�rX|�
|d�t
�|t
jd�t|ddd	��}	|	��}Wd�n1�sB0Y|�	dd�}|��|fS)
N�-c)�pass_fds�ascii�backslashreplace��rbrF)�closefd)r�strip�appendrZSuppressCrashReportrZspawn_pythonZcommunicate�wait�decode�assertEqual�open�read�os�lseek�SEEK_SET�
splitlines)
�self�coder�fdrZprocess�output�stderr�exitcode�fpr
r
r�
get_output/s,


D&
(zFaultHandlerTests.get_outputTF)r�all_threads�other_regexr2�know_current_thread�py_fatal_errorcCs�|r|rd}
qd}
nd}
d}|	r(|d7}t|�j|||
d���}|rP|d|7}|j|||d�\}}
d	�|�}|�||�|�|
d
�dS)NzCurrent thread 0x[0-9a-f]+zThread 0x[0-9a-f]+ZStackz�
            (?m)^{fatal_error}

            {header} \(most recent call first\):
              File "<string>", line {lineno} in <module>
            z"
Python runtime state: initialized)�lineno�fatal_errorr�|�rr2rr)r�formatr%r7�join�assertRegex�assertNotEqual)r0r1�line_numberr=rr8r9r2r:r;rrr3r5r
r
r�check_errorPs&
�

zFaultHandlerTests.check_errorcKs2|rd||f}d|}|j|||fi|��dS)Nz%s: %szFatal Python error: %s�rE)r0r1rD�
name_regex�func�kwr=r
r
r�check_fatal_errortsz#FaultHandlerTests.check_fatal_errorcKs"d|}|j|||fi|��dS)NzWindows fatal exception: %srF)r0r1rDrGrIr=r
r
r�check_windows_exceptionzsz)FaultHandlerTests.check_windows_exceptionZaixz5the first page of memory is a mapped read-only on AIXcCs&ts|�ddd�n|�ddd�dS)Nz�
                import faulthandler
                faulthandler.enable()
                faulthandler._read_null()
                �z4(?:Segmentation fault|Bus error|Illegal instruction)�access violation)�
MS_WINDOWSrJrK�r0r
r
r�test_read_null~s��z FaultHandlerTests.test_read_nullcCs|�ddd�dS)Nzs
            import faulthandler
            faulthandler.enable()
            faulthandler._sigsegv()
            rL�Segmentation fault�rJrOr
r
r�test_sigsegv�s�zFaultHandlerTests.test_sigsegvcCs|jddddddd�dS)Nz�
            import faulthandler
            faulthandler.enable()
            faulthandler._fatal_error_c_thread()
            rLz
in new threadFZfaulthandler_fatal_error_threadT)r:rHr;rRrOr
r
r�test_fatal_error_c_thread�s�z+FaultHandlerTests.test_fatal_error_c_threadcCs|�ddd�dS)Nzs
            import faulthandler
            faulthandler.enable()
            faulthandler._sigabrt()
            rLZAbortedrRrOr
r
r�test_sigabrt�s�zFaultHandlerTests.test_sigabrtZwin32z"SIGFPE cannot be caught on WindowscCs|�ddd�dS)Nzr
            import faulthandler
            faulthandler.enable()
            faulthandler._sigfpe()
            rLzFloating point exceptionrRrOr
r
r�test_sigfpe�s�zFaultHandlerTests.test_sigfpezneed _testcapi�SIGBUSzneed signal.SIGBUScCs|�ddd�dS)Nz�
            import faulthandler
            import signal

            faulthandler.enable()
            signal.raise_signal(signal.SIGBUS)
            �z	Bus errorrRrOr
r
r�test_sigbus�s�zFaultHandlerTests.test_sigbus�SIGILLzneed signal.SIGILLcCs|�ddd�dS)Nz�
            import faulthandler
            import signal

            faulthandler.enable()
            signal.raise_signal(signal.SIGILL)
            rXzIllegal instructionrRrOr
r
r�test_sigill�s�zFaultHandlerTests.test_sigillcCs|jdddddd�dS)Nz[
            import faulthandler
            faulthandler._fatal_error(b'xyz')
            ��xyz�faulthandler_fatal_error_pyT�rHr;rRrOr
r
r�test_fatal_error�s�z"FaultHandlerTests.test_fatal_errorcCs|jdddddd�dS)Nza
            import faulthandler
            faulthandler._fatal_error(b'xyz', True)
            r\r]r^Tr_rRrOr
r
r�test_fatal_error_without_gil�s�z.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()
            rLz (?:Segmentation fault|Bus error)z unable to raise a stack overflow)r9rRrOr
r
r�test_stack_overflow�s
�z%FaultHandlerTests.test_stack_overflowcCs|�ddd�dS)Nzw
            import faulthandler
            faulthandler.enable()
            faulthandler._sigsegv(True)
            rLrQrRrOr
r
r�test_gil_released�s�z#FaultHandlerTests.test_gil_releasedz0sanitizer builds change crashing process output.)ZmemoryZub�reasoncCsHt��.}|jdjt|�d�dd|d�Wd�n1s:0YdS)Nz�
                import faulthandler
                output = open({filename}, 'wb')
                faulthandler.enable(output)
                faulthandler._sigsegv()
                r�rQ)rrJr@�repr�r0rr
r
r�test_enable_files��z"FaultHandlerTests.test_enable_filez.subprocess doesn't support pass_fds on WindowscCsLt�d��.}|��}|jd|dd|d�Wd�n1s>0YdS)N�wb+z�
                import faulthandler
                import sys
                faulthandler.enable(%s)
                faulthandler._sigsegv()
                rerQ�r2)r�
TemporaryFile�filenorJ)r0r6r2r
r
r�test_enable_fds��z FaultHandlerTests.test_enable_fdcCs|jddddd�dS)Nz�
            import faulthandler
            faulthandler.enable(all_threads=False)
            faulthandler._sigsegv()
            rLrQF�r8rRrOr
r
r�test_enable_single_thread)s
�z+FaultHandlerTests.test_enable_single_threadcCsHd}d}|�|�\}}d�|�}|�||vd||f�|�|d�dS)Nz�
            import faulthandler
            faulthandler.enable()
            faulthandler.disable()
            faulthandler._sigsegv()
            zFatal Python errorrz%r is present in %rr)r7rA�
assertTruerC)r0r1Znot_expectedr4r5r
r
r�test_disable4s


�zFaultHandlerTests.test_disablecCs�tj}zztjt_t��}zFt��|�t���t��|�t���W|rVt��qxt��n|rnt��nt��0W|t_n|t_0dSr)	�sysr4�
__stderr__�faulthandlerZ
is_enabled�enablerpZdisableZassertFalse)r0Zorig_stderrZwas_enabledr
r
r�test_is_enabledCs 

�
z!FaultHandlerTests.test_is_enabledcCs0d}tjdd|f}t�|�}|�|��d�dS)N�5import faulthandler; print(faulthandler.is_enabled())�-Er�False)rr�
executable�
subprocess�check_outputr)�rstrip)r0r1�argsr3r
r
r�test_disabled_by_defaultYs
z*FaultHandlerTests.test_disabled_by_defaultcCs`d}tdtjtjjrdndddd|f�}tj��}|�dd�t	j
||d�}|�|��d	�dS)
Nrwrxr"z-Xrtr�PYTHONFAULTHANDLER��env�True)
�filterrrrz�flags�ignore_environmentr,�environ�copy�popr{r|r)r}�r0r1r~r�r3r
r
r�test_sys_xoptionsas�
z#FaultHandlerTests.test_sys_xoptionscCs�d}tjd|f}ttj�}d|d<d|d<tj||d�}|�|��d�ttj�}d|d<d|d<tj||d�}|�|��d	�dS)
Nrwrr"r�Z
PYTHONDEVMODEr�ry�1r�)	rrrz�dictr,r�r{r|r)r}r�r
r
r�test_env_varms

zFaultHandlerTests.test_env_varr?cCsld}|j||d�}|rd}n|dur*d}nd}dd|dd	g}|�|||�\}}|�||�|�|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()
            r?�	���Stack (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@r7r))r0rr2r1r<�expected�tracer5r
r
r�check_dump_tracebacks$��z&FaultHandlerTests.check_dump_tracebackcCs|��dSr)r�rOr
r
r�test_dump_traceback�sz%FaultHandlerTests.test_dump_tracebackcCs6t��}|j|d�Wd�n1s(0YdS�Nr)rr�rgr
r
r�test_dump_traceback_file�sz*FaultHandlerTests.test_dump_traceback_filecCs>t�d�� }|j|��d�Wd�n1s00YdS�Nrirj)rrkr�rl�r0r6r
r
r�test_dump_traceback_fd�sz(FaultHandlerTests.test_dump_traceback_fdcCsdd}d|d}d|d}d}|j|d�}dd|d	g}|�|�\}}|�||�|�|d
�dS)Ni��x�2z...z�
            import faulthandler

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

            {func_name}()
            )�	func_namer�z  File "<string>", line 4 in %sz%  File "<string>", line 6 in <module>rr�)r0�maxlenr�Z	truncatedr1r�r�r5r
r
r�
test_truncate�s��zFaultHandlerTests.test_truncatecCspd}|jt|�d�}|�||�\}}d�|�}|r8d}nd}d}t|j|d����}|�||�|�|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>$
            )r<r)r@rfr7rArr%rBr))r0rr1r3r5r<rr
r
r�check_dump_traceback_threads�s 
z.FaultHandlerTests.check_dump_traceback_threadscCs|�d�dSr)r�rOr
r
r�test_dump_traceback_threads
sz-FaultHandlerTests.test_dump_traceback_threadscCs4t��}|�|�Wd�n1s&0YdSr)rr�rgr
r
r� test_dump_traceback_threads_filesz2FaultHandlerTests.test_dump_traceback_threads_filer	c
Cs�ttjtd��}d}|jt|||||d�}|�||�\}}	d�|�}|s~|}
|rX|
d9}
d|}tdd||
d	�}|�||�n|�	|d
�|�	|	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�loopsrr2rr\zATimeout \(%s\)!\nThread 0x[0-9a-f]+ \(most recent call first\):\n��)rr"r)
�str�datetimeZ	timedelta�TIMEOUTr@r7rArrBr))
r0r�r�r�rr2Ztimeout_strr1r�r5�countrrr
r
r�check_dump_traceback_laters*	�
z,FaultHandlerTests.check_dump_traceback_latercCs|��dSr�r�rOr
r
r�test_dump_traceback_laterRsz+FaultHandlerTests.test_dump_traceback_latercCs|jdd�dS)NT)r�r�rOr
r
r� test_dump_traceback_later_repeatUsz2FaultHandlerTests.test_dump_traceback_later_repeatcCs|jdd�dS)NT)r�r�rOr
r
r� test_dump_traceback_later_cancelXsz2FaultHandlerTests.test_dump_traceback_later_cancelcCs6t��}|j|d�Wd�n1s(0YdSr�)rr�rgr
r
r�test_dump_traceback_later_file[sz0FaultHandlerTests.test_dump_traceback_later_filecCs>t�d�� }|j|��d�Wd�n1s00YdSr�)rrkr�rlr�r
r
r�test_dump_traceback_later_fd_sz.FaultHandlerTests.test_dump_traceback_later_fdcCs|jdd�dS)Nr\)r�r�rOr
r
r�test_dump_traceback_later_twiceesz1FaultHandlerTests.test_dump_traceback_later_twice�registerzneed faulthandler.registercCs�tj}d}|j||||||d�}|�||�\}}	d�|�}|sf|rHd}
nd}
tdd|
�}
|�||
�n|�|d�|r�|�|	d	�n|�|	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)
            )r8�signum�
unregister�chainrr2rz8Current thread 0x[0-9a-f]+ \(most recent call first\):\nz#Stack \(most recent call first\):\nr�� r"r)	�signal�SIGUSR1r@r7rArrBr)rC)r0rr8r�r�r2r�r1r�r5rr
r
r�check_registerhs,.�
z FaultHandlerTests.check_registercCs|��dSr�r�rOr
r
r�
test_register�szFaultHandlerTests.test_registercCs|jdd�dS)NT)r�r�rOr
r
r�test_unregister�sz!FaultHandlerTests.test_unregistercCs6t��}|j|d�Wd�n1s(0YdSr�)rr�rgr
r
r�test_register_file�sz$FaultHandlerTests.test_register_filecCs>t�d�� }|j|��d�Wd�n1s00YdSr�)rrkr�rlr�r
r
r�test_register_fd�sz"FaultHandlerTests.test_register_fdcCs|jdd�dS)NTrnr�rOr
r
r�test_register_threads�sz'FaultHandlerTests.test_register_threadscCs|jdd�dS)NT)r�r�rOr
r
r�test_register_chain�sz%FaultHandlerTests.test_register_chainccsftj}zRdt_|�t��}dVWd�n1s40Y|�t|j�d�W|t_n|t_0dS)Nzsys.stderr is None)rrr4ZassertRaises�RuntimeErrorr)r�Z	exception)r0r4�cmr
r
r�check_stderr_none�s$z#FaultHandlerTests.check_stderr_nonecCs�|���t��Wd�n1s&0Y|���t��Wd�n1sV0Y|���t�d�Wd�n1s�0Yttd�r�|���t�tj�Wd�n1s�0YdS)Ng����MbP?r�)	r�rtruZdump_tracebackZdump_traceback_later�hasattrr�r�r�rOr
r
r�test_stderr_None�s
&
&
(

z"FaultHandlerTests.test_stderr_Nonezspecific to WindowscCs(dD]\}}|�d|�d�d|�qdS)N))ZEXCEPTION_ACCESS_VIOLATIONrM)ZEXCEPTION_INT_DIVIDE_BY_ZEROzint divide by zero)ZEXCEPTION_STACK_OVERFLOWzstack overflowz�
                import faulthandler
                faulthandler.enable()
                faulthandler._raise_exception(faulthandler._�)
                rL)rK)r0�exc�namer
r
r�test_raise_exception�s��z&FaultHandlerTests.test_raise_exceptioncCsHdD]>}d|�d�}t|�}|�|�\}}|�|g�|�||�qdS)N)lcs�@lRC�@z�
                    import faulthandler
                    faulthandler.enable()
                    faulthandler._raise_exception(z)
                    �rr7r))r0Zexc_coder1r3r5r
r
r�test_ignore_exception�s�z'FaultHandlerTests.test_ignore_exceptioncCsFdD]<}|�d|d�d��\}}|�|g�|�|||d@f�qdS)N)ri�xV4i@i@ipi���z{
                import faulthandler
                faulthandler.enable()
                faulthandler._raise_exception(0xr�r�i����)r7r)ZassertIn)r0r�r3r5r
r
r�test_raise_nonfatal_exceptions�
�z/FaultHandlerTests.test_raise_nonfatal_exceptioncCs2td�}|�|�\}}|�|g�|�|d�dS)Nz�
            import faulthandler
            faulthandler.enable()
            faulthandler.disable()
            code = faulthandler._EXCEPTION_ACCESS_VIOLATION
            faulthandler._raise_exception(code)
        lr��r0r1r3r5r
r
r� test_disable_windows_exc_handler$sz2FaultHandlerTests.test_disable_windows_exc_handlercCs2td�}|�|�\}}|�|g�|�|d�dS)Nz`
            import faulthandler
            faulthandler.cancel_dump_traceback_later()
        rr�r�r
r
r�.test_cancel_later_without_dump_traceback_later1sz@FaultHandlerTests.test_cancel_later_without_dump_traceback_later)NN)N)FFr	)FFFFN)E�__name__�
__module__�__qualname__r7rErJrKrrrr�platform�
startswithrPrrSrTrUrV�	_testcapiZ
skipUnlessr�r�rYr[r`rartrbrcrrhrmrorqrvrr�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�rr�r�rNr�r�r�r�r�r
r
r
rr.s�
"�$
�

		�
	

��

	�



.�
;�>�
��Q�










r�__main__)r	)�
contextlibrr�rtr,r�r{rrrrZtest.supportrrrrr�textwraprr��ImportErrorr�r�rNrrrZTestCaserr��mainr
r
r
r�<module>s>