python (3.12.0)

Browse
Build Log
Usage
Build Options
Dependencies
Source
Versions
Version Info
(root)/
lib/
python3.12/
test/
__pycache__/
test_faulthandler.cpython-312.opt-2.pyc

͑etyddlmZddlZddlZddlZddlZddlZddlZddlZddl	m
Z
ddlmZddlm
Z
mZddlmZddlZddlZddlmZ	ddlZe
j,sej.dd	Zej2d
k(ZddZdZed
ZGddej<Ze dk(rejByy#e$rdZYtwxYw))contextmanagerN)support)	os_helper)
script_helper
is_android)skip_if_sanitizer)dedentztest module requires subprocessg?ntcb|}|d|zz
}|d|zz
}d|krd|dz|dz
zz|zSd|zdzS)Nz#  File "<string>", line %s in func
z&  File "<string>", line %s in <module>^
$)lineno1lineno2header	min_countregexs     J/BuggyBox/python/3.12.0/bootstrap/lib/python3.12/test/test_faulthandler.pyexpected_tracebackrsZE	
3g
==E	
5
??E9}edly1}55==U{S  cBtjtd|S)Nz(raising SIGSEGV on Android is unreliable)unittestskipIfr)tests rskip_segfault_on_androidr&s(G8??:EGGKMMrc#Ktj}	|tj|y#tj|wxYwwN)tempfilemktemprunlinkfilenames rtemporary_filenamer%+s8 H#"	"sA2AA		Ac	eZdZdRdZddddddddddZdSdZd	Zeje	jjd
ddZe
d
Ze
dZdZdZeje	jdk(ddZejedudej(eedde
dZejedudej(eedde
dZdZdZdZeje	jjddejeed d!d"Ze
d#Zeddd$%e
d&Z eje	jdk(d'eddd$%e
d(Z!e
d)Z"e
d*Z#e
d+Z$d,Z%e&jNd-Z(e&jNd.Z)e&jNd/Z*ddd0d1Z+d2Z,d3Z-eje	jdk(d'd4Z.d5Z/d6Z0d7Z1d8Z2dTddd0d9Z3d:Z4d;Z5d<Z6d=Z7eje	jdk(d'd>Z8e&jrd?d@Z:ejeedAdB		dUdCZ;dDZ<dEZ=dFZ>eje	jdk(d'dGZ?dHZ@dIZAeBdJZCdKZDej(eEdLdMZFej(eEdLdNZGej(eEdLdOZHej(eEdLdPZIdQZJy)VFaultHandlerTestsNcJ	t|j}g}||j|tj5tjd||}|5|j\}}|j}ddddddjdd}|rJ|j|dt|d5}	|	j}ddd|jdd}nr|p|j|dtj|tjdt|dd	5}	|	j}ddd|jdd}|j!fS#1swYxYw#1swYxYw#1swYxYw#1swYQxYw)
N-c)pass_fdsasciibackslashreplacerbrF)closefd)r	stripappendrSuppressCrashReportrspawn_pythoncommunicatewaitdecodeassertEqualopenreadoslseekSEEK_SET
splitlines)
selfcoder$fdr*processoutputstderrexitcodefps
          r
get_outputzFaultHandlerTests.get_output5sz	d|!!#
>OOB

(
(
*	*#00thOG
*!(!4!4!6"<<>
*	*
w(:;VR(h%
#
#]]7,>?F
^VR(HHRa(b$.
#"
#]]7,>?F  "H,,
*
*	*	*
#
#
#
#s<F$E5FF
8F5E>	:FF

FF"TFz<module>)r$all_threadsother_regexr@know_current_threadpy_fatal_errorgarbage_collectingfunctionc	|r|rd}nd}nd}d|g}
|	r|
jd|
jd|
j|d|
r|
jd|
jd	|d
|dj|
}
|r	d|
d
|d}
d|
}
|j|||\}}dj|}|j||
|j	|dy)NzCurrent thread 0x[0-9a-f]+zThread 0x[0-9a-f]+Stackr
z!Python runtime state: initializedr-z \(most recent call first\):z  Garbage-collectingz  File "<string>", line z in rz(?:|)z(?m)r$r@r)r1joinrFassertRegexassertNotEqual)r>r?linenofatal_errorr$rGrHr@rIrJrKrLrrrBrDs                rcheck_errorzFaultHandlerTests.check_errorVs	"5-F[M"#LL<=
R
 <=>LL/0
0XJGH		% %+a0Eug??4(r?J6"'Ha(rcJ|r|d|}d|z}|j|||fi|y)Nz: zFatal Python error: %srW)r>r?line_number
name_regexfunckwrVs       rcheck_fatal_errorz#FaultHandlerTests.check_fatal_error}s2%):6J.;{K>2>rc8d|z}|j|||fi|y)NzWindows fatal exception: %srY)r>r?rZr[r]rVs      rcheck_windows_exceptionz)FaultHandlerTests.check_windows_exceptions%3j@{K>2>raixz5the first page of memory is a mapped read-only on AIXc^ts|jdddy|jdddy)Nz
                import faulthandler
                faulthandler.enable()
                faulthandler._read_null()
                z4(?:Segmentation fault|Bus error|Illegal instruction)access violation)
MS_WINDOWSr^r`r>s rtest_read_nullz FaultHandlerTests.test_read_nullsA""$
,	
-
((*
"

$rc*|jdddy)Nzs
            import faulthandler
            faulthandler.enable()
            faulthandler._sigsegv()
            rcSegmentation faultr^rfs rtest_sigsegvzFaultHandlerTests.test_sigsegv 

 
	"rc0|jdddddy)Na
            import faulthandler
            import gc
            import sys

            faulthandler.enable()

            class RefCycle:
                def __del__(self):
                    faulthandler._sigsegv()

            # create a reference cycle which triggers a fatal
            # error in a destructor
            a = RefCycle()
            b = RefCycle()
            a.b = b
            b.a = a

            # Delete the objects, not the cycle
            a = None
            b = None

            # Break the reference cycle: call __del__()
            gc.collect()

            # Should not reach this line
            print("exit", file=sys.stderr)
            	ri__del__T)rLrKrjrfs rtest_gczFaultHandlerTests.test_gcs*	
 8
 #?		%rc2|jddddddy)Nz
            import faulthandler
            faulthandler.enable()
            faulthandler._fatal_error_c_thread()
            rcz
in new threadFfaulthandler_fatal_error_threadT)rIr\rJrjrfs rtest_fatal_error_c_threadz+FaultHandlerTests.test_fatal_error_c_threads+ 

 %2			!rc*|jdddy)Nzs
            import faulthandler
            faulthandler.enable()
            faulthandler._sigabrt()
            rcAbortedrjrfs rtest_sigabrtzFaultHandlerTests.test_sigabrts 


	rwin32z"SIGFPE cannot be caught on Windowsc*|jdddy)Nzr
            import faulthandler
            faulthandler.enable()
            faulthandler._sigfpe()
            rczFloating point exceptionrjrfs rtest_sigfpezFaultHandlerTests.test_sigfpes	
 

&
	(rzneed _testcapiSIGBUSzneed signal.SIGBUSc*|jdddy)Nz
            import faulthandler
            import signal

            faulthandler.enable()
            signal.raise_signal(signal.SIGBUS)
            z	Bus errorrjrfs rtest_sigbuszFaultHandlerTests.test_sigbuss	
 
	rSIGILLzneed signal.SIGILLc*|jdddy)Nz
            import faulthandler
            import signal

            faulthandler.enable()
            signal.raise_signal(signal.SIGILL)
            r|zIllegal instructionrjrfs rtest_sigillzFaultHandlerTests.test_sigills	
 
!	#rctj5|jd|ddddddddy#1swYyxYw)NzP
                import _testcapi
                _testcapi.fatal_error(b'xyz', )
                xyz_testcapi_fatal_error_implT)r\rJ)rr2r^)r>release_gils  rcheck_fatal_error_funcz(FaultHandlerTests.check_fatal_error_funcsX

(
(
*	%""(//:m<$1#
#
%	%	%	%s	9Ac&|jdy)NFrrfs rtest_fatal_errorz"FaultHandlerTests.test_fatal_errors##E*rc&|jdy)NTrrfs rtest_fatal_error_without_gilz.FaultHandlerTests.test_fatal_error_without_gils##D)ropenbsdzVIssue #12868: sigaltstack() doesn't work on OpenBSD if Python is compiled with pthread_stack_overflowz#need faulthandler._stack_overflow()c.|jddddy)Nzz
            import faulthandler
            faulthandler.enable()
            faulthandler._stack_overflow()
            rcz (?:Segmentation fault|Bus error)z unable to raise a stack overflow)rHrjrfs rtest_stack_overflowz%FaultHandlerTests.test_stack_overflows'	
 

.:		<rc*|jdddy)Nzw
            import faulthandler
            faulthandler.enable()
            faulthandler._sigsegv(True)
            rcrirjrfs rtest_gil_releasedz#FaultHandlerTests.test_gil_released)rlrz0sanitizer builds change crashing process output.)memoryubreasonct5}|jdjt|dd|dddy#1swYyxYw)Nz
                import faulthandler
                output = open({filename}, 'wb')
                faulthandler.enable(output)
                faulthandler._sigsegv()
                r#ri)r%r^formatreprr>r$s  rtest_enable_filez"FaultHandlerTests.test_enable_file3sT 
!		#X""$
FDNF3$!
#
#		#		#		#s/AAz.subprocess doesn't support pass_fds on Windowsctjd5}|j}|jd|zdd|dddy#1swYyxYw)Nwb+z
                import faulthandler
                import sys
                faulthandler.enable(%s)
                faulthandler._sigsegv()
                rrir@)r 
TemporaryFilefilenor^)r>rEr@s   rtest_enable_fdz FaultHandlerTests.test_enable_fdBsa
#
#E
*
	bB""$
$$
#

	
	
	s)AAc.|jddddy)Nz
            import faulthandler
            faulthandler.enable(all_threads=False)
            faulthandler._sigsegv()
            rcriFrGrjrfs rtest_enable_single_threadz+FaultHandlerTests.test_enable_single_threadTs% 

 		rcd}d}|j|\}}dj|}|j||v|d||j|dy)Nz
            import faulthandler
            faulthandler.enable()
            faulthandler.disable()
            faulthandler._sigsegv()
            zFatal Python errorrz is present in r)rFrR
assertTruerT)r>r?not_expectedrCrDs     rtest_disablezFaultHandlerTests.test_disable_s],??406"F2.:FC	EHa(rchd}|j|\}}dj|}tjd|tj}|s|jd|t
|jdjjd}dD]}|j||y)Nz
            import faulthandler
            import sys
            # Don't filter stdlib module names
            sys.stdlib_module_names = frozenset()
            faulthandler.enable()
            faulthandler._sigsegv()
            rz*^Extension modules:(.*) \(total: [0-9]+\)$z$Cannot find 'Extension modules:' in rz, )sysfaulthandler)rFrRresearch	MULTILINEfailsetgroupr0splitassertIn)r>r?rCrDmatchmodulesnames       rtest_dump_ext_modulesz'FaultHandlerTests.test_dump_ext_modulesns ??406"		G ",,0II<VJGHekk!n**,22489+	)DMM$(	)rcLtj}	tjt_tj}	tj
|j
tjtj|jtj|rtj
ntj	|t_y#|rtj
wtjwxYw#|t_wxYwr)	rrC
__stderr__r
is_enabledenablerdisableassertFalse)r>orig_stderrwas_enableds   rtest_is_enabledz!FaultHandlerTests.test_is_enabledsjj	%CJ&113K	
+##% 7 7 9:$$&  !8!8!:; '') ((*$CJ '') ((*$CJs$-DA.C&.,D&-DD
D#cd}tjdd|f}tj|}|j	|jdy)N5import faulthandler; print(faulthandler.is_enabled())-Er)False)r
executable
subprocesscheck_outputr7rstrip)r>r?argsrBs    rtest_disabled_by_defaultz*FaultHandlerTests.test_disabled_by_defaultsBGdD1((.(3rc	Nd}tdtjtjjrdndddd|f}t
jj}|jddtj||}|j|jd	y)
Nrrr-z-Xrr)PYTHONFAULTHANDLERenvTrue)
filterrrflagsignore_environmentr:environcopypoprrr7rr>r?rrrBs     rtest_sys_xoptionsz#FaultHandlerTests.test_sys_xoptionssGdS^^%(YY%A%ATr!>4?@jjoo$d+((37'2rcd}tjd|f}ttj}d|d<d|d<tj||}|j|jdttj}d|d<d|d<tj||}|j|jd	y)
Nrr)r-r
PYTHONDEVMODErr1r)	rrdictr:rrrr7rrs     rtest_env_varzFaultHandlerTests.test_env_varsGd+2::$& !!O((37(32::$' !!O((37'2rrQc	d}|j||}|rd}n|d}nd}dd|zdd	g}|j|||\}}|j|||j|d
y)Na[
            import faulthandler

            filename = {filename!r}
            fd = {fd}

            def funcB():
                if filename:
                    with open(filename, "wb") as fp:
                        faulthandler.dump_traceback(fp, all_threads=False)
                elif fd is not None:
                    faulthandler.dump_traceback(fd,
                                                all_threads=False)
                else:
                    faulthandler.dump_traceback(all_threads=False)

            def funcA():
                funcB()

            funcA()
            rQrnStack (most recent call first):z#  File "<string>", line %s in funcBz#  File "<string>", line 17 in funcAz&  File "<string>", line 19 in <module>rrrFr7)r>r$r@r?rUexpectedtracerDs        rcheck_dump_tracebackz&FaultHandlerTests.check_dump_tracebacks	*{{
F
^FF-1F:14	
//$"=x)1%rc$|jyr)rrfs rtest_dump_tracebackz%FaultHandlerTests.test_dump_tracebacks!!#rcft5}|j|dddy#1swYyxYwNr#)r%rrs  rtest_dump_traceback_filez*FaultHandlerTests.test_dump_traceback_files0

!	9X%%x%8	9	9	9'0ctjd5}|j|jdddy#1swYyxYwNrr)r rrrr>rEs  rtest_dump_traceback_fdz(FaultHandlerTests.test_dump_traceback_fds@
#
#E
*	6b%%%5	6	6	6!AA	cd}d|dzz}d|zdz}d}|j|}dd|zd	g}|j|\}}|j|||j|d
y)Nix2z...z
            import faulthandler

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

            {func_name}()
            )	func_namerz  File "<string>", line 4 in %sz%  File "<string>", line 6 in <module>rr)r>maxlenr	truncatedr?rrrDs        r
test_truncatezFaultHandlerTests.test_truncates6B;'	&L5(	{{

.-	93

//$/x)1%rc8	d}|jt|}|j||\}}dj|}|rd}nd}d}t	|j|j}|j
|||j|dy)	Na
            import faulthandler
            from threading import Thread, Event
            import time

            def dump():
                if {filename}:
                    with open({filename}, "wb") as fp:
                        faulthandler.dump_traceback(fp, all_threads=True)
                else:
                    faulthandler.dump_traceback(all_threads=True)

            class Waiter(Thread):
                # avoid blocking if the main thread raises an exception.
                daemon = True

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

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

            waiter = Waiter()
            waiter.start()
            waiter.running.wait()
            dump()
            waiter.stop.set()
            waiter.join()
            r#r
a
            ^Thread 0x[0-9a-f]+ \(most recent call first\):
            (?:  File ".*threading.py", line [0-9]+ in [_a-z]+
            ){{1,3}}  File "<string>", line 23 in run
              File ".*threading.py", line [0-9]+ in _bootstrap_inner
              File ".*threading.py", line [0-9]+ in _bootstrap

            Current thread 0x[0-9a-f]+ \(most recent call first\):
              File "<string>", line {lineno} in dump
              File "<string>", line 28 in <module>$
            )rUr)rrrFrRr	r0rSr7)r>r$r?rBrDrUrs       rcheck_dump_traceback_threadsz.FaultHandlerTests.check_dump_traceback_threadss	@{{DN{3??4:6"FF
u||6|2399;'1%rc&|jdyr)rrfs rtest_dump_traceback_threadsz-FaultHandlerTests.test_dump_traceback_threadsOs))$/rcdt5}|j|dddy#1swYyxYwr)r%rrs  r test_dump_traceback_threads_filez2FaultHandlerTests.test_dump_traceback_threads_fileRs-

!	8X--h7	8	8	8s&/c~	ttjt}d}|j	t|||||}|j||\}}	dj
|}|s0|}
|r|
dz}
d|z}tdd||
	}|j||n|j|d
|j|	dy)N)secondsa
            import faulthandler
            import time
            import sys

            timeout = {timeout}
            repeat = {repeat}
            cancel = {cancel}
            loops = {loops}
            filename = {filename!r}
            fd = {fd}

            def func(timeout, repeat, cancel, file, loops):
                for loop in range(loops):
                    faulthandler.dump_traceback_later(timeout, repeat=repeat, file=file)
                    if cancel:
                        faulthandler.cancel_dump_traceback_later()
                    time.sleep(timeout * 5)
                    faulthandler.cancel_dump_traceback_later()

            if filename:
                file = open(filename, "wb")
            elif fd is not None:
                file = sys.stderr.fileno()
            else:
                file = None
            func(timeout, repeat, cancel, file, loops)
            if filename:
                file.close()
            )timeoutrepeatcancelloopsr$r@rrzATimeout \(%s\)!\nThread 0x[0-9a-f]+ \(most recent call first\):\n)rr-r)
strdatetime	timedeltaTIMEOUTrrFrRrrSr7)
r>rrrr$r@timeout_strr?rrDcountrrs
             rcheck_dump_traceback_laterz,FaultHandlerTests.check_dump_traceback_laterVs	(,,W=><{{

//$9x		% E
Y\ggF&r2vGEUE*UB'1%rc$|jyrr
rfs rtest_dump_traceback_laterz+FaultHandlerTests.test_dump_traceback_laters'')rc(|jdy)NT)rrrfs r test_dump_traceback_later_repeatz2FaultHandlerTests.test_dump_traceback_later_repeat''t'4rc(|jdy)NT)rrrfs r test_dump_traceback_later_cancelz2FaultHandlerTests.test_dump_traceback_later_cancelrrcft5}|j|dddy#1swYyxYwr)r%r
rs  rtest_dump_traceback_later_filez0FaultHandlerTests.test_dump_traceback_later_files0

!	?X++X+>	?	?	?rctjd5}|j|jdddy#1swYyxYwr)r rr
rrs  rtest_dump_traceback_later_fdz.FaultHandlerTests.test_dump_traceback_later_fds@
#
#E
*	<b++ryy{+;	<	<	<rwalltimec(|jdy)Nr)rrrfs rtest_dump_traceback_later_twicez1FaultHandlerTests.test_dump_traceback_later_twices''a'0rregisterzneed faulthandler.registerch	tj}d}|j||||||}|j||\}}	dj	|}|s'|rd}
nd}
tdd|
}
|j
||
n|j|d|r|j|	d	y|j|	d	y)
Naz
            import faulthandler
            import os
            import signal
            import sys

            all_threads = {all_threads}
            signum = {signum:d}
            unregister = {unregister}
            chain = {chain}
            filename = {filename!r}
            fd = {fd}

            def func(signum):
                os.kill(os.getpid(), signum)

            def handler(signum, frame):
                handler.called = True
            handler.called = False

            if filename:
                file = open(filename, "wb")
            elif fd is not None:
                file = sys.stderr.fileno()
            else:
                file = None
            if chain:
                signal.signal(signum, handler)
            faulthandler.register(signum, file=file,
                                  all_threads=all_threads, chain={chain})
            if unregister:
                faulthandler.unregister(signum)
            func(signum)
            if chain and not handler.called:
                if file is not None:
                    output = file
                else:
                    output = sys.stderr
                print("Error: signal handler not called!", file=output)
                exitcode = 1
            else:
                exitcode = 0
            if filename:
                file.close()
            sys.exit(exitcode)
            )rGsignum
unregisterchainr$r@rz8Current thread 0x[0-9a-f]+ \(most recent call first\):\nz#Stack \(most recent call first\):\nr r-r)	signalSIGUSR1rrFrRrrSr7rT)r>r$rGr r!r@rr?rrDrs           rcheck_registerz FaultHandlerTests.check_registers	-\{{#!

//$9x		% S>&r2u5EUE*UB'!,Xq)rc$|jyrr%rfs r
test_registerzFaultHandlerTests.test_registersrc(|jdy)NT)r r'rfs rtest_unregisterz!FaultHandlerTests.test_unregisterst,rcft5}|j|dddy#1swYyxYwr)r%r%rs  rtest_register_filez$FaultHandlerTests.test_register_files0

!	3X2	3	3	3rctjd5}|j|jdddy#1swYyxYwr)r rr%rrs  rtest_register_fdz"FaultHandlerTests.test_register_fds@
#
#E
*	0b299;/	0	0	0rc(|jdy)NTrr'rfs rtest_register_threadsz'FaultHandlerTests.test_register_threadss-rc(|jdy)NT)r!r'rfs rtest_register_chainz%FaultHandlerTests.test_register_chains$'rc# Ktj}	dt_|jt5}dddd|j	tjd|t_y#1swY:xYw#|t_wxYww)Nzsys.stderr is None)rrCassertRaisesRuntimeErrorr7r	exception)r>rCcms   rcheck_stderr_nonez#FaultHandlerTests.check_stderr_nonesm	 CJ""<0
B
S.0DECJ	

 CJs2B A>A2-A>&B2A;7A>>
BBc|j5tjddd|j5tjddd|j5tjddddttdr=|j5tjtjdddyy#1swYxYw#1swYxYw#1swYoxYw#1swYyxYw)NgMbP?r)	r8rrdump_tracebackdump_traceback_laterhasattrrr#r$rfs rtest_stderr_Nonez"FaultHandlerTests.test_stderr_Nones
#
#
%	"!	"

#
#
%	*'')	*

#
#
%	4--d3	4<,'')
6%%fnn5
6
6-
	"	"	*	*	4	4
6
6s.CC#+C/)$C;C #C,/C8;Dzspecific to WindowscFdD]\}}|jd|dd|y)N))EXCEPTION_ACCESS_VIOLATIONrd)EXCEPTION_INT_DIVIDE_BY_ZEROzint divide by zero)EXCEPTION_STACK_OVERFLOWzstack overflowz
                import faulthandler
                faulthandler.enable()
                faulthandler._raise_exception(faulthandler._rrc)r`)r>excrs   rtest_raise_exceptionz&FaultHandlerTests.test_raise_exception,sG
	IC

((.=>AEB*


	rcdD]K}d|d}t|}|j|\}}|j|g|j||My)N)lcs@lRC@z
                    import faulthandler
                    faulthandler.enable()
                    faulthandler._raise_exception(z)
                    r	rFr7)r>exc_coder?rBrDs     rtest_ignore_exceptionz'FaultHandlerTests.test_ignore_exception;si
	1H34<*=D
$<D#t4FHVR(Xx0	1rcdD]D}|jd|dd\}}|j|g|j|||dzfFy)N)rixV4i@i@ipiz{
                import faulthandler
                faulthandler.enable()
                faulthandler._raise_exception(0xrri)rFr7r)r>rBrBrDs    rtest_raise_nonfatal_exceptionz/FaultHandlerTests.test_raise_nonfatal_exceptionKso
	4C $4125Q80 FH
VR(
MM(k 12
4#	4rctd}|j|\}}|j|g|j|dy)Nz
            import faulthandler
            faulthandler.enable()
            faulthandler.disable()
            code = faulthandler._EXCEPTION_ACCESS_VIOLATION
            faulthandler._raise_exception(code)
        lrEr>r?rBrDs    r test_disable_windows_exc_handlerz2FaultHandlerTests.test_disable_windows_exc_handlergsF
 ??40$:.rctd}|j|\}}|j|g|j|dy)Nz`
            import faulthandler
            faulthandler.cancel_dump_traceback_later()
        rrErKs    r.test_cancel_later_without_dump_traceback_laterz@FaultHandlerTests.test_cancel_later_without_dump_traceback_latertsH
 ??40$1%r)NNr)FFr)FFFFN)K__name__
__module____qualname__rFrWr^r`rrrplatform
startswithrgrrkrprsrvry	_testcapi
skipUnlessr<r#r}rrrrrrrrrrrrrrrrequires_subprocessrrrrrrrrrrrr
rrrrrrequires_resourcerr%r(r*r,r.r0r2rr8r=rerCrGrIrLrNrrrr'r'3s-D"t#(','%)N??X__S\\,,U3LN$N$*""!%!%F
!X__S\\W,9;(;(X__Y$&(89X24HI	J:	X__Y$&(89X24HI	#J:	#
%+*X__S\\,,Y7BCX__/@AA:<<<C
<""dt5@A
#A
#X__S\\W,EGdt5@AAG
))))&%,!W  "4#4!W  "
3#
3!W  "3#3$04,&\$9X__S\\W,EG6G6&09&v08<&/3<&|*55?X__S\\W,EG<G<Wz*1+1X__z::139>9=O*3O*b-3X__S\\W,EG0G0.(  6X%:;<X%:;
1<
1X%:;4<46X%:;
/<
/	&rr'__main__)r)"
contextlibrrrr:rr#rrrrtest.supportrrrrr rtextwrapr	rTImportErrorhas_subprocess_supportSkipTestr
rrerrr%TestCaser'rOmainrrr<module>ras%		

"2*%%
(

=
>>

ggo
!M
##J
&))J
&ZzHMMO[IsB;;CC