403Webshell
Server IP : 121.121.20.254  /  Your IP : 216.73.217.84
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 :  C:/Python313/Lib/test/__pycache__/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Command :


[ Back ]     

Current File : C:/Python313/Lib/test/__pycache__/test_faulthandler.cpython-313.opt-2.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$S5 [USS	S
9nUR!5nSSS5 URSS5nUR'5W
4$!,(df   N�=f!,(df   GN=f!,(df   N�=f!,(df   Nf=f)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)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 rz(?:�|�)z(?m)�r$rEr)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-SS	/nURX1U5upgURXe5 URUS
5 g)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()
            rXry���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)	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 (?: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\r)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)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$rErr�zATimeout \(%s\)!\nThread 0x[0-9a-f]+ \(most recent call first\):\n��)rr/r)
�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 gURU	S	5 g)
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)
            )rN�signum�
unregister�chainr$rErz8Current thread 0x[0-9a-f]+ \(most recent call first\):\nz#Stack \(most recent call first\):\nr�� r/r)	�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