HEX
Server: Apache
System: Linux zacp120.webway.host 4.18.0-553.50.1.lve.el8.x86_64 #1 SMP Thu Apr 17 19:10:24 UTC 2025 x86_64
User: govancoz (1003)
PHP: 8.3.26
Disabled: exec,system,passthru,shell_exec,proc_close,proc_open,dl,popen,show_source,posix_kill,posix_mkfifo,posix_getpwuid,posix_setpgid,posix_setsid,posix_setuid,posix_setgid,posix_seteuid,posix_setegid,posix_uname
$ pwd: /usr/local/lib/python3.7/test/__pycache__/
Upload Files
File: //usr/local/lib/python3.7/test/__pycache__/test_faulthandler.cpython-37.pyc
B

��g�o�@s:ddlmZddlZddlZddlZddlZddlZddlZddlZddl	m
Z
ddlmZm
Z
ddlZddlZddlZddlmZyddlZWnek
r�dZYnXdZejdkZe�d�p�d	Ze�d
�p�d	Zdekp�dekZd
ekp�dekZddd�Zdd�Zedd��ZGdd�dej �Z!e"dk�r6e�#�dS)�)�contextmanagerN)�support)�
script_helper�
is_android)�dedentg�?�ntZCFLAGS�ZCONFIG_ARGSz-fsanitize=undefinedz#--with-undefined-behavior-sanitizerz-fsanitize=memoryz--with-memory-sanitizer�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
�2/usr/local/lib/python3.7/test/test_faulthandler.py�expected_traceback#srcCst�td�|�S)Nz(raising SIGSEGV on Android is unreliable)�unittest�skipIfr)�testr
r
r�skip_segfault_on_android,src	cs$t��}z
|VWdt�|�XdS)N)�tempfileZmktempr�unlink)�filenamer
r
r�temporary_filename1s
rc@sBeZdZd�dd�Zdddddd�dd�Zdd	�Zd
d�Ze�e	j
�d�d
�dd��Ze
dd��Zdd�Zdd�Ze�e	j
dkd�dd��Ze�edkd�e�eed�d�e
dd����Ze�edkd�e�eed�d �e
d!d"����Zd#d$�Zd%d&�Ze�e	j
�d'�d(�e�eed)�d*�d+d,���Ze
d-d.��Ze�e�p>ed/�e
d0d1���Ze�e	j
dkd2�e�e�pled/�e
d3d4����Z e
d5d6��Z!e
d7d8��Z"d9d:�Z#d;d<�Z$d=d>�Z%d?d@�Z&dddA�dBdC�Z'dDdE�Z(dFdG�Z)e�e	j
dkd2�dHdI��Z*dJdK�Z+dLdM�Z,dNdO�Z-dPdQ�Z.e�eedR�dS�d�dddA�dVdW��Z/dXdY�Z0dZd[�Z1d\d]�Z2d^d_�Z3e�e	j
dkd2�d`da��Z4dbdc�Z5e�eedd�de�d�dfdg��Z6dhdi�Z7djdk�Z8dldm�Z9e�e	j
dkd2�dndo��Z:dpdq�Z;drds�Z<e=dtdu��Z>dvdw�Z?e�e@dx�dydz��ZAe�e@dx�d{d|��ZBe�e@dx�d}d~��ZCe�e@dx�dd���ZDdS)��FaultHandlerTestsNc
Cst|���}g}|dk	r"|�|�t���:tjd||d�}|�|��\}}|��}WdQRXWdQRXt�	|�}	|	�
dd�}	|r�|�|	d�t|d��}
|
�
�}	WdQRX|	�
dd�}	nT|dk	�r|�|	d�t�|tjd�t|dd	d
��}
|
�
�}	WdQRX|	�
dd�}	|	��|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".
        Nz-c)�pass_fds�ascii�backslashreplacer�rbrF)�closefd)r�strip�appendrZSuppressCrashReportrZspawn_pythonZcommunicate�waitZstrip_python_stderr�decode�assertEqual�open�read�os�lseek�SEEK_SET�
splitlines)�self�coder�fdrZprocess�stdout�stderr�exitcode�output�fpr
r
r�
get_output:s.




zFaultHandlerTests.get_outputT)r�all_threads�other_regexr.�know_current_threadc
Cs~|r|rd}	qd}	nd}	d}
t|
j|||	d����}
|rD|
d|7}
|j|||d�\}}d�|�}|�||
�|�|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.
        zCurrent 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>
            )�lineno�fatal_errorr�|)rr.rrN)r�formatr!r4�join�assertRegex�assertNotEqual)
r,r-�line_numberr9rr5r6r.r7rrr2r1r
r
r�check_error\s 	
zFaultHandlerTests.check_errorcKsd|}|j|||f|�dS)NzFatal Python error: %s)r@)r,r-r?�
name_regex�kwr9r
r
r�check_fatal_error}sz#FaultHandlerTests.check_fatal_errorcKsd|}|j|||f|�dS)NzWindows fatal exception: %s)r@)r,r-r?rArBr9r
r
r�check_windows_exception�sz)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)zaccess violation)�
MS_WINDOWSrCrD)r,r
r
r�test_read_null�sz FaultHandlerTests.test_read_nullcCs|�ddd�dS)Nzs
            import faulthandler
            faulthandler.enable()
            faulthandler._sigsegv()
            rEzSegmentation fault)rC)r,r
r
r�test_sigsegv�szFaultHandlerTests.test_sigsegvcCs|jddddd�dS)Nz�
            import faulthandler
            faulthandler.enable()
            faulthandler._fatal_error_c_thread()
            rEz
in new threadF)r7)rC)r,r
r
r�test_fatal_error_c_thread�s
z+FaultHandlerTests.test_fatal_error_c_threadcCs|�ddd�dS)Nzs
            import faulthandler
            faulthandler.enable()
            faulthandler._sigabrt()
            rEZAborted)rC)r,r
r
r�test_sigabrt�szFaultHandlerTests.test_sigabrt�win32z"SIGFPE cannot be caught on WindowscCs|�ddd�dS)Nzr
            import faulthandler
            faulthandler.enable()
            faulthandler._sigfpe()
            rEzFloating point exception)rC)r,r
r
r�test_sigfpe�szFaultHandlerTests.test_sigfpezneed _testcapi�SIGBUSzneed signal.SIGBUScCs|�ddd�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|�ddd�dS)Nz�
            import _testcapi
            import faulthandler
            import signal

            faulthandler.enable()
            _testcapi.raise_signal(signal.SIGILL)
            rNzIllegal instruction)rC)r,r
r
r�test_sigill�szFaultHandlerTests.test_sigillcCs|�ddd�dS)Nz[
            import faulthandler
            faulthandler._fatal_error(b'xyz')
            ��xyz)rC)r,r
r
r�test_fatal_error�sz"FaultHandlerTests.test_fatal_errorcCs|�ddd�dS)Nza
            import faulthandler
            faulthandler._fatal_error(b'xyz', True)
            rRrS)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()
            rEz (?: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|�ddd�dS)Nzw
            import faulthandler
            faulthandler.enable()
            faulthandler._sigsegv(True)
            rEzSegmentation fault)rC)r,r
r
r�test_gil_releasedsz#FaultHandlerTests.test_gil_releasedz0sanitizer builds change crashing process output.c	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_filesz"FaultHandlerTests.test_enable_filez.subprocess doesn't support pass_fds on Windowsc	Cs8t�d��$}|��}|jd|dd|d�WdQRXdS)Nzwb+z�
                import faulthandler
                import sys
                faulthandler.enable(%s)
                faulthandler._sigsegv()
                rXzSegmentation fault)r.)r�
TemporaryFile�filenorC)r,r3r.r
r
r�test_enable_fdsz FaultHandlerTests.test_enable_fdcCs|jddddd�dS)Nz�
            import faulthandler
            faulthandler.enable(all_threads=False)
            faulthandler._sigsegv()
            rEzSegmentation faultF)r5)rC)r,r
r
r�test_enable_single_thread,s
z+FaultHandlerTests.test_enable_single_threadcCsHd}d}|�|�\}}d�|�}|�||kd||f�|�|d�dS)Nz�
            import faulthandler
            faulthandler.enable()
            faulthandler.disable()
            faulthandler._sigsegv()
            zFatal Python errorrz%r is present in %rr)r4r<�
assertTruer>)r,r-Znot_expectedr0r1r
r
r�test_disable7s

zFaultHandlerTests.test_disablecCsrtj}z^tjt_t��}z0t��|�t���t��|�t���Wd|rXt��nt��XWd|t_XdS)N)	�sysr0�
__stderr__�faulthandlerZ
is_enabled�enabler_ZdisableZassertFalse)r,Zorig_stderrZwas_enabledr
r
r�test_is_enabledFs
z!FaultHandlerTests.test_is_enabledcCs0d}tjdd|f}t�|�}|�|��d�dS)Nz5import faulthandler; print(faulthandler.is_enabled())z-Ez-csFalse)ra�
executable�
subprocess�check_outputr%�rstrip)r,r-�argsr2r
r
r�test_disabled_by_default\s
z*FaultHandlerTests.test_disabled_by_defaultcCs`d}tdtjtjjrdndddd|f�}tj��}|�dd�t	j
||d�}|�|��d	�dS)
Nz5import faulthandler; print(faulthandler.is_enabled())z-Erz-Xrcz-c�PYTHONFAULTHANDLER)�envsTrue)
�filterrarf�flags�ignore_environmentr(�environ�copy�poprgrhr%ri)r,r-rjrmr2r
r
r�test_sys_xoptionsds
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)
Nz5import faulthandler; print(faulthandler.is_enabled())z-crrlZ
PYTHONDEVMODE)rmsFalse�1sTrue)	rarf�dictr(rqrgrhr%ri)r,r-rjrmr2r
r
r�test_env_varps

zFaultHandlerTests.test_env_var)rr.cCsld}|j||d�}|rd}n|dk	r*d}nd}dd|d	d
g}|�|||�\}}|�||�|�|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

            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.�	N��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_traceback�s z&FaultHandlerTests.check_dump_tracebackcCs|��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*t�d��}|j|��d�WdQRXdS)Nzwb+)r.)rr[r}r\)r,r3r
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_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�szFaultHandlerTests.test_truncatecCspd}|jt|�d�}|�||�\}}d�|�}|r8d}nd}d}t|j|d����}|�||�|�|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��
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>$
            )r8rN)r;rYr4r<rr!r=r%)r,rr-r2r1r8rr
r
r�check_dump_traceback_threads�s$
z.FaultHandlerTests.check_dump_traceback_threadscCs|�d�dS)N)r�)r,r
r
r�test_dump_traceback_threadssz-FaultHandlerTests.test_dump_traceback_threadsc	Cs t��}|�|�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�}|�||�\}}	d�|�}|s~|}
|rX|
d9}
d|}tdd||
d	�}|�||�n|�	|d
�|�	|	d�dS)
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
            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.rrRzATimeout \(%s\)!\nThread 0x[0-9a-f]+ \(most recent call first\):\n��)rrrN)
�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|��dS)N)r�)r,r
r
r�test_dump_traceback_laterWsz+FaultHandlerTests.test_dump_traceback_latercCs|jdd�dS)NT)r�)r�)r,r
r
r� test_dump_traceback_later_repeatZsz2FaultHandlerTests.test_dump_traceback_later_repeatcCs|jdd�dS)NT)r�)r�)r,r
r
r� test_dump_traceback_later_cancel]sz2FaultHandlerTests.test_dump_traceback_later_cancelc	Cs"t��}|j|d�WdQRXdS)N)r)rr�)r,rr
r
r�test_dump_traceback_later_file`sz0FaultHandlerTests.test_dump_traceback_later_filec	Cs*t�d��}|j|��d�WdQRXdS)Nzwb+)r.)rr[r�r\)r,r3r
r
r�test_dump_traceback_later_fddsz.FaultHandlerTests.test_dump_traceback_later_fdcCs|jdd�dS)NrR)r�)r�)r,r
r
r�test_dump_traceback_later_twicejsz1FaultHandlerTests.test_dump_traceback_later_twice�registerzneed faulthandler.registercCs�tj}d}|j||||||d�}|�||�\}}	d�|�}|sf|rHd}
nd}
tdd|
�}
|�||
�n|�|d�|r�|�|	d	�n|�|	d	�d
S)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.
        ax
            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\):\nrz� rrN)	�signal�SIGUSR1r;r4r<rr=r%r>)r,rr5r�r�r.r�r-r|r1rr
r
r�check_registerms*.
z FaultHandlerTests.check_registercCs|��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*t�d��}|j|��d�WdQRXdS)Nzwb+)r.)rr[r�r\)r,r3r
r
r�test_register_fd�sz"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_chainc	csLtj}z8dt_|�t��}dVWdQRX|�t|j�d�Wd|t_XdS)Nzsys.stderr is None)rar0ZassertRaises�RuntimeErrorr%r�Z	exception)r,r0�cmr
r
r�check_stderr_none�sz#FaultHandlerTests.check_stderr_nonec	Cs�|���t��WdQRX|���t��WdQRXttd�r`|���t�d�WdQRXttd�r�|���t�tj�WdQRXdS)Nr�g����MbP?r�)	r�rcrdZdump_traceback�hasattrr�r�r�r�)r,r
r
r�test_stderr_None�s





z"FaultHandlerTests.test_stderr_Nonezspecific to WindowscCs,x&dD]\}}|�d|�d�d|�qWdS)N))ZEXCEPTION_ACCESS_VIOLATIONzaccess violation)ZEXCEPTION_INT_DIVIDE_BY_ZEROzint divide by zero)ZEXCEPTION_STACK_OVERFLOWzstack overflowz�
                import faulthandler
                faulthandler.enable()
                faulthandler._raise_exception(faulthandler._z)
                rE)rD)r,�exc�namer
r
r�test_raise_exception�s
z&FaultHandlerTests.test_raise_exceptioncCsLxFdD]>}d|�d�}t|�}|�|�\}}|�|g�|�||�qWdS)N)lcs�@lRC�@z�
                    import faulthandler
                    faulthandler.enable()
                    faulthandler._raise_exception(z)
                    )rr4r%)r,Zexc_coder-r2r1r
r
r�test_ignore_exception�sz'FaultHandlerTests.test_ignore_exceptioncCsJxDdD]<}|�d|d�d��\}}|�|g�|�|||d@f�qWdS)N)ri�xV4i@i@ipi���z{
                import faulthandler
                faulthandler.enable()
                faulthandler._raise_exception(0xr�z)
                i����)r4r%ZassertIn)r,r�r2r1r
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)
        l)rr4r%)r,r-r2r1r
r
r� test_disable_windows_exc_handler*s
z2FaultHandlerTests.test_disable_windows_exc_handler)NN)FFr	)FFFFN)E�__name__�
__module__�__qualname__r4r@rCrDrrra�platform�
startswithrGrrHrIrJrL�	_testcapiZ
skipUnlessr�r�rOrQrTrUrcrVrW�UB_SANITIZER�MEMORY_SANITIZERrZr]r^r`rerkrtrwr}r~rr�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�rr�r�rFr�r�r�r�r
r
r
rr9s�
#

	




.;=Pr�__main__)r	)$�
contextlibrr�rcr(r�rgraZ	sysconfigrrZtest.supportrrrZ	threadingr�textwraprr��ImportErrorr�r�rFZget_config_varZ_cflagsZ_config_argsr�r�rrrZTestCaserr��mainr
r
r
r�<module>sJ


	

@ Telegram