Your IP : 216.73.216.213

Current Path : /opt/alt/python35/lib64/python3.5/test/__pycache__/
Upload File :
Current File : //opt/alt/python35/lib64/python3.5/test/__pycache__/test_faulthandler.cpython-35.opt-2.pyc



���]�]�@sbddlmZddlZddlZddlZddlZddlZddlZddlZddl	m
Z
ddlmZddl
Z
ddlZddlmZyddlZdZWnek
r�dZYnXyddlZWnek
rdZYnXdZd	d
d�Zedd
��ZGdd�dej�Zedkr^ej�dS)�)�contextmanagerN)�support)�
script_helper)�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�regexr
r
�6/opt/alt/python35/lib64/python3.5/test_faulthandler.py�expected_tracebacksrccs*tj�}z	|VWdtj|�XdS)N)�tempfile�mktempr�unlink)�filenamer
r
r�temporary_filename$s	rc
@s�eZdZdddd�Zdddddd�Zejejj	d�d�d	d
��Z
dd�Zd
d�Zejejdkd�dd��Z
ejedkd�ejeed�d�dd���Zejedkd�ejeed�d�dd���Zdd�Zdd�Zejejj	d �oPed!�ejeed"�d#�d$d%���Zd&d'�Zd(d)�Zejejdkd*�d+d,��Zd-d.�Zd/d0�Zd1d2�Zd3d4�Zd5d6�Z d7d8�Z!d9dd:dd;d<�Z"d=d>�Z#d?d@�Z$ejejdkd*�dAdB��Z%dCdD�Z&ejedE�dFdG��Z'dHdI�Z(dJdK�Z)ejeedL�dM�dNdNdOd9dd:ddPdQ��Z*dRdS�Z+dTdU�Z,dVdW�Z-dXdY�Z.ejejdkd*�dZd[��Z/d\d]�Z0ejeed^�d_�dNdNdNdNdd`da��Z1dbdc�Z2ddde�Z3dfdg�Z4ejejdkd*�dhdi��Z5djdk�Z6dldm�Z7e8dndo��Z9dpdq�Z:dS)r�FaultHandlerTestsNcCs�t|�j�}g}|dk	r1|j|�tj��tjd|d|�}WdQRX|j�\}}|j�}tj	|�}	|	j
dd�}	|r�|j|	d�t|d��}
|
j
�}	WdQRX|	j
dd�}	no|dk	r[|j|	d�tj|tjd�t|ddd	��}
|
j
�}	WdQRX|	j
dd�}	tjd
d|	�}	|	j�|fS)Nz-c�pass_fds�ascii�backslashreplace��rbr�closefdFzCurrent thread 0x[0-9a-f]+zCurrent thread XXX)r�strip�appendrZSuppressCrashReportrZspawn_python�communicate�waitZstrip_python_stderr�decode�assertEqual�open�read�os�lseek�SEEK_SET�re�sub�
splitlines)�self�coder�fdr�process�stdout�stderr�exitcode�output�fpr
r
r�
get_output-s2


		zFaultHandlerTests.get_outputTc	Cs�|rd}nd}d}	t|	jd|d|dtj|���j�}	|rb|	d|7}	|j|d|d	|�\}
}d
j|
�}
|j|
|	�|j|d�dS)Nz+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�|rr,rr)	r�formatr'�escaperr3�join�assertRegex�assertNotEqual)r*r+Zline_numberZ
name_regexr�all_threads�other_regexr,rr
r1r0r
r
r�check_fatal_errorQs		!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))r>)r*r
r
r�test_read_nullosz FaultHandlerTests.test_read_nullcCs|jddd�dS)Nzs
            import faulthandler
            faulthandler.enable()
            faulthandler._sigsegv()
            r@zSegmentation fault)r>)r*r
r
r�test_sigsegv{szFaultHandlerTests.test_sigsegvcCs|jddd�dS)Nzs
            import faulthandler
            faulthandler.enable()
            faulthandler._sigabrt()
            r@ZAborted)r>)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()
            r@zFloating point exception)r>)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)r>)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)
            rGzIllegal instruction)r>)r*r
r
r�test_sigill�szFaultHandlerTests.test_sigillcCs|jddd�dS)Nz[
            import faulthandler
            faulthandler._fatal_error(b'xyz')
            ��xyz)r>)r*r
r
r�test_fatal_error�sz"FaultHandlerTests.test_fatal_errorcCs|jddd�dS)Nza
            import faulthandler
            faulthandler._fatal_error(b'xyz', True)
            rKrL)r>)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()
            r@z (?:Segmentation fault|Bus error)r=z unable to raise a stack overflow)r>)r*r
r
r�test_stack_overflow�s
z%FaultHandlerTests.test_stack_overflowcCs|jddd�dS)Nzw
            import faulthandler
            faulthandler.enable()
            faulthandler._sigsegv(True)
            r@zSegmentation fault)r>)r*r
r
r�test_gil_released�sz#FaultHandlerTests.test_gil_releasedc
CsBt��2}|jdjdt|��ddd|�WdQRXdS)Nz�
                import faulthandler
                output = open({filename}, 'wb')
                faulthandler.enable(output)
                faulthandler._sigsegv()
                r�zSegmentation fault)rr>r7�repr)r*rr
r
r�test_enable_file�sz"FaultHandlerTests.test_enable_filez.subprocess doesn't support pass_fds on Windowsc
CsFtjd��0}|j�}|jd|ddd|�WdQRXdS)Nzwb+z�
                import faulthandler
                import sys
                faulthandler.enable(%s)
                faulthandler._sigsegv()
                rQzSegmentation faultr,)r�
TemporaryFile�filenor>)r*r2r,r
r
r�test_enable_fd�sz FaultHandlerTests.test_enable_fdcCs|jddddd�dS)Nz�
            import faulthandler
            faulthandler.enable(all_threads=False)
            faulthandler._sigsegv()
            r@zSegmentation faultr<F)r>)r*r
r
r�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 errorrz%r is present in %rr)r3r9�
assertTruer;)r*r+Znot_expectedr/r0r
r
r�test_disableszFaultHandlerTests.test_disablecCs�tj}z{tjt_tj�}z>tj�|jtj��tj�|jtj��Wd|rxtj�n
tj�XWd|t_XdS)N)	�sysr/�
__stderr__�faulthandlerZ
is_enabled�enablerX�disableZassertFalse)r*Zorig_stderrZwas_enabledr
r
r�test_is_enableds	


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)
�filterrZ�
executable�flags�ignore_environmentr$�environ�copy�pop�
subprocess�check_outputr!�rstrip)r*r+�argsrar1r
r
r�test_disabled_by_default%sz*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-Xr\z-cr`rasTrue)
rbrZrcrdrer$rfrgrhrirjr!rk)r*r+rlrar1r
r
r�test_sys_xoptions1sz#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-crr`rasFalse�1sTrue)	rZrcr$rfrgrirjr!rk)r*r+rlrar1r
r
r�test_env_var=s

zFaultHandlerTests.test_env_varrr,cCs�d}|jd|d|�}|r-d}n|dk	rBd}nd}dd|d	d
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)r7r3r!)r*rr,r+r4�expected�tracer0r
r
r�check_dump_tracebackMs 					z&FaultHandlerTests.check_dump_tracebackcCs|j�dS)N)rv)r*r
r
r�test_dump_traceback{sz%FaultHandlerTests.test_dump_tracebackc
Cs't��}|jd|�WdQRXdS)Nr)rrv)r*rr
r
r�test_dump_traceback_file~sz*FaultHandlerTests.test_dump_traceback_filec
Cs3tjd��}|jd|j��WdQRXdS)Nzwb+r,)rrTrvrU)r*r2r
r
r�test_dump_traceback_fd�sz(FaultHandlerTests.test_dump_traceback_fdcCs�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)r7r3r!)r*�maxlenr|Z	truncatedr+rtrur0r
r
r�
test_truncate�s			zFaultHandlerTests.test_truncatezneed threadscCs�d}|jdt|��}|j||�\}}dj|�}|rTd}nd}d}t|jd|��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 XXX \(most recent call first\):
              File "<string>", line {lineno} in dump
              File "<string>", line 28 in <module>$
            r4r)r7rRr3r9rrr:r!)r*rr+r1r0r4r
r
r
r�check_dump_traceback_threads�s%	z.FaultHandlerTests.check_dump_traceback_threadscCs|jd�dS)N)r�)r*r
r
r�test_dump_traceback_threads�sz-FaultHandlerTests.test_dump_traceback_threadsc	Cs$t��}|j|�WdQRXdS)N)rr�)r*rr
r
r� test_dump_traceback_threads_file�sz2FaultHandlerTests.test_dump_traceback_threads_file�dump_traceback_laterz(need faulthandler.dump_traceback_later()Frc

Cs�ttjdt��}d}|jdtd|d|d|d|d|�}|j||�\}}	d	j|�}|s�|}
|r�|
d
9}
d|}tdd
|d|
�}|j||�n|j	|d�|j	|	d�dS)NZsecondsa�
            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()
            �timeout�repeat�cancel�loopsrr,rrKzATimeout \(%s\)!\nThread 0x[0-9a-f]+ \(most recent call first\):\n��rrr)
�str�datetimeZ	timedelta�TIMEOUTr7r3r9rr:r!)
r*r�r�r�rr,Ztimeout_strr+rur0�countrr
r
r
r�check_dump_traceback_later�s(		

z,FaultHandlerTests.check_dump_traceback_latercCs|j�dS)N)r�)r*r
r
r�test_dump_traceback_later#sz+FaultHandlerTests.test_dump_traceback_latercCs|jdd�dS)Nr�T)r�)r*r
r
r� test_dump_traceback_later_repeat&sz2FaultHandlerTests.test_dump_traceback_later_repeatcCs|jdd�dS)Nr�T)r�)r*r
r
r� test_dump_traceback_later_cancel)sz2FaultHandlerTests.test_dump_traceback_later_cancelc
Cs't��}|jd|�WdQRXdS)Nr)rr�)r*rr
r
r�test_dump_traceback_later_file,sz0FaultHandlerTests.test_dump_traceback_later_filec
Cs3tjd��}|jd|j��WdQRXdS)Nzwb+r,)rrTr�rU)r*r2r
r
r�test_dump_traceback_later_fd0sz.FaultHandlerTests.test_dump_traceback_later_fdcCs|jdd�dS)Nr�rK)r�)r*r
r
r�test_dump_traceback_later_twice6sz1FaultHandlerTests.test_dump_traceback_later_twice�registerzneed faulthandler.registerc
Cs�tj}d}|jd|d|d|d|d|d|�}|j||�\}}	dj|�}|s�|r{d	}
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)
            r<�signum�
unregister�chainrr,rz/Current thread XXX \(most recent call first\):
z"Stack \(most recent call first\):
rs� rr)	�signal�SIGUSR1r7r3r9rr:r!r;)r*rr<r�r�r,r�r+rur0r
r
r
r�check_register9s*	.			z FaultHandlerTests.check_registercCs|j�dS)N)r�)r*r
r
r�
test_register�szFaultHandlerTests.test_registercCs|jdd�dS)Nr�T)r�)r*r
r
r�test_unregister�sz!FaultHandlerTests.test_unregisterc
Cs't��}|jd|�WdQRXdS)Nr)rr�)r*rr
r
r�test_register_file�sz$FaultHandlerTests.test_register_filec
Cs3tjd��}|jd|j��WdQRXdS)Nzwb+r,)rrTr�rU)r*r2r
r
r�test_register_fd�sz"FaultHandlerTests.test_register_fdcCs|jdd�dS)Nr<T)r�)r*r
r
r�test_register_threads�sz'FaultHandlerTests.test_register_threadscCs|jdd�dS)Nr�T)r�)r*r
r
r�test_register_chain�sz%FaultHandlerTests.test_register_chainccs^tj}zDdt_|jt��}dVWdQRX|jt|j�d�Wd|t_XdS)Nzsys.stderr is None)rZr/ZassertRaises�RuntimeErrorr!r��	exception)r*r/�cmr
r
r�check_stderr_none�s		z#FaultHandlerTests.check_stderr_nonecCs�|j��tj�WdQRX|j��tj�WdQRXttd�rl|j��tjd�WdQRXttd�r�|j��tjtj�WdQRXdS)Nr�g����MbP?r�)	r�r\r]Zdump_traceback�hasattrr�r�r�r�)r*r
r
r�test_stderr_None�s



z"FaultHandlerTests.test_stderr_None);�__name__�
__module__�__qualname__r3r>�unittestZskipIfrZ�platform�
startswithrArBrCrE�	_testcapiZ
skipUnlessr�r�rHrJrMrN�HAVE_THREADSr\rOrPrSrVrWrYr_rmrnrprvrwrxryr~r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�rr�r�r
r
r
rr,s|%			
*
*
	
.<=Pr�__main__)�
contextlibrr�r\r$r'r�rirZZtestrZtest.supportrrr��textwrapr�	threadingr��ImportErrorr�r�rrZTestCaserr��mainr
r
r
r�<module>s:


	���