403Webshell
Server IP : 121.121.20.254  /  Your IP : 216.73.216.202
Web Server : Microsoft-IIS/10.0
System : Windows NT WEB-SERVER 10.0 build 20348 (Windows Server 2022) AMD64
User : IUSR ( 0)
PHP Version : 8.3.28
Disable Function : NONE
MySQL : ON  |  cURL : ON  |  WGET : OFF  |  Perl : OFF  |  Python : OFF  |  Sudo : OFF  |  Pkexec : OFF
Directory :  /Python313/Lib/test/__pycache__/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Command :


[ Back ]     

Current File : /Python313/Lib/test/__pycache__/test_faulthandler.cpython-313.pyc
�

��i����v�SSKJr SSKrSSKrSSKrSSKrSSKrSSKrSSKrSSK	J
r
 SSKJrJ
r
JrJrJr SSKrSSKrSSKJr SSKr\
R.(d\R0"S5eSrSSjrS	r\S
5r"SS\R:5r\S
:Xa\R@"5 gg!\a SrNmf=f)�)�contextmanagerN)�support)�	os_helper�
script_helper�
is_android�
MS_WINDOWS�threading_helper)�dedentztest module requires subprocessg�?c�d�UnUSU--
nUSU--
nSU:aSUS-US-
--U-$SU-S-$)Nz#  File "<string>", line %s in func
z&  File "<string>", line %s in <module>��^�
�$�)�lineno1�lineno2�header�	min_count�regexs     �+C:\Python313\\Lib\test\test_faulthandler.py�expected_tracebackrsZ���E�	�
3�g�
=�=�E�	�
5��
?�?�E��9�}��e�d�l�y�1�}�5�5��=�=��U�{�S� � �c�D�[R"[S5"U5$)Nz(raising SIGSEGV on Android is unreliable)�unittest�skipIfr)�tests r�skip_segfault_on_androidr#s#���?�?�:�E�G�GK�M�Mrc#�# �[R"5nUv� [R"U5 g![R"U5 f=f7f�N)�tempfile�mktempr�unlink��filenames r�temporary_filenamer%(s7������ �H�#�������"��	����"�s�A�4�A�A�Ac	�p�\rSrSrSTSjrSSSSSSSSS.SjrSUS	jrS
r\R"\
RRS5S5S
5r
\S5r\S5rSrSr\R"\
RS:HS5S5r\R"\SLS5\R*"\"\S5S5\S555r\R"\SLS5\R*"\"\S5S5\S555r\R"\SLS5S5rSrSr\R"\
RRS5S 5\R"\"\S!5(+S"5S#55r\S$5r\S%5r \R"\
RS:HS&5\S'55r!\S(5r"\S)5r#\S*5r$S+r%\&RN"5S,5r(\&RN"5S-5r)\&RN"5S.5r*SSS/.S0jr+S1r,S2r-\R"\
RS:HS&5S35r.S4r/S5r0S6r1S7r2SVSSS/.S8jjr3S9r4S:r5S;r6S<r7\R"\
RS:HS&5S=5r8\&Rr"S>5S?5r:\R"\"\S@5(+SA5SWSBj5r;SCr<SDr=SEr>\R"\
RS:HS&5SF5r?SGr@SHrA\BSI5rCSJrD\R*"\ESK5SL5rF\R*"\ESK5SM5rG\R*"\ESK5SN5rH\R*"\ESK5SO5rISPrJ\KR�"5\R*"\&R�SQ5SR55rNSSrOg)X�FaultHandlerTests�0Nc���[U5R5n/nUbURU5 [[R
5nSn[R"XV5 [R"5 [R"SUUUS9nU UR5up�UR5n
SSS5 SSS5 WRSS5nU(aJURUS5 [US5nUR!5nSSS5 URSS5nOqUbnURUS5 [R""U[R$S	5 [USS
S9nUR!5nSSS5 URSS5nUR'5W
4$!,(df   N�=f!,(df   GN=f!,(df   N�=f!,(df   Nf=f)aC
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
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_output�FaultHandlerTests.get_output2s����d�|�!�!�#����
�>��O�O�B���2�:�:���!���%�%�c�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<�6F:�#F)�3F:�:G�,G�)
F7	�3F:�:
G	�
G�
G+TFz<module>)r$�all_threads�other_regexrE�know_current_thread�py_fatal_error�garbage_collecting�functionc���U(a
U(aSnOSnOSnSU3/n
U	(aU
RS5 U
RS5 U
RUS35 U
(aU
RS5 U
RS	US
U35 SRU
5n
U(a	SU
S
US3n
SU
3n
URXUS9up�SRU5nURX�5 UR	US5 g)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]+�Stackr
z!Python runtime state: initializedr/z \(most recent call first\):z  Garbage-collectingz  File "<string>", line z in rz(?:�|�)z(?m)�r$rErN)r3�joinrL�assertRegex�assertNotEqual)rCrD�lineno�fatal_errorr$rNrOrErPrQrRrSrrrHrJs                r�check_error�FaultHandlerTests.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�V�U(a	U<SU<3nSU-nUR"XU40UD6 g)Nz: zFatal Python error: %s�r^)rCrD�line_number�
name_regex�func�kwr]s       r�check_fatal_error�#FaultHandlerTests.check_fatal_error�s.���%)�:�6�J�.��;������K�>�2�>rc�6�SU-nUR"XU40UD6 g)NzWindows fatal exception: %sra)rCrDrbrcrer]s      r�check_windows_exception�)FaultHandlerTests.check_windows_exception�s!��3�j�@������K�>�2�>r�aixz5the first page of memory is a mapped read-only on AIXc�h�[(dURSSS5 gURSSS5 g)Nz�
                import faulthandler
                faulthandler.enable()
                faulthandler._read_null()
                �z4(?:Segmentation fault|Bus error|Illegal instruction)�access violation)rrfri�rCs r�test_read_null� FaultHandlerTests.test_read_null�sC���z��"�"�$�
�,�	
-�
�(�(�*�
�"�

$rc�*�URSSS5 g)Nzs
            import faulthandler
            faulthandler.enable()
            faulthandler._sigsegv()
            rm�Segmentation fault�rfros r�test_sigsegv�FaultHandlerTests.test_sigsegv������� �

� �
	"rc�*�URSSSSSS9 g)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)
            �	rs�__del__T)rSrRrtros r�test_gc�FaultHandlerTests.test_gc�s*��	
��� �8
� ��#�?	�	%rc	�,�URSSSSSSS9 g)Nz�
            import faulthandler
            faulthandler.enable()
            faulthandler._fatal_error_c_thread()
            rmz
in new threadF�faulthandler_fatal_error_threadT)rPrdrQrtros r�test_fatal_error_c_thread�+FaultHandlerTests.test_fatal_error_c_thread�s+����� �

�� %�2��	�		!rc�*�URSSS5 g)Nzs
            import faulthandler
            faulthandler.enable()
            faulthandler._sigabrt()
            rm�Abortedrtros r�test_sigabrt�FaultHandlerTests.test_sigabrt�s����� �

��
	r�win32z"SIGFPE cannot be caught on Windowsc�*�URSSS5 g)Nzr
            import faulthandler
            faulthandler.enable()
            faulthandler._sigfpe()
            rmzFloating-point exceptionrtros r�test_sigfpe�FaultHandlerTests.test_sigfpe�s��	
��� �

�&�
	(rzneed _testcapi�SIGBUSzneed signal.SIGBUSc�*�URSSS5 g)Nz�
            import faulthandler
            import signal

            faulthandler.enable()
            signal.raise_signal(signal.SIGBUS)
            �z	Bus errorrtros r�test_sigbus�FaultHandlerTests.test_sigbus�s��	
��� �
��	r�SIGILLzneed signal.SIGILLc�*�URSSS5 g)Nz�
            import faulthandler
            import signal

            faulthandler.enable()
            signal.raise_signal(signal.SIGILL)
            r�zIllegal instructionrtros r�test_sigill�FaultHandlerTests.test_sigill�s��	
��� �
�!�	#rc	��[R"5 URSUS3SSSSS9 SSS5 g!,(df   g=f)NzP
                import _testcapi
                _testcapi.fatal_error(b'xyz', �)
                ��xyz�_testcapi_fatal_error_implT)rdrQ)rr8rf)rC�release_gils  r�check_fatal_error_func�(FaultHandlerTests.check_fatal_error_func
sQ���
(�
(�
*��"�"�(/�/:�m�<�$���1�#�
#�
%�+�
*�
*�s	�7�
Ac�&�URS5 g)NF�r�ros r�test_fatal_error�"FaultHandlerTests.test_fatal_errors���#�#�E�*rc�&�URS5 g)NTr�ros r�test_fatal_error_without_gil�.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�(�URSSSSS9 g)Nzz
            import faulthandler
            faulthandler.enable()
            faulthandler._stack_overflow()
            rmz (?:Segmentation fault|Bus error)z unable to raise a stack overflow)rOrtros r�test_stack_overflow�%FaultHandlerTests.test_stack_overflow s'��	
��� �

�.�:�	�	<rc�*�URSSS5 g)Nzw
            import faulthandler
            faulthandler.enable()
            faulthandler._sigsegv(True)
            rmrsrtros r�test_gil_released�#FaultHandlerTests.test_gil_released/rwrc��[5nURSR[U5S9SSUS9 SSS5 g!,(df   g=f)Nz�
                import faulthandler
                output = open({filename}, 'wb')
                faulthandler.enable(output)
                faulthandler._sigsegv()
                r#�rs)r%rf�format�repr�rCr$s  r�test_enable_file�"FaultHandlerTests.test_enable_file9sI��
�
!�X��"�"�$�
�F�D��N�F�3��$�!�
#�
#�"�
!�
!�s	�)=�
Az.subprocess doesn't support pass_fds on Windowsc��[R"S5nUR5nURSU-SSUS9 SSS5 g!,(df   g=f)N�wb+z�
                import faulthandler
                import sys
                faulthandler.enable(%s)
                faulthandler._sigsegv()
                r�rs�rE)r �
TemporaryFile�filenorf)rCrKrEs   r�test_enable_fd� FaultHandlerTests.test_enable_fdFsX���
#�
#�E�
*�b�����B��"�"�$�
�$��$��
#�
�+�
*�
*�s�&A�
Ac�(�URSSSSS9 g)Nz�
            import faulthandler
            faulthandler.enable(all_threads=False)
            faulthandler._sigsegv()
            rmrsF�rNrtros r�test_enable_single_thread�+FaultHandlerTests.test_enable_single_threadVs%����� �

� ��	�	rc��SnSnURU5up4SRU5nURX#;U<SU<35 URUS5 g)Nz�
            import faulthandler
            faulthandler.enable()
            faulthandler.disable()
            faulthandler._sigsegv()
            zFatal Python errorrz is present in r)rLrY�
assertTruer[)rCrD�not_expectedrIrJs     r�test_disable�FaultHandlerTests.test_disableasY����,���?�?�4�0������6�"������2�.:�F�C�	E����H�a�(rc�v�SnURU5up#SRU5n[R"SU[R5nU(dURSU<35 [
URS5R5RS55nSHnURXe5 M g)Nz�
            import faulthandler
            import sys
            # Don't filter stdlib module names
            sys.stdlib_module_names = frozenset()
            faulthandler.enable()
            faulthandler._sigsegv()
            rz*^Extension modules:(.*) \(total: [0-9]+\)$z$Cannot find 'Extension modules:' in rz, )�sys�faulthandler)rLrY�re�search�	MULTILINE�fail�set�groupr2�split�assertIn)rCrDrIrJ�match�modules�names       r�test_dump_ext_modules�'FaultHandlerTests.test_dump_ext_modulesps����� �?�?�4�0������6�"���	�	�G� �"�,�,�0����I�I�<�V�J�G�H��e�k�k�!�n�*�*�,�2�2�4�8�9��+�D��M�M�$�(�,rc�r�[Rn[R[l[R"5n[R
"5 UR
[R"55 [R"5 UR[R"55 U(a[R
"5 O[R"5 U[lg!U(a[R
"5 f[R"5 f=f!U[lf=fr)	r�rI�
__stderr__r��
is_enabled�enabler��disable�assertFalse)rC�orig_stderr�was_enableds   r�test_is_enabled�!FaultHandlerTests.test_is_enabled�s����j�j��	%����C�J�&�1�1�3�K�	
+��#�#�%����� 7� 7� 9�:��$�$�&�� � ��!8�!8�!:�;�� �'�'�)� �(�(�*�$�C�J��� �'�'�)� �(�(�*��$�C�J�s$�.D)�A2C2�33D)�24D&�&D)�)
D6c��Sn[RSSU4n[R"U5nUR	UR5S5 g)N�5import faulthandler; print(faulthandler.is_enabled())�-Er*�False)r��
executable�
subprocess�check_outputr=�rstrip)rCrD�argsrHs    r�test_disabled_by_default�*FaultHandlerTests.test_disabled_by_default�sB��G������d�D�1���(�(��.���������(�3rc	�R�Sn[S[R[RR(aSOSSSSU45n[
RR5nURSS5 [R"X#S9nURUR5S	5 g)
Nr�r�r/z-Xr�r*�PYTHONFAULTHANDLER�r,�True)
�filterr�r��flags�ignore_environmentr5r6�copy�popr�r�r=r��rCrDr�r,rHs     r�test_sys_xoptions�#FaultHandlerTests.test_sys_xoptions�s���G���d�S�^�^�%(�Y�Y�%A�%A�T�r�!�>�4��?�@���j�j�o�o������$�d�+��(�(��7���������'�2rc��Sn[RSU4n[[R5nSUS'SUS'[
R"X#S9nURUR5S5 [[R5nSUS'SUS'[
R"X#S9nURUR5S	5 g)
Nr�r*r/r��
PYTHONDEVMODEr�r��1r�)	r�r�r4r5r6r�r�r=r�r�s     r�test_env_var�FaultHandlerTests.test_env_var�s���G������d�+���2�:�:���$&�� �!�!��O���(�(��7���������(�3��2�:�:���$'�� �!�!��O���(�(��7���������'�2rrXc���SnURUUS9nU(aSnOUbSnOSnSSU-S	S
/nURX1U5upgURXe5 URUS5 g)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()
            rXryN���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�rLr=)rCr$rErDr\�expected�tracerJs        r�check_dump_traceback�&FaultHandlerTests.check_dump_traceback�s���
��*�{�{����
����F�
�^��F��F�-�1�F�:�1�4�	
���/�/�$�"�=�������)�����1�%rc�$�UR5 gr)r�ros r�test_dump_traceback�%FaultHandlerTests.test_dump_traceback�s���!�!�#rc�j�[5nURUS9 SSS5 g!,(df   g=f�Nr#)r%r�r�s  r�test_dump_traceback_file�*FaultHandlerTests.test_dump_traceback_file�s'��
�
!�X��%�%�x�%�8�"�
!�
!���$�
2c��[R"S5nURUR5S9 SSS5 g!,(df   g=f�Nr�r�)r r�r�r��rCrKs  r�test_dump_traceback_fd�(FaultHandlerTests.test_dump_traceback_fd�s7���
#�
#�E�
*�b��%�%�����%�5�+�
*�
*��	�>�
Ac���SnSUS--nSU-S-nSnURUS9nSSU-S	/nURU5upgURXe5 URUS
5 g)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�)rC�maxlenr�	truncatedrDr�r�rJs        r�
test_truncate�FaultHandlerTests.test_truncate�s������6�B�;�'�	��&�L�5�(�	����{�{���
��
.�-�	�9�3�
��
�/�/�$�/�������)�����1�%rc�.�SnUR[U5S9nURX!5up4SRU5nU(aSnOSnSn[	URUS95R5nUR
X65 URUS5 g	)
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()
            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 (?:22|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\rN)r�r�rLrYr
r2rZr=)rCr$rDrHrJr\rs       r�check_dump_traceback_threads�.FaultHandlerTests.check_dump_traceback_threadss���
��@�{�{�D��N�{�3���?�?�4�:������6�"����F��F�
���u�|�|�6�|�2�3�9�9�;������'�����1�%rc�&�URS5 gr)rros r�test_dump_traceback_threads�-FaultHandlerTests.test_dump_traceback_threadsSs���)�)�$�/rc�n�[5nURU5 SSS5 g!,(df   g=fr)r%rr�s  r� test_dump_traceback_threads_file�2FaultHandlerTests.test_dump_traceback_threads_fileVs$��
�
!�X��-�-�h�7�"�
!�
!�s�&�
4c	�x�[[R"[S95nSnUR	[UUUUUS9nURXt5up�SR
U5nU(d0Un
U(aU
S-n
SU-n[SSX�S	9nURX�5 OURUS
5 URU	S5 g)
z�
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.
)�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$rErr�zATimeout \(%s\)!\nThread 0x[0-9a-f]+ \(most recent call first\):\n��)rr/rN)
�str�datetime�	timedelta�TIMEOUTr�rLrYrrZr=)
rCr#r$r%r$rE�timeout_strrDr�rJ�countrrs
             r�check_dump_traceback_later�,FaultHandlerTests.check_dump_traceback_laterZs����(�,�,�W�=�>����<�{�{�������
�
���/�/�$�9����	�	�%� ����E����
��Y�\g�g�F�&�r�2�v�G�E����U�*����U�B�'�����1�%rc�$�UR5 gr�r.ros r�test_dump_traceback_later�+FaultHandlerTests.test_dump_traceback_later�s���'�'�)rc�"�URSS9 g)NT)r#r1ros r� test_dump_traceback_later_repeat�2FaultHandlerTests.test_dump_traceback_later_repeat�����'�'�t�'�4rc�"�URSS9 g)NT)r$r1ros r� test_dump_traceback_later_cancel�2FaultHandlerTests.test_dump_traceback_later_cancel�r7rc�j�[5nURUS9 SSS5 g!,(df   g=fr)r%r.r�s  r�test_dump_traceback_later_file�0FaultHandlerTests.test_dump_traceback_later_file�s'��
�
!�X��+�+�X�+�>�"�
!�
!�rc��[R"S5nURUR5S9 SSS5 g!,(df   g=fr)r r�r.r�r	s  r�test_dump_traceback_later_fd�.FaultHandlerTests.test_dump_traceback_later_fd�s7���
#�
#�E�
*�b��+�+�r�y�y�{�+�;�+�
*�
*�r�walltimec�"�URSS9 g)Nr�)r%r1ros r�test_dump_traceback_later_twice�1FaultHandlerTests.test_dump_traceback_later_twice�s���'�'�a�'�0r�registerzneed faulthandler.registerc	�x�[RnSnURUUUUUUS9nURXq5up�SR	U5nU(d+U(aSn
OSn
[SSU
5n
UR
X�5 OURUS5 U(aURU	S	5 g
URU	S	5 g
)z�
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.
az
            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)
            )rN�signum�
unregister�chainr$rErz8Current thread 0x[0-9a-f]+ \(most recent call first\):\nz#Stack \(most recent call first\):\nr�� r/rN)	�signal�SIGUSR1r�rLrYrrZr=r[)rCr$rNrHrIrErGrDr�rJrs           r�check_register� FaultHandlerTests.check_register�s�������-��\�{�{�#��!����
�
���/�/�$�9����	�	�%� ����S��>��&�r�2�u�5�E����U�*����U�B�'������!�,����X�q�)rc�$�UR5 gr�rMros r�
test_register�FaultHandlerTests.test_registers�����rc�"�URSS9 g)NT)rHrPros r�test_unregister�!FaultHandlerTests.test_unregisters�����t��,rc�j�[5nURUS9 SSS5 g!,(df   g=fr)r%rMr�s  r�test_register_file�$FaultHandlerTests.test_register_files'��
�
!�X������2�"�
!�
!�rc��[R"S5nURUR5S9 SSS5 g!,(df   g=fr)r r�rMr�r	s  r�test_register_fd�"FaultHandlerTests.test_register_fds7���
#�
#�E�
*�b����2�9�9�;��/�+�
*�
*�rc�"�URSS9 g)NTr�rPros r�test_register_threads�'FaultHandlerTests.test_register_threadss�������-rc�"�URSS9 g)NT)rIrPros r�test_register_chain�%FaultHandlerTests.test_register_chains�����$��'rc#�*# �[RnS[lUR[5nSv� SSS5 UR	[WR5S5 U[lg!,(df   N?=f!U[lf=f7f)Nzsys.stderr is None)r�rI�assertRaises�RuntimeErrorr=r(�	exception)rCrI�cms   r�check_stderr_none�#FaultHandlerTests.check_stderr_nonese�������	 ��C�J��"�"�<�0�B��1����S����.�0D�E��C�J�	1�0�� �C�J�s2�B� B�A2�-B�&B�2
B�<B�
B�Bc�H�UR5 [R"5 SSS5 UR5 [R"5 SSS5 UR5 [R"S5 SSS5 [[S5(a>UR5 [R"[R5 SSS5 gg!,(df   N�=f!,(df   N�=f!,(df   N�=f!,(df   g=f)Ng����MbP?rE)	rgr�r��dump_traceback�dump_traceback_later�hasattrrErKrLros r�test_stderr_None�"FaultHandlerTests.test_stderr_None#s����
#�
#�
%����!�&�
�
#�
#�
%��'�'�)�&�
�
#�
#�
%��-�-�d�3�&��<��,�,��'�'�)��%�%�f�n�n�5�*�)�-�
&�
%��
%�
%��
%�
%��*�)�s.�C �C1�-D�1%D� 
C.�1
C?�
D�
D!zspecific to Windowsc�H�SHupURSUS3SU5 M g)N))�EXCEPTION_ACCESS_VIOLATIONrn)�EXCEPTION_INT_DIVIDE_BY_ZEROzint divide by zero)�EXCEPTION_STACK_OVERFLOWzstack overflowz�
                import faulthandler
                faulthandler.enable()
                faulthandler._raise_exception(faulthandler._r�rm)ri)rC�excr�s   r�test_raise_exception�&FaultHandlerTests.test_raise_exception0s@��
�I�C�

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

�
rc��SHJnSUS3n[U5nURU5up4URU/5 URXA5 ML g)N)lcs�@lRC�@z�
                    import faulthandler
                    faulthandler.enable()
                    faulthandler._raise_exception(z)
                    �r
rLr=)rC�exc_coderDrHrJs     r�test_ignore_exception�'FaultHandlerTests.test_ignore_exception?s`��
�H�3�4<�*�=��D�
�$�<�D�#���t�4��F����V�R�(����X�0�
rc��SHCnURSUSS35up#URU/5 URUXS-45 ME g)N)ri�xV4i@i@ipi���z{
                import faulthandler
                faulthandler.enable()
                faulthandler._raise_exception(0xrr�i����)rLr=r�)rCrsrHrJs    r�test_raise_nonfatal_exception�/FaultHandlerTests.test_raise_nonfatal_exceptionOsf��
�C� $���41�25�Q��8�0� ��F�
���V�R�(�
�M�M�(��k� 1�2�
4�#
rc��[S5nURU5up#URU/5 URUS5 g)Nz�
            import faulthandler
            faulthandler.enable()
            faulthandler.disable()
            code = faulthandler._EXCEPTION_ACCESS_VIOLATION
            faulthandler._raise_exception(code)
        lrw�rCrDrHrJs    r� test_disable_windows_exc_handler�2FaultHandlerTests.test_disable_windows_exc_handlerksD����
�� �?�?�4�0��������$�����:�.rc��[S5nURU5up#URU/5 URUS5 g)Nz`
            import faulthandler
            faulthandler.cancel_dump_traceback_later()
        rrwrs    r�.test_cancel_later_without_dump_traceback_later�@FaultHandlerTests.test_cancel_later_without_dump_traceback_laterxsF����
�� �?�?�4�0��������$�����1�%rz&only meaningful if the GIL is disabledc�d�[S5nURU5up#URUS5 g)NaL
        import faulthandler
        from threading import Thread, Event

        class Waiter(Thread):
            def __init__(self):
                Thread.__init__(self)
                self.running = Event()
                self.stop = Event()

            def run(self):
                self.running.set()
                self.stop.wait()

        for _ in range(100):
            waiter = Waiter()
            waiter.start()
            waiter.running.wait()
            faulthandler.dump_traceback(all_threads=True)
            waiter.stop.set()
            waiter.join()
        rrw)rCrD�_rJs    r�!test_free_threaded_dump_traceback�3FaultHandlerTests.test_free_threaded_dump_traceback�s5����
��,�o�o�d�+�������1�%rr)NNr)FFr)FFFFN)P�__name__�
__module__�__qualname__�__firstlineno__rLr^rfrirrr��platform�
startswithrprrur{rr�r��	_testcapi�
skipUnlessrlrKr�r�r�r�r�r�r�r�r�r�r�r�r�r�r�requires_subprocessr�r�r�r�rrr
rrrrr.r2r5r9r<r?�requires_resourcerCrMrQrTrWrZr]r`rrgrmrrtryr|r�r�r	�requires_working_threading�Py_GIL_DISABLEDr��__static_attributes__rrrr'r'0s���'-�T"�t����#(�',�'�%)�N?�?��_�_�S�\�\�,�,�U�3�L�N�$�N�$�*�"��"��!%��!%�F
!���_�_�S�\�\�W�,�9�;�(�;�(��_�_�Y�$�&�(8�9�
������2�4H�I��	��J�:�	��_�_�Y�$�&�(8�9�
������2�4H�I��	#��J�:�	#��_�_�Y�$�&�(8�9�
%�:�
%�+�*��_�_�S�\�\�,�,�Y�7�B�C��_�_���/@�A�A�:�<�<�<�C�
<��"��"��
#��
#��_�_�S�\�\�W�,�E�G����G�������)��)��)��)�&%�,
� � �"�4�#�4�
� � �"�
3�#�
3�
� � �"�3�#�3�$04��,&�\$�9��_�_�S�\�\�W�,�E�G�6�G�6�&�0;&�z0�8�<&�/3��<&�|*�5�5�?��_�_�S�\�\�W�,�E�G�<�G�<�
���z�*�1�+�1��_�_���z�:�:�1�3�9>�9=�O*�3�O*�b�-�3��_�_�S�\�\�W�,�E�G�0�G�0�.�(�� �� �6�����%:�;��<������%:�;�
1�<�
1�����%:�;�4�<�4�6����%:�;�
/�<�
/�	&��0�0�2�
����0�0�2Z�[�&�\�3�&rr'�__main__)r)!�
contextlibrr)r�r5r�rKr�r�rr�test.supportrrrrr	r r�textwrapr
r��ImportError�has_subprocess_support�SkipTestr+rrr%�TestCaser'r��mainrrr�<module>r�s���%���	�	�
��
��[�[�������%�%�
�
�
�=�
>�>�

��!�M�
�#��#�n
&��)�)�n
&�`�z���M�M�O���_���I��s�B-�-B8�7B8

Youez - 2016 - github.com/yon3zu
LinuXploit