+
    Bi                        ^ RI Ht ^ RIt^ RIt^ RIt^ RIt^ RIt^ RIt^ RIt^ RI	H
t
 ^ RIHtHtHtHtHt ^ RIt^ RIt^ RIHt  ^ RIt]
P.                  '       g   ]P0                  ! R4      hRtRt]P6                  ! ]4      tR	tR
] 2t] R2tR] 2t ]  R2t!RR lt"R t#]R 4       t$Rt%RR]% R]% R2.t& ! R R]PN                  4      t(])R8X  d   ]PT                  ! 4        R# R#   ] d    Rt Li ; i)    )contextmanagerN)support)	os_helperscript_helper
is_android
MS_WINDOWSthreading_helper)dedentztest module requires subprocessg      ?zStack (most recent call first):z
( \[.*\])?zThread 0x[0-9a-f]+z \(most recent call first\):zCurrent thread 0x[0-9a-f]+c                     TpVR V ,          ,          pVRV,          ,          p^V8  d&   RVR,           V^,
          ,          ,           V,           # RV,           R,           # )z#  File "<string>", line %s in func
z&  File "<string>", line %s in <module>^
$ )lineno1lineno2header	min_countregexs   &&&& -/usr/lib/python3.14/test/test_faulthandler.pyexpected_tracebackr   $   sZ    E	3g==E	5??E9}edly1}55==U{S      c                 D    \         P                  ! \        R 4      ! V 4      # )z(raising SIGSEGV on Android is unreliable)unittestskipIfr   )tests   &r   skip_segfault_on_androidr   -   s#    ??:EGGKM Mr   c               #      "   \         P                  ! 4       p  V x  \        P                  ! V 4       R #   \        P                  ! T 4       i ; i5iN)tempfilemktempr   unlinkfilenames    r   temporary_filenamer$   2   s7      H#"	"s   A5 AAAz0x[0-9a-f]+z:Current thread's C stack trace \(most recent call first\):z!(  Binary file ".+"(, at .*(\+|-)z)? \[z
\])|(<.+>)c                     a  ] tR t^At o RcR ltRRRRRRRRRRR	R
RR
RRRR/	R ltRdR ltR t]P                  ! ]
P                  P                  R4      R4      R 4       t]R 4       t]R 4       tR t]P&                  ! RRR7      R 4       t]P                  ! ]
P                  R8H  R4      ]P&                  ! RRR7      R 4       4       t]P                  ! ]RJ R4      ]P.                  ! ]! ]R 4      R!4      ]P&                  ! R"RR7      ]R# 4       4       4       4       t]P                  ! ]RJ R4      ]P.                  ! ]! ]R$4      R%4      ]P&                  ! R&RR7      ]R' 4       4       4       4       t]P                  ! ]RJ R4      R( 4       tR) tR* t]P                  ! ]
P                  P                  R+4      R,4      ]P                  ! ]! ]R-4      '       * R.4      R/ 4       4       t ]R0 4       t!]R1 4       t"]P                  ! ]
P                  R8H  R24      ]R3 4       4       t#]R4 4       t$]R5 4       t%]R6 4       t&R7 t']PP                  ! 4       R8 4       t)]PP                  ! 4       R9 4       t*]PP                  ! 4       R: 4       t+RRRR/R; lt,R< t-R= t.]P                  ! ]
P                  R8H  R24      R> 4       t/R? t0R@ t1RA t2RB t3ReRRRR/RC llt4RD t5RE t6RF t7RG t8]P                  ! ]
P                  R8H  R24      RH 4       t9]Pt                  ! RI4      RJ 4       t;]P                  ! ]! ]RK4      '       * RL4      RfRM l4       t<RN t=RO t>RP t?]P                  ! ]
P                  R8H  R24      RQ 4       t@RR tA]P&                  ! RSRR7      RT 4       tB]CRU 4       tDRV tE]P.                  ! ]FRW4      RX 4       tG]P.                  ! ]FRW4      RY 4       tH]P.                  ! ]FRW4      RZ 4       tI]P.                  ! ]FRW4      R[ 4       tJR\ tK]LP                  ! 4       ]P.                  ! ]P                  R]4      R^ 4       4       tOR_ tPR` tQRa tRRbtSV tTR# )gFaultHandlerTestsNc           	     @   \        V4      P                  4       p. pVe   VP                  V4       \        \        P
                  4      pRp\        P                  ! WV4       \        P                  ! 4       ;_uu_ 4        \        P                  ! RVVVR7      pV;_uu_ 4        VP                  4       w  rVP                  4       p
RRR4       RRR4       XP                  RR4      pV'       dS   V P                  VR4       \        VR4      ;_uu_ 4       pVP!                  4       pRRR4       VP                  RR4      pM}Vez   V P                  VR4       \        P"                  ! V\        P$                  ^ 4       \        VRR	R
7      ;_uu_ 4       pVP!                  4       pRRR4       VP                  RR4      pVP'                  4       X
3#   + '       g   i     EL; i  + '       g   i     EL ; i  + '       g   i     L; i  + '       g   i     Lo; i)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 rbF)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_outputC   s    d|!!#>OOB2:: !%%c2((**#00t:B58:G !(!4!4!6"<<> 	 + w(:;VR(h%% &]]7,>?F^VR(HHRa(b$.." /]]7,>?F  "H,, 	 +** &% /.s<   ?%G&$#G	G&G:HG#	G&&G7	:H
	H	r#   all_threadsTother_regexrC   know_current_threadpy_fatal_errorFgarbage_collectingc_stackfunctionz<module>c       	        j   T;'       d    \         P                  ! 4       '       * pV'       d   V'       g   V'       d   \        pM\        pM\        pRV 2.pV	'       d   VP                  R4       VP                  R4       V'       d   V	'       g   VP                  R4       VP                  V 4       \        P                  '       d#   V	'       d   V'       g   VP                  R4       M8V
'       d   V'       g   VP                  R4       VP                  RV RV 24       V'       d   VP                  \        4       R	P                  V4      pV'       d
   R
V RV R2pRV 2pV P                  WVR7      w  ppR	P                  V4      pV P                  VV4       V P                  V^ 4       R# )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.
r   z!Python runtime state: initializedr-   z3<Cannot show all threads while the GIL is disabled>z  <tstate is freed>z  Garbage-collectingz  File "<string>", line z in r   z(?:|)z(?m)r#   rC   N)sys_is_gil_enabledCURRENT_THREAD_HEADERTHREAD_HEADERSTACK_HEADERr1   r   Py_GIL_DISABLEDextendC_STACK_REGEXjoinrJ   assertRegexassertNotEqual)rA   rB   linenofatal_errorr#   rL   rM   rC   rN   rO   rP   rQ   rR   all_threads_disabledr   r   rF   rH   s   &&&&$$$$$$$$$     r   check_errorFaultHandlerTests.check_errorl   s[     , ,((** 	 3".&!F[M"#LL<=RLLNO""""~>QLL./!*>34LL4VHD
KLLL'		% %+a0E ug??4r?J6"'Ha(r   c                b    V'       d
   V: R V: 2pRV,          pV P                   ! WV3/ VB  R# )z: zFatal Python error: %sNre   )rA   rB   line_number
name_regexfunckwrc   s   &&&&&, r   check_fatal_error#FaultHandlerTests.check_fatal_error   s.    %):6J.;K>2>r   c                @    R V,          pV P                   ! WV3/ VB  R# )zWindows fatal exception: %sNrh   )rA   rB   ri   rj   rl   rc   s   &&&&, r   check_windows_exception)FaultHandlerTests.check_windows_exception   s!    3j@K>2>r   aixz5the first page of memory is a mapped read-only on AIXc                n    \         '       g   V P                  R ^R4       R# V P                  R ^R4       R# )z
                import faulthandler
                faulthandler.enable()
                faulthandler._read_null()
                z4(?:Segmentation fault|Bus error|Illegal instruction)access violationN)r   rm   rp   rA   s   &r   test_read_null FaultHandlerTests.test_read_null   sC     z"" $
 ,	- (( *
 "$r   c                ,    V P                  R ^R4       R# )zs
            import faulthandler
            faulthandler.enable()
            faulthandler._sigsegv()
            Segmentation faultNrm   ru   s   &r   test_sigsegvFaultHandlerTests.test_sigsegv         
  	"r   c                2    V P                  R ^	RRRR7       R# )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)
            ry   __del__T)rR   rP   Nrz   ru   s   &r   test_gcFaultHandlerTests.test_gc   s*     	  8  #? 	 	%r   c           	     4    V P                  R ^RRRRR7       R# )z
            import faulthandler
            faulthandler.enable()
            faulthandler._fatal_error_c_thread()
            zin new threadFfaulthandler_fatal_error_threadT)rN   rk   rO   Nrz   ru   s   &r   test_fatal_error_c_thread+FaultHandlerTests.test_fatal_error_c_thread   s+      
  %2 	 		!r   zTSAN itercepts SIGABRT)threadc                ,    V P                  R ^R4       R# )zs
            import faulthandler
            faulthandler.enable()
            faulthandler._sigabrt()
            AbortedNrz   ru   s   &r   test_sigabrtFaultHandlerTests.test_sigabrt   s      
 	r   win32z"SIGFPE cannot be caught on WindowszTSAN itercepts SIGFPEc                ,    V P                  R ^R4       R# )zr
            import faulthandler
            faulthandler.enable()
            faulthandler._sigfpe()
            zFloating-point exceptionNrz   ru   s   &r   test_sigfpeFaultHandlerTests.test_sigfpe  s     	  
 &	(r   zneed _testcapiSIGBUSzneed signal.SIGBUSzTSAN itercepts SIGBUSc                ,    V P                  R ^R4       R# )z
            import faulthandler
            import signal

            faulthandler.enable()
            signal.raise_signal(signal.SIGBUS)
            z	Bus errorNrz   ru   s   &r   test_sigbusFaultHandlerTests.test_sigbus  s    
 	   	r   SIGILLzneed signal.SIGILLzTSAN itercepts SIGILLc                ,    V P                  R ^R4       R# )z
            import faulthandler
            import signal

            faulthandler.enable()
            signal.raise_signal(signal.SIGILL)
            zIllegal instructionNrz   ru   s   &r   test_sigillFaultHandlerTests.test_sigill  s    
 	   !	#r   c           
         \         P                  ! 4       ;_uu_ 4        V P                  R V R2^RRRR7       RRR4       R#   + '       g   i     R# ; i)zP
                import _testcapi
                _testcapi.fatal_error(b'xyz', )
                xyz_testcapi_fatal_error_implT)rk   rO   N)r   r6   rm   )rA   release_gils   &&r   check_fatal_error_func(FaultHandlerTests.check_fatal_error_func.  sW     ((**"" (//:m <$ 1# # % +***s   AA	c                (    V P                  R 4       R# )FNr   ru   s   &r   test_fatal_error"FaultHandlerTests.test_fatal_error;  s    ##E*r   c                (    V P                  R 4       R# )TNr   ru   s   &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                0    V P                  R ^RRR7       R# )zz
            import faulthandler
            faulthandler.enable()
            faulthandler._stack_overflow()
            z (?:Segmentation fault|Bus error)z unable to raise a stack overflow)rM   Nrz   ru   s   &r   test_stack_overflow%FaultHandlerTests.test_stack_overflowA  s'     	  
 .: 	 	<r   c                ,    V P                  R ^R4       R# )zw
            import faulthandler
            faulthandler.enable()
            faulthandler._sigsegv(True)
            ry   Nrz   ru   s   &r   test_gil_released#FaultHandlerTests.test_gil_releasedP  r}   r   c           	         \        4       ;_uu_ 4       pV P                  R P                  \        V4      R7      ^RVR7       RRR4       R#   + '       g   i     R# ; i)z
                import faulthandler
                output = open({filename}, 'wb')
                faulthandler.enable(output)
                faulthandler._sigsegv()
                r"   ry   N)r$   rm   formatreprrA   r#   s   & r   test_enable_file"FaultHandlerTests.test_enable_fileZ  sO    !!X"" $
 FDNF3$! # # "!!!s   /AA	z.subprocess doesn't support pass_fds on Windowsc           	         \         P                  ! R 4      ;_uu_ 4       pVP                  4       pV P                  RV,          ^RVR7       RRR4       R#   + '       g   i     R# ; i)wb+z
                import faulthandler
                import sys
                faulthandler.enable(%s)
                faulthandler._sigsegv()
                ry   rC   N)r   TemporaryFilefilenorm   )rA   rI   rC   s   &  r   test_enable_fd FaultHandlerTests.test_enable_fdg  s^     ##E**bB"" $
 $ $ #  +***s   -AA'	c                0    V P                  R ^RRR7       R# )z
            import faulthandler
            faulthandler.enable(all_threads=False)
            faulthandler._sigsegv()
            ry   FrL   Nrz   ru   s   &r   test_enable_single_thread+FaultHandlerTests.test_enable_single_threadw  s%      
   	 	r   c                    R pRpV P                  V4      w  r4RP                  V4      pV P                  W#9  V: RV: 24       V P                  V^ 4       R# )z
            import faulthandler
            faulthandler.enable()
            faulthandler.disable()
            faulthandler._sigsegv()
            zFatal Python errorr   z is present in N)rJ   r_   
assertTruera   )rA   rB   not_expectedrG   rH   s   &    r   test_disableFaultHandlerTests.test_disable  sY     ,??406"2.:FC	EHa(r   c                z   R pV P                  V4      w  r#RP                  V4      p\        P                  ! RV\        P                  4      pV'       g   V P                  RV: 24       \        VP                  ^4      P                  4       P                  R4      4      pR F  pV P                  We4       K  	  R# )z
            import faulthandler
            import sys
            # Don't filter stdlib module names
            sys.stdlib_module_names = frozenset()
            faulthandler.enable()
            faulthandler._sigsegv()
            r   z*^Extension modules:(.*) \(total: [0-9]+\)$z$Cannot find 'Extension modules:' in z, N)rW   faulthandler)rJ   r_   research	MULTILINEfailsetgroupr0   splitassertIn)rA   rB   rG   rH   matchmodulesnames   &      r   test_dump_ext_modules'FaultHandlerTests.test_dump_ext_modules  s      ??406"		G ",,0II<VJGHekk!n**,22489+DMM$( ,r   c                x   \         P                  p \         P                  \         n        \        P                  ! 4       p \        P
                  ! 4        V P                  \        P                  ! 4       4       \        P                  ! 4        V P                  \        P                  ! 4       4       V'       d   \        P
                  ! 4        M\        P                  ! 4         V\         n        R #   T'       d   \        P
                  ! 4        i \        P                  ! 4        i ; i  T\         n        i ; ir   )	rW   rG   
__stderr__r   
is_enabledenabler   disableassertFalse)rA   orig_stderrwas_enableds   &  r   test_is_enabled!FaultHandlerTests.test_is_enabled  s    jj	% CJ&113K	+##% 7 7 9:$$&  !8!8!:; '') ((*$CJ  '') ((*$CJs$   .D, A2C4 34D, 45D))D, ,D9c                    R p\         P                  RRV3p\        P                  ! V4      pV P	                  VP                  4       R4       R# )5import faulthandler; print(faulthandler.is_enabled())-Er(      FalseN)rW   
executable
subprocesscheck_outputr;   rstrip)rA   rB   argsrF   s   &   r   test_disabled_by_default*FaultHandlerTests.test_disabled_by_default  sB     GdD1((.(3r   c           	     \   R p\        R\        P                  \        P                  P                  '       d   RMRRRRV34      p\
        P                  P                  4       pVP                  RR4       \        P                  ! W#R7      pV P                  VP                  4       R	4       R# )
r   Nr   r-   z-Xr   r(   PYTHONFAULTHANDLERr*      True)filterrW   r   flagsignore_environmentr3   r4   copypopr   r   r;   r   rA   rB   r   r*   rF   s   &    r   test_sys_xoptions#FaultHandlerTests.test_sys_xoptions  s     GdS^^%(YY%A%A%ATr!>4? @ jjoo$d+((7'2r   c                   R p\         P                  RV3p\        \        P                  4      pRVR&   RVR&   \
        P                  ! W#R7      pV P                  VP                  4       R4       \        \        P                  4      pRVR&   RVR&   \
        P                  ! W#R7      pV P                  VP                  4       R4       R	# )
r   r(   r-   r   PYTHONDEVMODEr   r   1r   N)	rW   r   r2   r3   r4   r   r   r;   r   r   s   &    r   test_env_varFaultHandlerTests.test_env_var  s     Gd+2::$& !!O((7(3 2::$' !!O((7'2r   c                   RpVP                  VVR7      pV'       d   ^	pM	Ve   ^pM^p\         RV,          RR.pV P                  W1V4      w  rgV P                  We4       V P                  V^ 4       R# )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()
            rV   Nz#  File "<string>", line %s in funcBz#  File "<string>", line 17 in funcAz&  File "<string>", line 19 in <module>r   STACK_HEADER_STRrJ   r;   )rA   r#   rC   rB   rb   expectedtracerH   s   &$$     r   check_dump_traceback&FaultHandlerTests.check_dump_traceback  s    
* {{  
 F^FF 1F:14	
 //$"=)1%r   c                &    V P                  4        R # r   )r   ru   s   &r   test_dump_traceback%FaultHandlerTests.test_dump_traceback  s    !!#r   c                    \        4       ;_uu_ 4       pV P                  VR 7       RRR4       R#   + '       g   i     R# ; ir"   N)r$   r   r   s   & r   test_dump_traceback_file*FaultHandlerTests.test_dump_traceback_file  s-    !!X%%x%8 "!!!	   0A	c                    \         P                  ! R 4      ;_uu_ 4       pV P                  VP                  4       R7       RRR4       R#   + '       g   i     R# ; ir   r   N)r   r   r   r   rA   rI   s   & r   test_dump_traceback_fd(FaultHandlerTests.test_dump_traceback_fd  s=     ##E**b%%%5 +***   !A

A	c                    R pRV^2,           ,          pRV,          R,           pRpVP                  VR7      p\         RV,          R.pV P                  V4      w  rgV P                  We4       V P                  V^ 4       R# )i  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>Nr   )rA   maxlenr  	truncatedrB   r   r   rH   s   &       r   test_truncateFaultHandlerTests.test_truncate  s    6B;'	&L5(	 {{  
   -	93

 //$/)1%r   c                B   RpVP                  \        V4      R7      pV P                  W!4      w  r4RP                  V4      pV'       d   ^pM^
pR\         R\
         RV R2p\        V4      P                  4       pV P                  W64       V P                  V^ 4       R# )	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   z
            ^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>$
            N)
r   r   rJ   r_   rZ   rY   r
   r0   r`   r;   )rA   r#   rB   rF   rH   rb   r   s   &&     r   check_dump_traceback_threads.FaultHandlerTests.check_dump_traceback_threads7  s    
@ {{DN{3??4:6"FF_  ## $%%+H -
 u##%'1%r   c                (    V P                  R 4       R # r   )r  ru   s   &r   test_dump_traceback_threads-FaultHandlerTests.test_dump_traceback_threadst  s    ))$/r   c                    \        4       ;_uu_ 4       pV P                  V4       R R R 4       R #   + '       g   i     R # ; ir   )r$   r  r   s   & r    test_dump_traceback_threads_file2FaultHandlerTests.test_dump_traceback_threads_filew  s*    !!X--h7 "!!!s	   /A 	c          	        \        \        P                  ! \        R7      4      pRpVP	                  \        VVVVVR7      pV P                  Wt4      w  rRP                  V4      pV'       gA   Tp
V'       d
   V
^,          p
RV R\         R2p\        ^^WR7      pV P                  W4       MV P                  VR	4       V P                  V	^ 4       R
# )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#   rC   r   z
Timeout \(z\)!\n\n)r   r-   N)strdatetime	timedeltaTIMEOUTr   rJ   r_   rZ   r   r`   r;   )rA   r   r!  r"  r#   rC   timeout_strrB   r   rH   countr   r   s   &&&&$$       r   check_dump_traceback_later,FaultHandlerTests.check_dump_traceback_later{  s     (,,W=>< {{  
 //$9		% E
#K=',F&r2vGEU*UB'1%r   c                &    V P                  4        R # r   r*  ru   s   &r   test_dump_traceback_later+FaultHandlerTests.test_dump_traceback_later  s    '')r   c                *    V P                  R R7       R# )T)r   Nr-  ru   s   &r    test_dump_traceback_later_repeat2FaultHandlerTests.test_dump_traceback_later_repeat      ''t'4r   c                *    V P                  R R7       R# )T)r!  Nr-  ru   s   &r    test_dump_traceback_later_cancel2FaultHandlerTests.test_dump_traceback_later_cancel  r3  r   c                    \        4       ;_uu_ 4       pV P                  VR 7       RRR4       R#   + '       g   i     R# ; ir  )r$   r*  r   s   & r   test_dump_traceback_later_file0FaultHandlerTests.test_dump_traceback_later_file  s-    !!X++X+> "!!!r  c                    \         P                  ! R 4      ;_uu_ 4       pV P                  VP                  4       R7       RRR4       R#   + '       g   i     R# ; ir  )r   r   r*  r   r	  s   & r   test_dump_traceback_later_fd.FaultHandlerTests.test_dump_traceback_later_fd  s=     ##E**b++ryy{+; +***r  walltimec                *    V P                  ^R7       R# )   )r"  Nr-  ru   s   &r   test_dump_traceback_later_twice1FaultHandlerTests.test_dump_traceback_later_twice  s    ''a'0r   registerzneed faulthandler.registerc           	        \         P                  pRpVP                  VVVVVVR7      pV P                  Wq4      w  rRP	                  V4      pV'       g;   V'       d   \
         R2p
M	\         R2p
\        ^^ V
4      p
V P                  W4       MV P                  VR4       V'       d   V P                  V	^ 4       R# V P                  V	^ 4       R# )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)
            )rL   signum
unregisterchainr#   rC   r   r#  r-   N)signalSIGUSR1r   rJ   r_   rY   r[   r   r`   r;   ra   )rA   r#   rL   rE  rF  rC   rD  rB   r   rH   r   s   &&&&&&     r   check_register FaultHandlerTests.check_register  s     -\ {{#!  
 //$9		% 12"5(>,&r2u5EU*UB'!,Xq)r   c                &    V P                  4        R # r   rI  ru   s   &r   test_registerFaultHandlerTests.test_register$  s    r   c                *    V P                  R R7       R# )T)rE  NrL  ru   s   &r   test_unregister!FaultHandlerTests.test_unregister'  s    t,r   c                    \        4       ;_uu_ 4       pV P                  VR 7       RRR4       R#   + '       g   i     R# ; ir  )r$   rI  r   s   & r   test_register_file$FaultHandlerTests.test_register_file*  s-    !!X2 "!!!r  c                    \         P                  ! R 4      ;_uu_ 4       pV P                  VP                  4       R7       RRR4       R#   + '       g   i     R# ; ir  )r   r   rI  r   r	  s   & r   test_register_fd"FaultHandlerTests.test_register_fd.  s=     ##E**b299;/ +***r  c                *    V P                  R R7       R# )Tr   NrL  ru   s   &r   test_register_threads'FaultHandlerTests.test_register_threads4  s    -r   zgh-129825: hangs under TSANc                *    V P                  R R7       R# )T)rF  NrL  ru   s   &r   test_register_chain%FaultHandlerTests.test_register_chain7  s    $'r   c              #  @  "   \         P                  p R \         n        V P                  \        4      ;_uu_ 4       pR x  R R R 4       V P	                  \        XP                  4      R4       V\         n        R #   + '       g   i     LB; i  T\         n        i ; i5i)Nzsys.stderr is None)rW   rG   assertRaisesRuntimeErrorr;   r$  	exception)rA   rG   cms   &  r   check_stderr_none#FaultHandlerTests.check_stderr_none;  sh     	 CJ""<00B 1S.0DECJ	 10  CJs3   B(B A;-B .B;B	B BBc                   V P                  4       ;_uu_ 4        \        P                  ! 4        R R R 4       V P                  4       ;_uu_ 4        \        P                  ! 4        R R R 4       V P                  4       ;_uu_ 4        \        P                  ! R4       R R R 4       \        \        R4      '       dH   V P                  4       ;_uu_ 4        \        P                  ! \        P                  4       R R R 4       R # R #   + '       g   i     L; i  + '       g   i     L; i  + '       g   i     L; i  + '       g   i     R # ; i)NgMbP?rB  )	rc  r   r   dump_tracebackdump_traceback_laterhasattrrB  rG  rH  ru   s   &r   test_stderr_None"FaultHandlerTests.test_stderr_NoneF  s     ##%%! &##%%'') &##%%--d3 &<,,''))%%fnn5 *) - &%%%%% *))s/   DDD)%D<D	D&	)D9	<E	zspecific to Windowsc                J    R F  w  rV P                  RV R2^V4       K  	  R# )EXCEPTION_ACCESS_VIOLATIONz
                import faulthandler
                faulthandler.enable()
                faulthandler._raise_exception(faulthandler._r   N))rl  rt   )EXCEPTION_INT_DIVIDE_BY_ZEROzint divide by zero)EXCEPTION_STACK_OVERFLOWzstack overflow)rp   )rA   excr   s   &  r   test_raise_exception&FaultHandlerTests.test_raise_exceptionS  s@    
IC
 (( .= >AE B*
 
r   c                    R FJ  pRV R2p\        V4      pV P                  V4      w  r4V P                  V. 4       V P                  WA4       KL  	  R# )   cs@ z
                    import faulthandler
                    faulthandler.enable()
                    faulthandler._raise_exception(z)
                    N)rs  l   RC@ r
   rJ   r;   )rA   exc_coderB   rF   rH   s   &    r   test_ignore_exception'FaultHandlerTests.test_ignore_exceptionb  s`    
H3 4<* =D
 $<D#t4FVR(X0
r   c                    R FG  pV P                  RVR R24      w  r#V P                  V. 4       V P                  VWR,          34       KI  	  R# )r   z{
                import faulthandler
                faulthandler.enable()
                faulthandler._raise_exception(0xr  r   N)r   ixV4i   @i  @i   pii)rJ   r;   r   )rA   ro  rF   rH   s   &   r   test_raise_nonfatal_exception/FaultHandlerTests.test_raise_nonfatal_exceptionr  sf    
C  $ 41 25Q 80  F VR( MM(k 124#
r   c                    \        R 4      pV P                  V4      w  r#V P                  V. 4       V P                  VR4       R# )z
            import faulthandler
            faulthandler.enable()
            faulthandler.disable()
            code = faulthandler._EXCEPTION_ACCESS_VIOLATION
            faulthandler._raise_exception(code)
        l       Nrt  rA   rB   rF   rH   s   &   r    test_disable_windows_exc_handler2FaultHandlerTests.test_disable_windows_exc_handler  sD        ??40$:.r   c                    \        R 4      pV P                  V4      w  r#V P                  V. 4       V P                  V^ 4       R# )z`
            import faulthandler
            faulthandler.cancel_dump_traceback_later()
        Nrt  r|  s   &   r   .test_cancel_later_without_dump_traceback_later@FaultHandlerTests.test_cancel_later_without_dump_traceback_later  sF         ??40$1%r   z&only meaningful if the GIL is disabledc                f    \        R 4      pV P                  V4      w  r#V P                  V^ 4       R# )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()
        Nrt  )rA   rB   _rH   s   &   r   !test_free_threaded_dump_traceback3FaultHandlerTests.test_free_threaded_dump_traceback  s5       , ood+1%r   c                `   VP                  ^ 4      pV P                  V\        ^ ,          4       V P                  \	        V4      ^ 4       V FJ  pV P                  VR7      ;_uu_ 4        VR8w  d   V P                  V\        ^,          4       RRR4       KL  	  R#   + '       g   i     Ka  ; i)r   )liner-   N)r   r`   r^   assertGreaterlensubTest)rA   rF   starting_liner  s   &&  r   check_c_stackFaultHandlerTests.check_c_stack  s    

1a(893v;*D4((2:$$T=+;< )( (((s   )%BB-c                    \        R 4      pV P                  V4      w  r#V P                  V^ 4       V P                  V4       R# )zI
        import faulthandler
        faulthandler.dump_c_stack()
        N)r
   rJ   r;   r  r|  s   &   r   test_dump_c_stack#FaultHandlerTests.test_dump_c_stack  sB        ??401%6"r   c                H   ^ RI pVP                  ! R4      ;_uu_ 4       p\        P                  ! VR7       VP	                  4        VP                  ^ 4       V P                  VP                  4       P                  R4      4       RRR4       R#   + '       g   i     R# ; i)r   Nzw+)filer   )	r   r   r   dump_c_stackflushseekr  r=   r   )rA   r   tmps   &  r   test_dump_c_stack_file(FaultHandlerTests.test_dump_c_stack_file  sh    ##D))S%%3/IIKHHQKsxxz//56	 *)))s   A'BB!	r   )NNr   )FF   )FFFFN)U__name__
__module____qualname____firstlineno__rJ   re   rm   rp   r   r   rW   platform
startswithrv   r   r{   r   r   r   skip_if_sanitizerr   r   	_testcapi
skipUnlessrh  rG  r   r   r   r   r   r   r   r   r   r   r   r   r   r   requires_subprocessr   r   r   r   r   r  r
  r  r  r  r  r*  r.  r1  r5  r8  r;  requires_resourcer@  rI  rM  rP  rS  rV  rY  r\  r   rc  ri  r   rp  rv  ry  r}  r  r	   requires_working_threadingr\   r  r  r  r  __static_attributes____classdictcell__)__classdict__s   @r   r&   r&   A   s    '-R1)!1)/31)AE1)1)151) $)1) (-	1)
 !1) (1)f?? __S\\,,U3LN$N$* " " !% !%F
! 7E F __S\\W,9;6tD( E;( __Y$&(8924HI6tD	  E J :	 __Y$&(8924HI6tD	#  E J :	# __Y$&(89
% :
%+* __S\\,,Y7BC __/@AA:<<<C
< " " 
# 
# __S\\W,EG G   ) ) ) )&%,   "4 #4   "
3 #
3   "3 #3$,&t ,& ,&\$9 __S\\W,EG6G6&0;&z08=&/3=&8<=&~*55? __S\\W,EG<G< z*1 +1 __z::13O*3O*b-3 __S\\W,EG0G0. <TJ( K(    6 %:; < %:;1 <1 %:;4 <46 %:;
/ <
/	& 002002Z[& \ 3&6=#7 7r   r&   __main__)r  )+
contextlibr   r%  r   r3   r   rG  r   rW   r   r   test.supportr   r   r   r   r	   r   r   textwrapr
   r  ImportErrorhas_subprocess_supportSkipTestr'  r   escaper[   THREAD_NAME	THREAD_IDrZ   CURRENT_THREAD_IDrY   r   r   r$   ADDRESS_EXPRr^   TestCaser&   r  mainr   r   r   <module>r     s3   %   	 	   
  [ [    %%%


=
>>
5  yy)*!+/	;:;1+? -..JK !M
 # # A(eL>T
^7)) ^7@ zMMO a  Is   C( (	C43C4