Sindbad~EG File Manager

Current Path : /usr/local/lib/python3.12/test/__pycache__/
Upload File :
Current File : //usr/local/lib/python3.12/test/__pycache__/test_faulthandler.cpython-312.opt-2.pyc

�

'Μg>y��b�ddlmZddlZddlZddlZddlZddlZddlZddlZddl	m
Z
ddlmZm
Z
mZmZddlZddlZddlmZ	ddlZe
j,sej.d��dZdd�Zd	�Zed
��ZGd�dej8�Zed
k(rej>�yy#e$rdZY�ewxYw)�)�contextmanagerN)�support)�	os_helper�
script_helper�
is_android�
MS_WINDOWS)�dedentztest module requires subprocessg�?c�b�|}|d|zz
}|d|zz
}d|krd|dz|dz
zz|zSd|zdzS)Nz#  File "<string>", line %s in func
z&  File "<string>", line %s in <module>��^�
�$�)�lineno1�lineno2�header�	min_count�regexs     �3/usr/local/lib/python3.12/test/test_faulthandler.py�expected_tracebackrsZ���E�	�
3�g�
=�=�E�	�
5��
?�?�E��9�}��e�d�l�y�1�}�5�5��=�=��U�{�S� � �c�B�tjtd�|�S)Nz(raising SIGSEGV on Android is unreliable)�unittest�skipIfr)�tests r�skip_segfault_on_androidr#s(��G�8�?�?�:�E�G�GK�M�Mrc#�K�tj�}	|��tj|�y#tj|�wxYw�w�N)�tempfile�mktempr�unlink��filenames r�temporary_filenamer$(s8������� �H�#�������"��	����"�s�A�2�A�A	�	Ac	��eZdZdPd�Zddddddddd�d�ZdQd�Zd	�Zeje	jjd
�d�d��Ze
d
��Ze
d��Zd�Zd�Zeje	jdk(d�d��Zejedud�ej(eed�d�e
d����Zejedud�ej(eed�d�e
d����Zd�Zd�Zd�Zeje	jjd�d�ejeed �d!�d"���Ze
d#��Ze
d$��Zeje	jdk(d%�e
d&���Z e
d'��Z!e
d(��Z"e
d)��Z#d*�Z$e%jL�d+��Z'e%jL�d,��Z(e%jL�d-��Z)ddd.�d/�Z*d0�Z+d1�Z,eje	jdk(d%�d2��Z-d3�Z.d4�Z/d5�Z0d6�Z1dRddd.�d7�Z2d8�Z3d9�Z4d:�Z5d;�Z6eje	jdk(d%�d<��Z7e%jpd=�d>��Z9ejeed?�d@�		dSdA��Z:dB�Z;dC�Z<dD�Z=eje	jdk(d%�dE��Z>dF�Z?dG�Z@eAdH��ZBdI�ZCej(eDdJ�dK��ZEej(eDdJ�dL��ZFej(eDdJ�dM��ZGej(eDdJ�dN��ZHdO�ZIy)T�FaultHandlerTestsNc��	t|�j�}g}|�|j|�ttj
�}d}t
j||�t
j�5tjd|||��}|5|j�\}}	|j�}
ddd�ddd�jdd�}|rJ|j|d�t|d�5}|j!�}ddd�|jdd�}nr|�p|j|d�t	j"|tj$d�t|dd	�
�5}|j!�}ddd�|jdd�}|j'�
fS#1swY��xYw#1swY��xYw#1swY��xYw#1swY�QxYw)Nz
handle_segv=0�-c)�pass_fds�env�ascii�backslashreplace��rbrF)�closefd)r	�strip�append�dict�os�environr�set_sanitizer_env_var�SuppressCrashReportr�spawn_python�communicate�wait�decode�assertEqual�open�read�lseek�SEEK_SET�
splitlines)�self�coder#�fdr)r*�option�process�output�stderr�exitcode�fps            r�
get_outputzFaultHandlerTests.get_output2s���	��d�|�!�!�#����
�>��O�O�B���2�:�:���!���%�%�c�6�2�
�
(�
(�
*�#�0�0��t�:B�58�:�G��!(�!4�!4�!6����"�<�<�>���	+����w�(:�;������V�R�(��h��%�������&��]�]�7�,>�?�F�
�^����V�R�(��H�H�R����a�(��b�$��.�"������/��]�]�7�,>�?�F�� � �"�H�,�,����	+�
*��&�%��/�.�s<�5F3�$F'�5F3�7F?�*G�'F0	�,F3�3F<�?G�GTFz<module>)r#�all_threads�other_regexrC�know_current_thread�py_fatal_error�garbage_collecting�functionc���	|r|rd}nd}nd}d|��g}
|	r|
jd�|
jd�|
j|�d��|
r|
jd�|
jd	|�d
|���dj|
�}
|r	d|
�d
|�d�}
d|
��}
|j|||��\}}dj|�}|j||
�|j	|d�y)NzCurrent thread 0x[0-9a-f]+zThread 0x[0-9a-f]+�Stackrz!Python runtime state: initializedr-z \(most recent call first\):z  Garbage-collectingz  File "<string>", line z in r
z(?:�|�)z(?m)�r#rCr)r1�joinrJ�assertRegex�assertNotEqual)rArB�lineno�fatal_errorr#rKrLrCrMrNrOrPrrrFrHs                r�check_errorzFaultHandlerTests.check_error[s��	��"�5��-���F��[�M�"�#����L�L�<�=�
���R��
����� <�=�>���L�L�/�0�
���0����X�J�G�H��	�	�%� ����%���+��a�0�E��u�g����?�?�4�(�r�?�J�������6�"�������'����H�a�(rc�J�|r|�d|��}d|z}|j|||fi|��y)Nz: zFatal Python error: %s�r[)rArB�line_number�
name_regex�func�kwrZs       r�check_fatal_errorz#FaultHandlerTests.check_fatal_error�s2���%)�:�6�J�.��;�������{�K�>�2�>rc�8�d|z}|j|||fi|��y)NzWindows fatal exception: %sr])rArBr^r_rarZs      r�check_windows_exceptionz)FaultHandlerTests.check_windows_exception�s%��3�j�@�������{�K�>�2�>r�aixz5the first page of memory is a mapped read-only on AIXc�^�ts|jddd�y|jddd�y)Nz�
                import faulthandler
                faulthandler.enable()
                faulthandler._read_null()
                �z4(?:Segmentation fault|Bus error|Illegal instruction)�access violation)rrbrd�rAs r�test_read_nullz FaultHandlerTests.test_read_null�sA����"�"�$�
�,�	
-�
�(�(�*�
�"�

$rc�*�|jddd�y)Nzs
            import faulthandler
            faulthandler.enable()
            faulthandler._sigsegv()
            rg�Segmentation fault�rbris r�test_sigsegvzFaultHandlerTests.test_sigsegv������� �

� �
	"rc�0�|jddddd��y)Na�
            import faulthandler
            import gc
            import sys

            faulthandler.enable()

            class RefCycle:
                def __del__(self):
                    faulthandler._sigsegv()

            # create a reference cycle which triggers a fatal
            # error in a destructor
            a = RefCycle()
            b = RefCycle()
            a.b = b
            b.a = a

            # Delete the objects, not the cycle
            a = None
            b = None

            # Break the reference cycle: call __del__()
            gc.collect()

            # Should not reach this line
            print("exit", file=sys.stderr)
            �	rl�__del__T)rPrOrmris r�test_gczFaultHandlerTests.test_gc�s*��	
��� �8
� ��#�?	�	%rc�2�|jdddddd��y)Nz�
            import faulthandler
            faulthandler.enable()
            faulthandler._fatal_error_c_thread()
            rgz
in new threadF�faulthandler_fatal_error_threadT)rMr`rNrmris r�test_fatal_error_c_threadz+FaultHandlerTests.test_fatal_error_c_thread�s+����� �

�� %�2��	�		!rc�*�|jddd�y)Nzs
            import faulthandler
            faulthandler.enable()
            faulthandler._sigabrt()
            rg�Abortedrmris r�test_sigabrtzFaultHandlerTests.test_sigabrt�s����� �

��
	r�win32z"SIGFPE cannot be caught on Windowsc�*�|jddd�y)Nzr
            import faulthandler
            faulthandler.enable()
            faulthandler._sigfpe()
            rgzFloating-point exceptionrmris r�test_sigfpezFaultHandlerTests.test_sigfpe�s��	
��� �

�&�
	(rzneed _testcapi�SIGBUSzneed signal.SIGBUSc�*�|jddd�y)Nz�
            import faulthandler
            import signal

            faulthandler.enable()
            signal.raise_signal(signal.SIGBUS)
            �z	Bus errorrmris r�test_sigbuszFaultHandlerTests.test_sigbus�s��	
��� �
��	r�SIGILLzneed signal.SIGILLc�*�|jddd�y)Nz�
            import faulthandler
            import signal

            faulthandler.enable()
            signal.raise_signal(signal.SIGILL)
            rzIllegal instructionrmris r�test_sigillzFaultHandlerTests.test_sigill�s��	
��� �
�!�	#rc��tj�5|jd|�d�dddd��ddd�y#1swYyxYw)NzP
                import _testcapi
                _testcapi.fatal_error(b'xyz', �)
                ��xyz�_testcapi_fatal_error_implT)r`rN)rr6rb)rA�release_gils  r�check_fatal_error_funcz(FaultHandlerTests.check_fatal_error_func
sO��
�
(�
(�
*��"�"�(/�/:�m�<�$���1�#�
#�
%�+�
*�
*�s	�9�Ac�&�|jd�y)NF�r�ris r�test_fatal_errorz"FaultHandlerTests.test_fatal_errors���#�#�E�*rc�&�|jd�y)NTr�ris r�test_fatal_error_without_gilz.FaultHandlerTests.test_fatal_error_without_gils���#�#�D�)r�openbsdzVIssue #12868: sigaltstack() doesn't work on OpenBSD if Python is compiled with pthread�_stack_overflowz#need faulthandler._stack_overflow()c�.�|jdddd��y)Nzz
            import faulthandler
            faulthandler.enable()
            faulthandler._stack_overflow()
            rgz (?:Segmentation fault|Bus error)z unable to raise a stack overflow)rLrmris r�test_stack_overflowz%FaultHandlerTests.test_stack_overflows'��	
��� �

�.�:�	�	<rc�*�|jddd�y)Nzw
            import faulthandler
            faulthandler.enable()
            faulthandler._sigsegv(True)
            rgrlrmris r�test_gil_releasedz#FaultHandlerTests.test_gil_released.rorc��t�5}|jdjt|���dd|��ddd�y#1swYyxYw)Nz�
                import faulthandler
                output = open({filename}, 'wb')
                faulthandler.enable(output)
                faulthandler._sigsegv()
                r"�rl)r$rb�format�repr�rAr#s  r�test_enable_filez"FaultHandlerTests.test_enable_file8sI��
�
!�X��"�"�$�
�F�D��N�F�3��$�!�
#�
#�"�
!�
!�s�/A�Az.subprocess doesn't support pass_fds on Windowsc��tjd�5}|j�}|jd|zdd|��ddd�y#1swYyxYw)N�wb+z�
                import faulthandler
                import sys
                faulthandler.enable(%s)
                faulthandler._sigsegv()
                r�rl�rC)r�
TemporaryFile�filenorb)rArIrCs   r�test_enable_fdz FaultHandlerTests.test_enable_fdEsX���
#�
#�E�
*�b�����B��"�"�$�
�$��$��
#�
�+�
*�
*�s�)A�Ac�.�|jdddd��y)Nz�
            import faulthandler
            faulthandler.enable(all_threads=False)
            faulthandler._sigsegv()
            rgrlF�rKrmris r�test_enable_single_threadz+FaultHandlerTests.test_enable_single_threadUs%����� �

� ��	�	rc��d}d}|j|�\}}dj|�}|j||v|�d|���|j|d�y)Nz�
            import faulthandler
            faulthandler.enable()
            faulthandler.disable()
            faulthandler._sigsegv()
            zFatal Python errorr
z is present in r)rJrV�
assertTruerX)rArB�not_expectedrGrHs     r�test_disablezFaultHandlerTests.test_disable`s]����,���?�?�4�0�������6�"������F�2�.:�F�C�	E����H�a�(rc�h�d}|j|�\}}dj|�}tjd|tj�}|s|jd|���t
|jd�j�jd��}dD]}|j||��y)Nz�
            import faulthandler
            import sys
            # Don't filter stdlib module names
            sys.stdlib_module_names = frozenset()
            faulthandler.enable()
            faulthandler._sigsegv()
            r
z*^Extension modules:(.*) \(total: [0-9]+\)$z$Cannot find 'Extension modules:' in rz, )�sys�faulthandler)rJrV�re�search�	MULTILINE�fail�set�groupr0�split�assertIn)rArBrGrH�match�modules�names       r�test_dump_ext_modulesz'FaultHandlerTests.test_dump_ext_modulesos����� �?�?�4�0�������6�"���	�	�G� �"�,�,�0����I�I�<�V�J�G�H��e�k�k�!�n�*�*�,�2�2�4�8�9��+�D��M�M�$��(�,rc�L�tj}	tjt_tj�}	tj
�|j
tj��tj�|jtj��|rtj
�ntj�	|t_y#|rtj
�wtj�wxYw#|t_wxYwr)	r�rG�
__stderr__r��
is_enabled�enabler��disable�assertFalse)rA�orig_stderr�was_enableds   r�test_is_enabledz!FaultHandlerTests.test_is_enabled�s����j�j��	%����C�J�&�1�1�3�K�	
+��#�#�%����� 7� 7� 9�:��$�$�&�� � ��!8�!8�!:�;�� �'�'�)� �(�(�*�$�C�J��� �'�'�)� �(�(�*��$�C�J�s$�-D�A.C&�.,D�&-D�D�
D#c��d}tjdd|f}tj|�}|j	|j�d�y)N�5import faulthandler; print(faulthandler.is_enabled())�-Er(�False)r��
executable�
subprocess�check_outputr;�rstrip)rArB�argsrFs    r�test_disabled_by_defaultz*FaultHandlerTests.test_disabled_by_default�sB��G������d�D�1���(�(��.���������(�3rc	�N�d}tdtjtjjrdndddd|f�}t
jj�}|jdd�tj||��}|j|j�d	�y)
Nr�r�r-z-Xr�r(�PYTHONFAULTHANDLER�r*�True)
�filterr�r��flags�ignore_environmentr3r4�copy�popr�r�r;r��rArBr�r*rFs     r�test_sys_xoptionsz#FaultHandlerTests.test_sys_xoptions�s���G���d�S�^�^�%(�Y�Y�%A�%A�T�r�!�>�4��?�@���j�j�o�o������$�d�+��(�(��3�7���������'�2rc��d}tjd|f}ttj�}d|d<d|d<tj||��}|j|j�d�ttj�}d|d<d|d<tj||��}|j|j�d	�y)
Nr�r(r-r��
PYTHONDEVMODEr�r��1r�)	r�r�r2r3r4r�r�r;r�r�s     r�test_env_varzFaultHandlerTests.test_env_var�s���G������d�+���2�:�:���$&�� �!�!��O���(�(��3�7���������(�3��2�:�:���$'�� �!�!��O���(�(��3�7���������'�2rrUc���	d}|j||��}|rd}n|�d}nd}dd|zdd	g}|j|||�\}}|j||�|j|d
�y)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()
            rUrq���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�rJr;)rAr#rCrBrY�expected�tracerHs        r�check_dump_tracebackz&FaultHandlerTests.check_dump_traceback�s���	���*�{�{����
����F�
�^��F��F�-�1�F�:�1�4�	
���/�/�$��"�=���x������)�����1�%rc�$�|j�yr)r�ris r�test_dump_tracebackz%FaultHandlerTests.test_dump_traceback�s���!�!�#rc�f�t�5}|j|��ddd�y#1swYyxYw�Nr")r$r�r�s  r�test_dump_traceback_filez*FaultHandlerTests.test_dump_traceback_file�s'��
�
!�X��%�%�x�%�8�"�
!�
!���'�0c��tjd�5}|j|j���ddd�y#1swYyxYw�Nr�r�)rr�r�r��rArIs  r�test_dump_traceback_fdz(FaultHandlerTests.test_dump_traceback_fd�s7���
#�
#�E�
*�b��%�%�����%�5�+�
*�
*���!A�A	c���d}d|dzz}d|zdz}d}|j|��}dd|zd	g}|j|�\}}|j||�|j|d
�y)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�)rA�maxlenr��	truncatedrBr�r�rHs        r�
test_truncatezFaultHandlerTests.test_truncate�s������6�B�;�'�	��&�L�5�(�	����{�{���
��
.�-�	�9�3�
��
�/�/�$�/���x������)�����1�%rc�8�	d}|jt|���}|j||�\}}dj|�}|rd}nd}d}t	|j|���j�}|j
||�|j|d�y)	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()
            r"r
��
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>$
            )rYr)r�r�rJrVr	r0rWr;)rAr#rBrFrHrYrs       r�check_dump_traceback_threadsz.FaultHandlerTests.check_dump_traceback_threadss���	���@�{�{�D��N�{�3���?�?�4��:�������6�"����F��F�
���u�|�|�6�|�2�3�9�9�;�������'�����1�%rc�&�|jd�yr)r�ris r�test_dump_traceback_threadsz-FaultHandlerTests.test_dump_traceback_threadsPs���)�)�$�/rc�d�t�5}|j|�ddd�y#1swYyxYwr)r$r�r�s  r� test_dump_traceback_threads_filez2FaultHandlerTests.test_dump_traceback_threads_fileSs$��
�
!�X��-�-�h�7�"�
!�
!�s�&�/c�~�	ttjt���}d}|j	t|||||��}|j||�\}}	dj
|�}|s0|}
|r|
dz}
d|z}tdd||
�	�}|j||�n|j|d
�|j|	d�y)N)�secondsa�
            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�loopsr#rCr
r�zATimeout \(%s\)!\nThread 0x[0-9a-f]+ \(most recent call first\):\n��)rr-r)
�str�datetime�	timedelta�TIMEOUTr�rJrVrrWr;)
rAr�rrr#rC�timeout_strrBr�rH�countrrs
             r�check_dump_traceback_laterz,FaultHandlerTests.check_dump_traceback_laterWs���	��(�,�,�W�=�>����<�{�{�������
�
���/�/�$��9���x��	�	�%� ����E����
��Y�\g�g�F�&�r�2�v��G�E����U�E�*����U�B�'�����1�%rc�$�|j�yr�r
ris r�test_dump_traceback_laterz+FaultHandlerTests.test_dump_traceback_later�s���'�'�)rc�(�|jd��y)NT)r�rris r� test_dump_traceback_later_repeatz2FaultHandlerTests.test_dump_traceback_later_repeat�����'�'�t�'�4rc�(�|jd��y)NT)rrris r� test_dump_traceback_later_cancelz2FaultHandlerTests.test_dump_traceback_later_cancel�rrc�f�t�5}|j|��ddd�y#1swYyxYwr�)r$r
r�s  r�test_dump_traceback_later_filez0FaultHandlerTests.test_dump_traceback_later_file�s'��
�
!�X��+�+�X�+�>�"�
!�
!�r�c��tjd�5}|j|j���ddd�y#1swYyxYwr�)rr�r
r�r�s  r�test_dump_traceback_later_fdz.FaultHandlerTests.test_dump_traceback_later_fd�s7���
#�
#�E�
*�b��+�+�r�y�y�{�+�;�+�
*�
*�r��walltimec�(�|jd��y)Nr�)rrris r�test_dump_traceback_later_twicez1FaultHandlerTests.test_dump_traceback_later_twice�s���'�'�a�'�0r�registerzneed faulthandler.registerc�h�	tj}d}|j||||||��}|j||�\}}	dj	|�}|s'|rd}
nd}
tdd|
�}
|j
||
�n|j|d�|r|j|	d	�y|j|	d	�y)
Naz
            import faulthandler
            import os
            import signal
            import sys

            all_threads = {all_threads}
            signum = {signum:d}
            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)
            )rK�signum�
unregister�chainr#rCr
z8Current thread 0x[0-9a-f]+ \(most recent call first\):\nz#Stack \(most recent call first\):\nr�� r-r)	�signal�SIGUSR1r�rJrVrrWr;rX)rAr#rKrrrCrrBr�rHrs           r�check_registerz FaultHandlerTests.check_register�s���	�����-��\�{�{�#��!����
�
���/�/�$��9���x��	�	�%� ����S��>��&�r�2�u�5�E����U�E�*����U�B�'������!�,����X�q�)rc�$�|j�yr�r"ris r�
test_registerzFaultHandlerTests.test_register�s�����rc�(�|jd��y)NT)rr$ris r�test_unregisterz!FaultHandlerTests.test_unregisters�����t��,rc�f�t�5}|j|��ddd�y#1swYyxYwr�)r$r"r�s  r�test_register_filez$FaultHandlerTests.test_register_files'��
�
!�X������2�"�
!�
!�r�c��tjd�5}|j|j���ddd�y#1swYyxYwr�)rr�r"r�r�s  r�test_register_fdz"FaultHandlerTests.test_register_fd	s7���
#�
#�E�
*�b����2�9�9�;��/�+�
*�
*�r�c�(�|jd��y)NTr�r$ris r�test_register_threadsz'FaultHandlerTests.test_register_threadss�������-rc�(�|jd��y)NT)rr$ris r�test_register_chainz%FaultHandlerTests.test_register_chains�����$��'rc#� K�tj}	dt_|jt�5}d��ddd�|j	tj�d�|t_y#1swY�:xYw#|t_wxYw�w)Nzsys.stderr is None)r�rG�assertRaises�RuntimeErrorr;r�	exception)rArG�cms   r�check_stderr_nonez#FaultHandlerTests.check_stderr_nonesf��������	 ��C�J��"�"�<�0�B��1����S����.�0D�E��C�J�	1�0�� �C�J�s2�B� A>�A2�-A>�&B�2A;�7A>�>
B�Bc��|j�5tj�ddd�|j�5tj�ddd�|j�5tjd�ddd�ttd�r=|j�5tjtj�ddd�yy#1swY��xYw#1swY��xYw#1swY�oxYw#1swYyxYw)Ng����MbP?r)	r5r�r��dump_traceback�dump_traceback_later�hasattrrr r!ris r�test_stderr_Nonez"FaultHandlerTests.test_stderr_None s����
#�
#�
%����!�&�
�
#�
#�
%��'�'�)�&�
�
#�
#�
%��-�-�d�3�&��<��,��'�'�)��%�%�f�n�n�5�*�)�-�
&�
%��
%�
%��
%�
%��*�)�s.�C�C#�+C/�)$C;�C �#C,�/C8�;Dzspecific to Windowsc�F�dD]\}}|jd|�d�d|��y)N))�EXCEPTION_ACCESS_VIOLATIONrh)�EXCEPTION_INT_DIVIDE_BY_ZEROzint divide by zero)�EXCEPTION_STACK_OVERFLOWzstack overflowz�
                import faulthandler
                faulthandler.enable()
                faulthandler._raise_exception(faulthandler._r�rg)rd)rA�excr�s   r�test_raise_exceptionz&FaultHandlerTests.test_raise_exception-sB��
�I�C��

�(�(�.=�>A�E�B�*�
��

�
rc��dD]K}d|�d�}t|�}|j|�\}}|j|g�|j||��My)N)lcs�@lRC�@z�
                    import faulthandler
                    faulthandler.enable()
                    faulthandler._raise_exception(z)
                    �r	rJr;)rA�exc_coderBrFrHs     r�test_ignore_exceptionz'FaultHandlerTests.test_ignore_exception<sd��
�H�3�4<�*�=��D�
�$�<�D�#���t�4��F�H����V�R�(����X�x�0�
rc��dD]D}|jd|d�d��\}}|j|g�|j|||dzf��Fy)N)ri�xV4i@i@ipi���z{
                import faulthandler
                faulthandler.enable()
                faulthandler._raise_exception(0xr�r�i����)rJr;r�)rAr?rFrHs    r�test_raise_nonfatal_exceptionz/FaultHandlerTests.test_raise_nonfatal_exceptionLsj��
�C� $���41�25�Q��8�0� ��F�H�
���V�R�(�
�M�M�(���k� 1�2�
4�#
rc��td�}|j|�\}}|j|g�|j|d�y)Nz�
            import faulthandler
            faulthandler.enable()
            faulthandler.disable()
            code = faulthandler._EXCEPTION_ACCESS_VIOLATION
            faulthandler._raise_exception(code)
        lrB�rArBrFrHs    r� test_disable_windows_exc_handlerz2FaultHandlerTests.test_disable_windows_exc_handlerhsF����
�� �?�?�4�0���������$�����:�.rc��td�}|j|�\}}|j|g�|j|d�y)Nz`
            import faulthandler
            faulthandler.cancel_dump_traceback_later()
        rrBrHs    r�.test_cancel_later_without_dump_traceback_laterz@FaultHandlerTests.test_cancel_later_without_dump_traceback_laterusH����
�� �?�?�4�0���������$�����1�%r)NNr)FFr)FFFFN)J�__name__�
__module__�__qualname__rJr[rbrdrrr��platform�
startswithrjrrnrsrvryr|�	_testcapi�
skipUnlessr9r r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�requires_subprocessr�r�r�r�r�r�r�r�r�r�r�r
r
rrrr�requires_resourcerr"r%r'r)r+r-r/rr5r:rr@rDrFrIrKrrrr&r&0s���'-�T"�t����#(�',�'�%)�N?�?��X�_�_�S�\�\�,�,�U�3�L�N�$�N�$�*�"��"��!%��!%�F
!���X�_�_�S�\�\�W�,�9�;�(�;�(��X�_�_�Y�$�&�(8�9��X������2�4H�I��	��J�:�	��X�_�_�Y�$�&�(8�9��X������2�4H�I��	#��J�:�	#�
%�+�*��X�_�_�S�\�\�,�,�Y�7�B�C��X�_�_���/@�A�A�:�<�<�<�C�
<��"��"��
#��
#��X�_�_�S�\�\�W�,�E�G����G�������)��)��)��)�&%�,!�W� � �"�4�#�4�!�W� � �"�
3�#�
3�!�W� � �"�3�#�3�$04��,&�\$�9��X�_�_�S�\�\�W�,�E�G�6�G�6�&�09&�v0�8�<&�/3��<&�|*�5�5�?��X�_�_�S�\�\�W�,�E�G�<�G�<��W���z�*�1�+�1��X�_�_���z�:�:�1�3�9>�9=�O*�3�O*�b�-�3��X�_�_�S�\�\�W�,�E�G�0�G�0�.�(�� �� �6��X����%:�;��<���X����%:�;�
1�<�
1��X����%:�;�4�<�4�6�X����%:�;�
/�<�
/�	&rr&�__main__)r) �
contextlibrrr�r3r�r r�r�rr�test.supportrrrrrr�textwrapr	rQ�ImportError�has_subprocess_support�SkipTestrrrr$�TestCaser&rL�mainrrr�<module>r^s���%���	�	�
��
��I�I�������%�%�
�(�
�
�=�
>�>�

��!�M�
�#��#�N
&��)�)�N
&�b�z���H�M�M�O���a���I��s�B$�$B.�-B.

Sindbad File Manager Version 1.0, Coded By Sindbad EG ~ The Terrorists