✘✘ GRAYBYTE WORDPRESS FILE MANAGER ✘✘

B

YI~d�o�@s:
dd
lm
Z

ddlZddlZddlZddlZddlZddlZddlZddl	m
Z

ddlmZm
Z

ddlZddlZddlZddlmZ
yddlZWnek
r�


dZYnXdZejdkZe�d�
p�d	Ze�d
�
p�d	Zdekp�dekZd
ekp�dekZddd�
Zdd�Ze
dd��
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
�;/opt/alt/python37/lib64/python3.7/test/test_faulthandler.py�expected_traceback#s




rc

Cst�
td
�|�
S)Nz(raising SIGSEGV on Android is unreliable)�unittest�skipIfr)
�testr
r
r�skip_segfault_on_android,s
rc
	cs$t�
�}z
|V
Wdt�|�

XdS)
N)�tempfileZmktempr�unlink)
�filenamer
r
r�temporary_filename1s


rc@sBeZ
dZd�dd�
Zd
dd
d
dd�dd�Zdd	�Zd
d�Ze�e	j
�d�
d
�dd��
Ze
dd��
Zdd�Zdd�Ze�e	j
dkd�dd��
Ze�ed
kd�e�eed�d�e
dd��
�
�
Ze�ed
kd�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&d
d
dA�dBdC�Z'dDdE�Z(dFdG�Z)e�e	j
dkd2�dHdI��
Z*dJdK�Z+dLdM�Z,dNdO�Z-dPdQ�Z.e�eedR�dS�d�d
d
dA�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���
ZDd
S)��FaultHandlerTestsNc
Cs
t|
�
�
�}
g}|dk	r"|�|�

t���:
tjd
|
|d�}|�
|��\}}|��}WdQRXWdQRXt�	|�
}	|	�
dd�}	|r�|�|	d�
t|d��}
|
�
�}	WdQRX|	�
dd�}	nT|dk	�
r|�|	d�
t�|tjd�
t|ddd	��}
|
�
�}	WdQRX|	�
dd�}	|	��|fS)
Nz-c)
�pass_fds�ascii�backslashreplacer�rbr
F)
�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	�
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>
            )�lineno�fatal_errorr�
|)rr.rr
)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}s

z#FaultHandlerTests.check_fatal_errorcKsd
|}|j|
||f|�

dS)NzWindows fatal exception: %s)
r@)r,r-r?rArBr9r
r
r�check_windows_exception�s

z)FaultHandlerTests.check_windows_exceptionZaixz5the first page of memory is a mapped read-only on AIXc

Cs&ts|�
d
dd�
n|�d
dd�
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�s



z FaultHandlerTests.test_read_nullc

Cs|�d
dd�
dS)Nzs
            import faulthandler
            faulthandler.enable()
            faulthandler._sigsegv()
            rEzSegmentation fault)
rC)
r,r
r
r�test_sigsegv�s

zFaultHandlerTests.test_sigsegvc

Cs|jd
dddd�
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_threadc

Cs|�d
dd�
dS)Nzs
            import faulthandler
            faulthandler.enable()
            faulthandler._sigabrt()
            rEZAborted)
rC)
r,r
r
r�test_sigabrt�s


zFaultHandlerTests.test_sigabrt�win32z"SIGFPE cannot be caught on Windowsc

Cs|�d
dd�
dS)Nzr
            import faulthandler
            faulthandler.enable()
            faulthandler._sigfpe()
            rEzFloating point exception)
rC)
r,r
r
r�test_sigfpe�s

zFaultHandlerTests.test_sigfpezneed _testcapi�SIGBUSzneed signal.SIGBUSc

Cs|�d
dd�
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�s

zFaultHandlerTests.test_sigbus�SIGILLzneed signal.SIGILLc

Cs|�d
dd�
dS)Nz�
            import _testcapi
            import faulthandler
            import signal

            faulthandler.enable()
            _testcapi.raise_signal(signal.SIGILL)
            rNzIllegal instruction)
rC)
r,r
r
r�test_sigill�s

zFaultHandlerTests.test_sigillc

Cs|�d
dd�
dS)Nz[
            import faulthandler
            faulthandler._fatal_error(b'xyz')
            ��xyz)
rC)
r,r
r
r�test_fatal_error�s


z"FaultHandlerTests.test_fatal_errorc

Cs|�d
dd�
dS)Nza
            import faulthandler
            faulthandler._fatal_error(b'xyz', True)
            rRrS)
rC)
r,r
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()c

Cs|jd
dddd�
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_overflowc

Cs|�d
dd�
dS)Nzw
            import faulthandler
            faulthandler.enable()
            faulthandler._sigsegv(True)
            rEzSegmentation fault)
rC)
r,r
r
r�test_gil_released

s

z#FaultHandlerTests.test_gil_releasedz0sanitizer builds change crashing process output.c
	Cs4t��$}
|j
d
jt|
�
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_file
s



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_fd
s




z FaultHandlerTests.test_enable_fdc

Cs|jd
dddd�
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_threadc
CsHd
}
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_disable7
s







zFaultHandlerTests.test_disablec
Csrtj
}
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_enabledF
s








z!FaultHandlerTests.test_is_enabledc
Cs0d
}
tj
dd|
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_defaultc
Cs`d
}
tdt
jt
jjrdndddd|
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_xoptionsd
s






z#FaultHandlerTests.test_sys_xoptionsc
Cs�d
}
tj
d|
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_varp
s










zFaultHandlerTests.test_env_var)rr.c
Csld
}|j|
|d�}|
rd}n|dk	r*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()
            )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_traceback�
s 










z&FaultHandlerTests.check_dump_tracebackc

Cs|��
dS)
N)
r})
r,r
r
r�test_dump_traceback�
s
z%FaultHandlerTests.test_dump_tracebackc
	Cs"t��}
|j
|
d
�

WdQRXdS)N)
r)rr})r,rr
r
r�test_dump_traceback_file�
s

z*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_fdc
Csdd
}
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�
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;rYr4r<rr!r=r%)r,rr-r2r1r8rr
r
r�check_dump_traceback_threads�
s$








z.FaultHandlerTests.check_dump_traceback_threadsc

Cs|�d�

dS)
N)
r�)
r,r
r
r�test_dump_traceback_threadss
z-FaultHandlerTests.test_dump_traceback_threadsc
	Cs t��}
|�
|
�

WdQRXdS)
N)rr�)r,rr
r
r� test_dump_traceback_threads_files

z2FaultHandlerTests.test_dump_traceback_threads_file�dump_traceback_laterz(need faulthandler.dump_traceback_later()Fr	c
Cs�tt
jtd
�
�
}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�loopsrr.rrRzATimeout \(%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_laterc

Cs|��
dS)
N)
r�)
r,r
r
r�test_dump_traceback_laterWs
z+FaultHandlerTests.test_dump_traceback_laterc

Cs|jd
d�

dS)NT)
r�)
r�)
r,r
r
r� test_dump_traceback_later_repeatZs
z2FaultHandlerTests.test_dump_traceback_later_repeatc

Cs|jd
d�

dS)NT)
r�)
r�)
r,r
r
r� test_dump_traceback_later_cancel]s
z2FaultHandlerTests.test_dump_traceback_later_cancelc
	Cs"t��}
|j
|
d
�

WdQRXdS)N)
r)rr�)r,rr
r
r�test_dump_traceback_later_file`s

z0FaultHandlerTests.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_fdc

Cs|jd
d�

dS)NrR)
r�)
r�)
r,r
r
r�test_dump_traceback_later_twicejs
z1FaultHandlerTests.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)
            )r5�signum�
unregister�chainrr.rz8Current thread 0x[0-9a-f]+ \(most recent call first\):\nz#Stack \(most recent call first\):\nrz� rr
)	�signal�SIGUSR1r;r4r<rr=r%r>)r,rr5r�r�r.r�r-r|r1rr
r
r�check_registerms*.















z FaultHandlerTests.check_registerc

Cs|��
dS)
N)
r�)
r,r
r
r�
test_register�s
zFaultHandlerTests.test_registerc

Cs|jd
d�

dS)NT)
r�)
r�)
r,r
r
r�test_unregister�s
z!FaultHandlerTests.test_unregisterc
	Cs"t��}
|j
|
d
�

WdQRXdS)N)
r)rr�)r,rr
r
r�test_register_file�s

z$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_fdc

Cs|jd
d�

dS)NT)
r5)
r�)
r,r
r
r�test_register_threads�s
z'FaultHandlerTests.test_register_threadsc

Cs|jd
d�

dS)NT)
r�)
r�)
r,r
r
r�test_register_chain�s
z%FaultHandlerTests.test_register_chainc
	csLtj
}
z8dt_
|�t�
�}dV
WdQRX|�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
��
WdQRXtt
d
�r`|���
t
�d�

WdQRXtt
d�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 Windowsc
Cs,x&d
D]\}
}|�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_exceptionc
CsLxFd
D]>}
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_exceptionc
CsJxDd
D]<}
|�d|
d�d��
\}}|�
|g�
|�||
|
d@f�
qWdS)N)r
i�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_exceptionc
Cs2td
�
}
|�
|
�
\}}|�|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