✘✘ GRAYBYTE WORDPRESS FILE MANAGER ✘✘

�
f fK��"@szdZd
Z
dZdZddlZddlZddlZddlZddlZddl	Z	ddl
Z
ddlZddlZddl
Z
ddlZddlZddlZddlZddlZddlZddlZddlZddlZddlZddlZddlmZ
yddlZWnek
rN



dZYn
XyddlZddlZWnek
r�



dZYn
Xxlej j!�D][Z"e#e"d�r�
dd	�e"j$D�
e"_$ne#e"d
�r�
ej%j&e"j'�
e"_'nq�
Wej
dkryyddl(Z(Wnek
r(


YnNXe(j)e(j*�
\Z+Z,e-e,e.e+dd
��Z/e(j0e(j*e/e,f�
ndZ1dZ2dZ3dZ4dZ5dZ6dZ7ddl8m9Z9
dddddddddf	Z:ej;�rej%j<ej=d�
d�Z>nej?�Z>ej%j&e>�
Z>Gdd �d ej@�ZAd!d"�ZBd#d$�ZCd%d&�ZDd'd(�ZEd)d*�ZFd+d,�ZGdd-d.�
ZHd/d0d1d2d3d4d5d6d7d8g
ZIeJ�ZKdeIeKd9d:�ZLGd;d<�d<eM�ZNd=d>�ZOd?dd?d?ddd@dA�ZPdeP_QGdBdC�dC�ZRd?dDdEdF�ZSdGdH�ZTdIdJ�ZUdKdL�ZVdMdN�ZWddOdP�
ZXdQdR�ZYdSdT�ZZdUddVdW�Z[dXdY�Z\e]dZkrvej%j&ej%j^ej%j_ej`d�
�
�
Zaebej%�
ZcxRecdkrYecd8Zcej%j&ej%j^ej%ec�
�
eakrVej%ec=nqWej%j&e'�
Z'e\�
ndS)[z^
Script to run Python regression tests.

Run this script with -h or --help for documentation.
z�python -m test [options] [test_name1 [test_name2 ...]]
python path/to/Lib/test/regrtest.py [options] [test_name1 [test_name2 ...]]
a`
Run Python regression tests.

If no arguments or options are provided, finds all files matching
the pattern "test_*" in the Lib/test subdirectory and runs
them in alphabetical order (but see -M and -u, below, for exceptions).

For more rigorous testing, it is useful to use the following
command line:

python -E -Wd -m test [options] [test_name1 ...]
a%Additional option details:

-r randomizes test execution order. You can use --randseed=int to provide an
int seed value for the randomizer; this is useful for reproducing troublesome
test orders.

-s On the first invocation of regrtest using -s, the first test file found
or the first test file given on the command line is run, and the name of
the next test is recorded in a file named pynexttest.  If run from the
Python build directory, pynexttest is located in the 'build' subdirectory,
otherwise it is located in tempfile.gettempdir().  On subsequent runs,
the test in pynexttest is run, and the next test is written to pynexttest.
When the last test has been run, pynexttest is deleted.  In this way it
is possible to single step through the test files.  This is useful when
doing memory analysis on the Python interpreter, which process tends to
consume too many resources to run the full regression test non-stop.

-S is used to continue running tests after an aborted run.  It will
maintain the order a standard run (ie, this assumes -r is not used).
This is useful after the tests have prematurely stopped for some external
reason and you want to start running from where you left off rather
than starting from the beginning.

-f reads the names of tests from the file given as f's argument, one
or more test names per line.  Whitespace is ignored.  Blank lines and
lines beginning with '#' are ignored.  This is especially useful for
whittling down failures involving interactions among tests.

-L causes the leaks(1) command to be run just before exit if it exists.
leaks(1) is available on Mac OS X and presumably on some other
FreeBSD-derived systems.

-R runs each test several times and examines sys.gettotalrefcount() to
see if the test appears to be leaking references.  The argument should
be of the form stab:run:fname where 'stab' is the number of times the
test is run to let gettotalrefcount settle down, 'run' is the number
of times further it is run and 'fname' is the name of the file the
reports are written to.  These parameters all have defaults (5, 4 and
"reflog.txt" respectively), and the minimal invocation is '-R :'.

-M runs tests that require an exorbitant amount of memory. These tests
typically try to ascertain containers keep working when containing more than
2 billion objects, which only works on 64-bit systems. There are also some
tests that try to exhaust the address space of the process, which only makes
sense on 32-bit systems with at least 2Gb of memory. The passed-in memlimit,
which is a string in the form of '2.5Gb', determines howmuch memory the
tests will limit themselves to (but they may go slightly over.) The number
shouldn't be more memory than the machine has (including swap memory). You
should also keep in mind that swap memory is generally much, much slower
than RAM, and setting memlimit to all available RAM or higher will heavily
tax the machine. On the other hand, it is no use running these tests with a
limit of less than 2.5Gb, and many require more than 20Gb. Tests that expect
to use more than memlimit memory will be skipped. The big-memory tests
generally run very, very long.

-u is used to specify which special resource intensive tests to run,
such as those requiring large file support or network connectivity.
The argument is a comma-separated list of words indicating the
resources to test.  Currently only the following are defined:

    all -       Enable all special resources.

    none -      Disable all special resources (this is the default).

    audio -     Tests that use the audio device.  (There are known
                cases of broken audio drivers that can crash Python or
                even the Linux kernel.)

    curses -    Tests that use curses and will modify the terminal's
                state and output modes.

    largefile - It is okay to run some test that may create huge
                files.  These tests can take a long time and may
                consume >2GB of disk space temporarily.

    network -   It is okay to run tests that use external network
                resource, e.g. testing SSL support for sockets.

    decimal -   Test the decimal module against a large suite that
                verifies compliance with standards.

    cpu -       Used for certain CPU-heavy tests.

    subprocess  Run all tests for the subprocess module.

    urlfetch -  It is okay to download files required on testing.

    gui -       Run tests that require a running GUI.

To enable all resources except one, use '-uall,-<resource>'.  For
example, to run all the tests except for the gui tests, give the
option '-uall,-gui'.
�N)
�
isabstract�__path__c
Cs"g|]}
tj
j|
�
�qS�)�os�path�abspath)�.0rrr�2/opt/alt/python34/lib64/python3.4/test/regrtest.py�
<listcomp>�s	r
�__file__�darwinii�
����)
�supportZaudioZcursesZ	largefileZnetwork�decimalZcpu�
subprocessZurlfetchZgui�srcdirZbuildcs"eZ
dZ�f
d
d�Z�S)�
_ArgParsercst�j
|
d
�

dS)Nz%
Pass -h or --help for complete help.)�super�error)�self�message)
�	__class__rr	r�s
z_ArgParser.error)�__name__�
__module__�__qualname__rrr)
rr	r�src
Csatd
ddt
dtdtdddtj�}d	}
|jd
�
}|jddd
ddd�
|jddddtdd�

|jdd
ddd�

|jddd�


|jdddddd|
�
|jd�
}|jdd d
d!dd"�
|jd#d$d
ddd%�
|jd&d'd
ddd(�
|jd)d*d
ddd+�
|jd,d-d
dd.d/dd0�
|jd1d
ddd2�

|jd3�
}|jd4d5d
ddd6|
�
|jd7dd8d.d9dt	dd:�

|jd;d<dd=dd>|
�
|jd?d@d
dddA�
|jdBdCd
dddD|
�
|jdEdFddGd.dHddI�
|jdJdKd
dddL�
|jdMdNddOd
dPdt
ddQ|
�
|jdRdSddTddU|
�
|jdVddWdtddX�

|jdY�
}|jdZd[d
ddd\�
|jd]d^d
ddd_|
�
|jd`daddbdtddc|
�
|jdddeddfd.dgdt	ddh�
|jdidjd
dd.dkddl�
|jdmdnddWdtddo�
|jdpdqd
drdsdd.dtddu�
|jdvdwddxdt	ddy�
|jdzd{d
ddd|�
|jd}d~d
ddd�
|jd�d�tj
dtj�

|S)�N�progzregrtest.pyZusageZdescriptionZepilogZadd_helpFZformatter_classz-  See the section at bottom for more details.zGeneral optionsz-hz--help�action�helpzshow this help message and exitz	--timeout�metavarZTIMEOUT�typezxdump the traceback and exit if a test takes more than TIMEOUT seconds; disabled if TIMEOUT is negative or equals to zeroz--wait�
store_truez:wait for user input, e.g., allow a debugger to be attachedz--slaveargsZARGSz-Sz--startZSTARTz'the name of the test at which to start.Z	Verbosityz-vz	--verbose�countz/run tests in verbose mode with output to stdoutz-wz
--verbose2z#re-run failed tests in verbose modez-Wz
--verbose3zdisplay test output on failurez-qz--quietz'no output unless one or more tests failz-oz--slow�dest�
print_slowzprint the slowest 10 testsz--headerz"print header with interpreter infozSelecting testsz-rz--randomizezrandomize test execution order.z
--randseedZSEED�random_seedz5pass a random seed to reproduce a previous random runz-fz
--fromfileZFILEz'read names of tests to run from a file.z-xz	--excludez arguments are tests to *exclude*z-sz--singlez#single step through a set of tests.z-mz--matchZPAT�match_testsz2match test cases and methods with glob pattern PATz-Gz
--failfastz1fail as soon as a test fails (only with -v or -W)z-uz--usez
RES1,RES2,...�appendz6specify which special resource intensive tests to run.z-Mz
--memlimitZLIMITz&run very large memory-consuming tests.z	--testdirZDIRzWexecute test files in the specified directory (instead of the Python stdlib test suite)zSpecial runsz-lz--findleaksz0if GC is available detect tests that leak memoryz-Lz
--runleaksz*run the leaks(1) command just before exit.z-Rz--huntrleaksZ	RUNCOUNTSz:search for reference leaks (needs debug build, very slow).z-jz--multiprocessZ	PROCESSES�use_mpzrun PROCESSES processes at oncez-Tz
--coverage�tracez4turn on code coverage tracing using the trace modulez-Dz
--coverdirz&directory where coverage files are putz-Nz--nocoverdirZstore_constZconst�coverdirz$put coverage files alongside modulesz-tz--thresholdZ	THRESHOLDz call gc.set_threshold(THRESHOLD)z-nz--nowindowsz'suppress error message boxes on Windowsz-Fz	--foreverz9run the specified tests in a loop, until an error happens�args�nargs)r�USAGE�DESCRIPTION�EPILOG�argparseZRawDescriptionHelpFormatterZadd_argument_group�add_argument�float�int�resources_list�relative_filename�
huntrleaksZ	REMAINDERZSUPPRESS)�parserZmore_details�grouprrr	�_create_parser�s�















































































r<c

Cstj
jtj|�S)
N)rr�joinr�SAVEDCWD)
�stringrrr	r8K
sr8c
Cs�|jd
�
}
t
|
�
d
kr3tjd�
�
n|
drMt|
d�
nd}|
drmt|
d�
nd}t
|
�
dkr�|
dr�|
dnd	}|||fS)N�
:rrz&needs 2 or 3 colon-separated argumentsr
rr
rz
reflog.txt)rr)�split�lenr3�ArgumentTypeErrorr6)r?r.�nwarmup�ntracked�fnamerrr	r9P
s




 
 
,
r9c
Cs�d
d�|jd�
D�
}
xq|
D]i}|dks#|dkrGq#n|ddkrj|dd�}n|t
kr#tjd	|�
�
q#q#W|
S)
Nc
Ssg|]}
|
j��qSr)
�lower)r�
xrrr	r
[
s	z"resources_list.<locals>.<listcomp>�
,�all�noner
�
-r
zinvalid resource: )rA�RESOURCE_NAMESr3rC)r?�
u�
rrrr	r7Z
s









r7c
	-Ks�tj
d
dddddddddddd	dd
dddddd
ddddddddddddddddddddddd�}xL|
j�D]>\}}t||�s�td|�
�
nt|||�
q�W|jdkr�g|_nt�}|jd|d|�
|j	r;
|j
r;
|jd�

n|jr]
|j
r]
|jd�

n|jr
|jr
|jd�

n|jr�
|jr�
|jd �

n|jr�
|jp�
|jr�
|jd!�

n|jr�
d|_n|jdk	r4ttd"�r|jdk
r1d|_q1q4td#�

d|_n|jdk	r�|jdk
rnd$tj�pdd%|_n|jd%kr�d|_q�n|jr�x�|jD]�}x�|D]�}|d&kr�t|jdd�<q�n|d'kr�|jdd�=q�nd}|dd(kr(d)}|d%d�}n|rS||jkru|jj|�

quq�||jkr�|jj|�

q�q�Wq�Wn|jdk	r�d)|_n|S)*N�testdir�verboser
�quietF�exclude�single�	randomize�fromfile�	findleaks�
use_resourcesr,r-Zcoverage�runleaksr9�verbose2r'r(r+�verbose3�forever�header�failfastr)z3%r is an invalid keyword argument for this functionr.�	namespacez-s and -f don't go together!z-T and -j don't go together!z-l and -j don't go together!z-M and -j don't go together!z#-G/--failfast needs either -v or -W�dump_traceback_laterzFWarning: The timeout option requires faulthandler.dump_traceback_laterrr
rJrKrLT)r3Z	Namespace�items�hasattr�	TypeError�setattrrXr<�
parse_argsrTrVrr+r,rW�memlimitr^rQr[rR�timeout�faulthandler�printr�	cpu_countZuserM�remover*r(rU)	r.�kwargs�ns�
k�
vr:�
arOrkrrr	�_parse_argse
sv












	









	










	



















rqc
Cs
d
dlm
}m}
tjg
tj�ddddg}||
j|
jft	d|
j
d|
jd	|
jd
|
j
d|
jd|
j�f}||d
tj|�
gd|d|dddtjdkdtj�
}|j�\}}|j�}	|	||fS)a%
Run the given test in a subprocess with --slaveargs.

    ns is the option Namespace parsed from command-line arguments. regrtest
    is invoked in a subprocess with the --slaveargs argument; when the
    subprocess exits, its return code, stdout and stderr are returned as a
    3-tuple.
    r
)�Popen�PIPEz-Xrhz-mz
test.regrtestr9rX�output_on_failurergr^r)z--slaveargs�stdout�stderrZuniversal_newlinesTZ	close_fds�nt�cwd)rrrrs�sys�
executablerZargs_from_interpreter_flagsrQrR�dictr9rXr[rgr^r)�json�dumpsr�namer>Zcommunicate�wait)
�testnamermrrrsZbase_cmd�	slaveargs�popenrurv�retcoderrr	�run_test_in_subprocess�
s"



	
	








r�c
.^s�tj
d
d�

g}ttd�r8|jtj�

nttd�rZ|jtj�

nx!|D]}tj|dd�


qaWt�
t	j
tj�

t
tjdd�|
�
��jr�t�
n�jdk	r�t	j�j�

n�jdk	r
ddl}|j�j�

n�jr�
ddl}|j|j|jB|jB|jB�

y|j
Wntk
rm



Yq�
XxI|j|j |j!gD],}|j||j"�
|j#||j$�
q�
Wn�j%r�
t&d	�

n�j'dk	r�t(j)�j'�
\}}
|
j*d
�
rdt+j,_-nyt.||
�}Wn^t/k
rH


t0df}YnAt1k
r�
}	
z!t2j3�
t4t5|	�
f}WYdd}	~	Xn
Xtjj6�
t7�
t7t(j8|�
�

tj9d�

ng�g�
g�	g�g�d}
�j:r.yddl}Wn%t;k
r$


t7d
�

d�_:Yq.Xg}n�jrFdt+j,_-n�j<r�t=j>j?t@d�}y7tA|d��"}
|
jB�jC�}|g
}WdQXWq�tDk
r�


Yq�Xn�jErWg}tAt=j>j?t	jF�jE��
�o}
tGjHd�
}xV|
D]N}|jId|�}|jJ�}|r�|djKd�
r�|jL|�

q�q�WWdQXntM�jN�

tM|�

tOdd�}tPjQ�}�jRr�x:�jND]/}||kr�|jS|�

n|jT|�

q�Wg�_Nn�jUs�jVs�jWp�j<p|p�jNr�t7dtXjY�tjZjJ��
t7dtXjXdd�
dtj[�
t7ddtj\j]tj^dUkrydnd�
t7dt=j_��
t7dtj`�
n�jar�tb�jatc�td��}ntb�ja||�}|p��jNp�|}�j<rM|dd�}y||je|d�
d}WqMtfk
rI


d}YqMXn�jgr�y|d|je�jg�
�=Wq�thk
r�


t7d�jg�

Yq�Xn�jir��jjdkr�tkjld�
�_jntkjm�jj�

t7d�jj�
tkjn|�

n�jorPddlo}ddlp}|jqdtjrtjs|jt�gd dd!d�}ng�
�jUt	_U�jut	_utjvjw�}�
����	�
fd"d#�}�jxr�tc|�
�
f
d$d%�
}|�}d}d&}n1ty|�
}d'jzt{|�
�
}t{|�
d}�j|rj
ydd(l}m~�
Wn)t;k
rS


t7d)�

tj9d�

Yn
Xdd*lm�} 
tGjHd+�
�| ��t�|�
�����fd,d-����fd.d/�t��j|�
D�
}!x|!D]}"|"jg�
q�Wd}#d}$y9
x2
|#�j|kr&
�j*�\}%}&}'}|%dkr8	|#d7}#q�n||%|�
�jWs�	�
rZ	d0nd1}(t7|(jz||$|t{�
�
|%��

n|&r�	t7|&�

n|'r�	t7|'d2tj��


ntjj6�
tj�j6�
|dt0kr�	t/�
n|dt4kr
t�d3jz|%|d��
�
n|$d7}$q�WWn!t/k
rK



d}
d�_�Yn
Xx�
|!D]}"|"j?�
qS
Wn�
x�
t�|d�D]�
\}$}%�jWs�
�
r�
d0nd1}(t7|(jz||$|t{�
�
|%��

tjj6�
n�jor
|j�d4d5t��d6t���

nyySt.|%�jU�jW�jd7�j�d8�j�d9�j�d:�j��}||%|�
Wn#t/k
ro


d}
PYn


�Yn
X�j:r�|j��
|j�r�t7d;t{|j��
d<d=�

t7d>�

|jL|j��

|j�dd�=q�nxBtjvjw�D]1})|)|kr�|)jKd?�
r�t	j�|)�

q�q�Wqz
W|
r�t7�
t7d@�

td|�
td��
td�
�
td�	�
}*t7t�t{|*�
dA�dB�
t�|*�

n�r��jWr��
r��	r�|
r�t{��
dkr�t7dCd<d=�


nt7t�t{��
dA�dD�
n�j�rY
�
j�dEd�

t7dF�

x5�
ddG�D] \}+}%t7dH|%|+f�

q2
Wn�
r�
t7t�t{�
�
dA�dI�
t��
�

n�r�
t7dJjzt�t{��
dA��
�

t���

n�	r�
�jWr�
t7t�t{�	�
dA�dK�
t��	�

n�j�r��
r�t7dL�

x��
dd�D]�}%t7dM|%�

tjj6�
y1d�_Ut.|%d�jW�jd8�j��
},Wnt/k
r�


t7�
PYq X|,dt�t�t�t�hkr �
jS|%�

q q W�
r�t7t�t{�
�
dA�dN�
t��
�

q�n�j<r<|r,tA|dO��}
|
j�|dP�

WdQXq<t=j�|�

n�jors|j��}-|-j�dQddRddS�j��
n�j�r�t=j�dTt=j���

ntj9t{�
�
dkp�|
�

dS)ValExecute a test suite.

    This also parses command-line options and modifies its behavior
    accordingly.

    tests -- a list of strings containing test names (optional)
    testdir -- the directory in which to look for tests (optional)

    Users other than the Python test suite will certainly want to
    specify testdir; if it's omitted, the directory containing the
    Python test suite is searched for.

    If the tests argument is omitted, the tests listed on the
    command-line will be used.  If that's empty, too, then all *.py
    files beginning with test_ will be used.

    The other default arguments (verbose, quiet, exclude,
    single, randomize, findleaks, use_resources, trace, coverdir,
    print_slow, and random_seed) allow programmers calling main()
    directly to set the values that would normally be set by flags
    on the command line.
    Zall_threadsT�SIGALRM�SIGUSR1�chainr
Nr
zPress any key to continue...r9F�z%No GC available, disabling findleaks.Z
pynexttestrOz\[\s*\d+/\s*\d+\]�
#z==z==  Zaliasedz	%s-endianzhash algorithm:r� �64bit�32bitzTesting with flags:z1Couldn't find starting test (%s), using all testsi���zUsing random seedZ
ignoredirsr,r%cs�|
\}}�j||f�

|t
kr;�j|�

n}|tkrW�j|�

na|tkrs�
j|�

nE|tkr��j|�

n)|tkr��j|�

�j|�

ndS)
N)r*�PASSED�FAILED�ENV_CHANGED�SKIPPED�RESOURCE_DENIED)�test�result�ok�	test_time)�bad�environment_changed�good�resource_denieds�skipped�
test_timesrr	�accumulate_result�s













zmain.<locals>.accumulate_resultc
3s+x$x|D]}
|
V
�r
dSq
WqWdS)
Nr)�testsr�)
r�rr	�test_forever�s






zmain.<locals>.test_foreverrz/{})
�Threadz+Multiprocess option requires thread support)
�Queuez\[\d+ refs, \d+ blocks\]$csB
y
x
yt��
}Wn#t
k
r;


�jd�

dSYn
Xt|�
�\}
}}�jd
|�}|j�jd�
\}}}|
dkr�td|
f}�j||j�|j�|f�

dS|s��jd�

dSt	j
|�
}�j||j�|j�|f�

qWWn"tk
r=



�jd�

�Yn
XdS)Nr��

r
zExit code %s)NNNN)NNNN)NNNN)�next�
StopIterationZputr��sub�strip�
rpartition�CHILD_ERROR�rstripr|�loads�
BaseException)r�r�rurv�
_r�)�debug_output_patrm�output�pendingrr	�work�s,







	




%






-




zmain.<locals>.workc
sg|]}
�d�
�
�qS)
�targetr)r�
i)r�r�rr	r
�s	zmain.<locals>.<listcomp>z[{1:{0}}{2}/{3}] {4}z[{1:{0}}{2}] {4}�filezChild error on {}: {}z7runtest(test, ns.verbose, ns.quiet, timeout=ns.timeout)�globals�localsrtrgr^r)zWarning: test created�end�
 zuncollectable object(s).ztest.z(Test suite interrupted by signal SIGINT.r�zomitted:ZAllzOK.�reversez10 slowest tests:�
z	%s: %.1fszfailed:z%{} altered the execution environment:zskipped:z'Re-running failed tests in verbose modez"Re-running test %r in verbose modez
failed again:�
wr�Zshow_missingZsummaryr-zleaks %dl)�rh�enablerb�signalr*r�r��register�replace_stdoutrZrecord_original_stdoutryrurq�argvr9�warm_cachesrfZset_memlimitZ	threshold�gcZ
set_thresholdZ	nowindows�msvcrtZSetErrorModeZSEM_FAILCRITICALERRORSZSEM_NOALIGNMENTFAULTEXCEPTZSEM_NOGPFAULTERRORBOXZSEM_NOOPENFILEERRORBOXZCrtSetReportMode�AttributeErrorZCRT_WARNZ	CRT_ERRORZ
CRT_ASSERTZCRTDBG_MODE_FILEZCrtSetReportFileZCRTDBG_FILE_STDERRr�inputr�r|r��get�unittestZ
BaseTestSuite�_cleanup�runtest�KeyboardInterrupt�INTERRUPTEDr��	traceback�	print_excr��str�flushrir}�exitrW�ImportErrorrTrrr=�TEMPDIR�open�readr��OSErrorrVr>�re�compiler�rA�
startswith�extend�removepyr.�STDTESTS�NOTTESTS�copyrSrk�addrQr]rR�platformZpython_implementation�version�	byteorder�	hash_info�	algorithm�maxsize�getcwd�flagsrP�	findtests�list�set�index�
IndexError�start�
ValueErrorrUr(�randomZ	randrangeZseedZshuffler,�tempfileZTrace�base_prefix�base_exec_prefix�
gettempdirrX�modules�keysr\�iter�formatrBr+�	threadingr�Zqueuer��MultiprocessTests�rangerv�	Exception�interrupted�	enumerateZrunctxr��varsr[rgr^r)�collectZgarbage�unloadr%�	printlistr'�sortrZr�r�r�r��write�unlinkZresultsZ
write_resultsr-rY�system�getpid).r�rlZsignalsZsignumr�r��
mr.r��
er�Z
found_garbage�filename�fpZ	next_testZ	count_pat�lineZguts�stdtests�nottests�argZalltestsZselectedZnext_single_testr,r�ZtracerZsave_modulesr�r�Z
test_countZtest_count_widthr�ZworkersZworkerZfinishedZ
test_indexr�rurvZfmt�moduleZomitted�timer�rOr)r�r�r�r�r�rmr�r�r�r�r�r�r	�main�
s






	






	









	













%









	






		
	







	

$











	




4





	

	





	





	





	






!	
	

	

	









	

%














	

	
	











	










	

	


	


	
	









	


	








*




'


	










	














	







	


	

"	
r
Ztest_grammarZtest_opcodesZ	test_dictZtest_builtinZtest_exceptionsZ
test_typesZ
test_unittestZtest_doctestZ
test_doctest2Ztest_supportc	Cs�t|�
}t
j|�
}g}t|
�
|B}xd|D]\}t
jj|�
\}}|d
d�dkr8|dkr8||kr8|j|�

q8q8W|
t|�
S)z-Return a list of all applicable test modules.NrZtest_�.pyr�)r
r�)�findtestdirr�listdirr�r�splitextr*�sorted)	rPr	
r

�namesr�Zothersr~�mod�extrrr	r�cs






.

r�c@s:eZ
dZd
Zdd�Zdd�Zdd�ZdS)	r�z8A thread-safe iterator over tests for multiprocess mode.cCs%d
|_t
j�|_|
|_dS)NF)r�r�ZLock�lockr�)rr�rrr	�__init__ts
	

zMultiprocessTests.__init__c


Cs|S)
Nr)
rrrr	�__iter__ys
zMultiprocessTests.__iter__c

	Cs9|j�*
|j
r"td
�
�
nt|j�
SWdQXdS)Nztests interrupted)r
r�r�r�r�)
rrrr	�__next__|s


	

zMultiprocessTests.__next__N)rrr�__doc__r
r
r
rrrr	r�psr�cskd
dl}t
j�t�j�dd�jddddd	d
�t
_�f
dd�}
|j|
�

dS)
z�Set stdout encoder error handler to backslashreplace (as stderr error
    handler) to avoid UnicodeEncodeError when printing a tracebackr
Nr��encoding�errors�backslashreplace�closefdF�newliner�cstj
j�
�t_
dS)
N)ryru�closer)
rurr	�restore_stdout�s


z&replace_stdout.<locals>.restore_stdout)�atexitryrur��filenor
r�)r#
r"
r)
rur	r��s	

	


r�Fc	Cs�
|d
k	r|t_
n|d
k	}	|	r@tj|dd�


nz0
|t_|r^dt_n|rF
dt_tjd
kr�t	j
�}
|
t_n tj}
|
jd�

|
j�
t
j}t
j}zg|
t
_|
t
_t||
||dd�
}
|
dtkr,
|
j�}|j|�

|j�
nWd
|t
_|t
_Xn%|
t_t||
||d|
�
}
|
SWd
|	r�
tj�
nt||
�
Xd
S)aRun a single test.

    test -- the name of the test
    verbose -- if true, print more messages
    quiet -- if true, don't print 'skipped' messages (probably redundant)
    huntrleaks -- run multiple times to test for leaks; requires a debug
                  build; a triple corresponding to -R's three arguments
    use_resources -- list of extra resources to use
    output_on_failure -- if true, display test output on failure
    timeout -- dump the traceback and exit if a test takes more than
               timeout seconds
    failfast, match_tests -- See regrtest command-line flags for these.

    Returns the tuple result, test_time, where result is one of the constants:
        INTERRUPTED      KeyboardInterrupt when run under -j
        RESOURCE_DENIED  test skipped because resource denied
        SKIPPED          test skipped for some other reason
        ENV_CHANGED      test failed because it changed the execution environment
        FAILED           test failed
        PASSED           test passed
    Nr�Tr
�display_failureF)rrXrhr`r)r^rQr��stringio�io�StringIO�seek�truncateryrurv�
runtest_innerr��getvaluer
r�Zcancel_dump_traceback_later�cleanup_test_droppings)r�rQrRr9rXrtr^r)rgZuse_timeout�streamZorig_stdoutZorig_stderrr�r�rrr	r��sJ





	



	

	



	
	

	
	

	




	

	






r�c@s�eZ
dZd
ZdZdddd�Zd�Zdd�Zdd�Zd d!�Z	d"d#�Z
d$d%�Zd&d'�Zd(d)�Z
d*d+�Zd,d-�Zd.d/�Zd0d1�Zd2d3�Zd4d5�Zd6d7�Zd8d9�Zd:d;�Zd<d=�Zd>d?�Zd@dA�ZdBdC�ZdDdE�ZdFdG�ZdHdI�ZdJdK�ZdLdM�ZdNdO�Z dPdQ�Z!dRdS�Z"dTdU�Z#dVdW�Z$dXdY�Z%dZd[�Z&d\d]�Z'd^d_�Z(d`da�Z)dbdc�Z*ddde�Z+dfdg�Z,dhdi�Z-djdk�Z.dldm�Z/dndo�Z0dpdq�Z1drds�Z2dtdu�e3e4�
D�
Z5dvdw�Z6dxdy�Z7dzd{�Z8d|d}�Z9d~d�Z:d�d��Z;d�d��Z<d�S)��saved_test_environmenta�
Save bits of the test environment and restore them at block exit.

        with saved_test_environment(testname, verbose, quiet):
            #stuff

    Unless quiet is True, a warning is printed to stderr if any of
    the saved items was changed by the test.  The attribute 'changed'
    is initially False, but is set to True if a change is detected.

    If verbose is more than 1, the before and after state of changed
    items is also printed.
    Fr
cCs|
|_||_
||_dS)
N)r�rQrR)rr�rQrRrrr	r
�s
	
	
zsaved_test_environment.__init__�sys.argvrx�	sys.stdin�
sys.stdout�
sys.stderr�
os.environ�sys.path�sys.path_hooks�
__import__�warnings.filters�asyncore.socket_map�logging._handlers�logging._handlerList�sys.gettrace�sys.warnoptions�!multiprocessing.process._dangling�threading._dangling�sysconfig._CONFIG_VARS�sysconfig._INSTALL_SCHEMES�files�locale�warnings.showwarningc

Cs&tt
j�
t
jt
jdd�fS)
N)�idryr�)
rrrr	�get_sys_argvs
z#saved_test_environment.get_sys_argvcCs(|
d
t_
|
dtj
dd�<dS)Nr
r)ryr�)rZ
saved_argvrrr	�restore_sys_argvs


z'saved_test_environment.restore_sys_argvc


Cs
tj
�S)
N)rr�)
rrrr	�get_cwds
zsaved_test_environment.get_cwdcCstj
|
�

dS)
N)r�chdir)rZ	saved_cwdrrr	�restore_cwds
z"saved_test_environment.restore_cwdc


Cstj
S)
N)ryru)
rrrr	�get_sys_stdouts
z%saved_test_environment.get_sys_stdoutcCs
|
t_
dS)
N)ryru)rZsaved_stdoutrrr	�restore_sys_stdouts
z)saved_test_environment.restore_sys_stdoutc


Cstj
S)
N)ryrv)
rrrr	�get_sys_stderr s
z%saved_test_environment.get_sys_stderrcCs
|
t_
dS)
N)ryrv)rZsaved_stderrrrr	�restore_sys_stderr"s
z)saved_test_environment.restore_sys_stderrc


Cstj
S)
N)ry�stdin)
rrrr	�
get_sys_stdin%s
z$saved_test_environment.get_sys_stdincCs
|
t_
dS)
N)ryrO
)rZsaved_stdinrrr	�restore_sys_stdin's
z(saved_test_environment.restore_sys_stdinc

Cs"tt
j�
t
jtt
j�
fS)
N)rE
r�environr{)
rrrr	�get_os_environ*s
z%saved_test_environment.get_os_environcCs2|
d
t_
tj
j�
tj
j|
d�

dS)Nr
r)rrR
�clear�update)rZ
saved_environrrr	�restore_os_environ,s




z)saved_test_environment.restore_os_environc

Cs&tt
j�
t
jt
jdd�fS)
N)rE
ryr)
rrrr	�get_sys_path1s
z#saved_test_environment.get_sys_pathcCs(|
d
t_
|
dtj
dd�<dS)Nr
r)ryr)rZ
saved_pathrrr	�restore_sys_path3s


z'saved_test_environment.restore_sys_pathc

Cs&tt
j�
t
jt
jdd�fS)
N)rE
ry�
path_hooks)
rrrr	�get_sys_path_hooks7s
z)saved_test_environment.get_sys_path_hookscCs(|
d
t_
|
dtj
dd�<dS)Nr
r)ryrY
)rZsaved_hooksrrr	�restore_sys_path_hooks9s


z-saved_test_environment.restore_sys_path_hooksc


Cs
tj
�S)
N)ry�gettrace)
rrrr	�get_sys_gettrace=s
z'saved_test_environment.get_sys_gettracecCstj
|
�

dS)
N)ry�settrace)rZ	trace_fxnrrr	�restore_sys_gettrace?s
z+saved_test_environment.restore_sys_gettracec


Cstj
S)
N)�builtinsr7
)
rrrr	�get___import__Bs
z%saved_test_environment.get___import__cCs
|
t_
dS)
N)r`
r7
)r�import_rrr	�restore___import__Ds
z)saved_test_environment.restore___import__c

Cs&tt
j�
t
jt
jdd�fS)
N)rE
�warnings�filters)
rrrr	�get_warnings_filtersGs
z+saved_test_environment.get_warnings_filterscCs(|
d
t_
|
dtj
dd�<dS)Nr
r)rd
re
)rZ
saved_filtersrrr	�restore_warnings_filtersIs


z/saved_test_environment.restore_warnings_filtersc
Cs+tj
jd
�
}
|
r'|
jj�p*iS)N�asyncore)ryr�r��
socket_mapr�)rrh
rrr	�get_asyncore_socket_mapMs
z.saved_test_environment.get_asyncore_socket_mapcCsEtj
jd
�
}|dk	rA|jdd�

|jj|
�

ndS)Nrh
Z
ignore_allT)ryr�r�Z	close_allri
rU
)rZ	saved_maprh
rrr	�restore_asyncore_socket_mapQs



z2saved_test_environment.restore_asyncore_socket_mapc

Cstj
tj
j�fS)
N)�shutil�_ARCHIVE_FORMATSr�)
rrrr	�get_shutil_archive_formatsWsz1saved_test_environment.get_shutil_archive_formatscCs2|
d
t_
tj
j�
tj
j|
d�

dS)Nr
r
)rl
rm
rT
rU
)r�savedrrr	�restore_shutil_archive_formats\s




z5saved_test_environment.restore_shutil_archive_formatsc

Cstj
tj
j�fS)
N)rl
�_UNPACK_FORMATSr�)
rrrr	�get_shutil_unpack_formatsas
z0saved_test_environment.get_shutil_unpack_formatscCs2|
d
t_
tj
j�
tj
j|
d�

dS)Nr
r
)rl
rq
rT
rU
)rro
rrr	�restore_shutil_unpack_formatscs




z4saved_test_environment.restore_shutil_unpack_formatsc

Cs"tt
j�
t
jt
jj�fS)
N)rE
�loggingZ	_handlersr�)
rrrr	�get_logging__handlershsz,saved_test_environment.get_logging__handlersc
CsdS)
Nr)rZsaved_handlersrrr	�restore_logging__handlersksz0saved_test_environment.restore_logging__handlersc

Cs&tt
j�
t
jt
jdd�fS)
N)rE
rt
Z_handlerList)
rrrr	�get_logging__handlerListosz/saved_test_environment.get_logging__handlerListc
CsdS)
Nr)rZsaved_handlerListrrr	�restore_logging__handlerListrsz3saved_test_environment.restore_logging__handlerListc

Cs&tt
j�
t
jt
jdd�fS)
N)rE
ry�warnoptions)
rrrr	�get_sys_warnoptionsvs
z*saved_test_environment.get_sys_warnoptionscCs(|
d
t_
|
dtj
dd�<dS)Nr
r)ryry
)rZ
saved_optionsrrr	�restore_sys_warnoptionsxs


z.saved_test_environment.restore_sys_warnoptionsc


Csts
dStj
j�S)
N)r��	_danglingr�)
rrrr	�get_threading__dangling~s

z.saved_test_environment.get_threading__danglingcCs+ts
dStj
j�
tj
j|
�

dS)
N)r�r|
rT
rU
)rro
rrr	�restore_threading__dangling�s




z2saved_test_environment.restore_threading__danglingc


Cs'ts
dStj
j�
tj
jj�S)
N)�multiprocessing�processr�r|
r�)
rrrr	�%get_multiprocessing_process__dangling�s


z<saved_test_environment.get_multiprocessing_process__danglingcCs1ts
dStj
jj�
tj
jj|
�

dS)
N)r
r�
r|
rT
rU
)rro
rrr	�)restore_multiprocessing_process__dangling�s



z@saved_test_environment.restore_multiprocessing_process__danglingc

Cs/tj
d
�

ttj�
tjttj�
fS)N�prefix)�	sysconfig�get_config_varrE
�_CONFIG_VARSr{)
rrrr	�get_sysconfig__CONFIG_VARS�s


z1saved_test_environment.get_sysconfig__CONFIG_VARScCs2|
d
t_
tj
j�
tj
j|
d�

dS)Nr
r)r�
r�
rT
rU
)rro
rrr	�restore_sysconfig__CONFIG_VARS�s




z5saved_test_environment.restore_sysconfig__CONFIG_VARSc

Cs"tt
j�
t
jt
jj�fS)
N)rE
r�
�_INSTALL_SCHEMESr�)
rrrr	�get_sysconfig__INSTALL_SCHEMES�s

z5saved_test_environment.get_sysconfig__INSTALL_SCHEMEScCs2|
d
t_
tj
j�
tj
j|
d�

dS)Nr
r)r�
r�
rT
rU
)rro
rrr	�"restore_sysconfig__INSTALL_SCHEMES�s




z9saved_test_environment.restore_sysconfig__INSTALL_SCHEMESc

Cstd
d�t
j�D�
�
S)Nc
ss1|]'}
|
tj
j|
�
r$dnd
V
qdS)�
/r�N)rr�isdir)r�fnrrr	�	<genexpr>�s
z3saved_test_environment.get_files.<locals>.<genexpr>)r
rr
)
rrrr	�	get_files�s

z saved_test_environment.get_filescCsptj
}||
krl|d
|
krltjj|�
rGtj|�

qltjj|�
rltj|�

qlndS)Nr�
)r�TESTFNrr�isfiler

r�
�rmtree)rZsaved_valuer�
rrr	�
restore_files�s
	




z$saved_test_environment.restore_filesc
Cs.g|]$}
|
jd�
rt
t|
��qS)
ZLC_)r��getattrrC
)r�lcrrr	r
�s	
z!saved_test_environment.<listcomp>c

Cs_g}
xR|jD]G}y#|
j
|tj|d�f�

Wqttfk
rV


wYqXqW|
S)
N)�_lcr*rC
�	setlocalercr�)rZpairingsr�
rrr	�
get_locale�s



#


z!saved_test_environment.get_localecCs+x$|
D]\}}tj
||�
qWdS)
N)rC
r�
)rro
r�
Zsettingrrr	�restore_locale�s

z%saved_test_environment.restore_localec


Cstj
S)
N)rd
�showwarning)
rrrr	�get_warnings_showwarning�s
z/saved_test_environment.get_warnings_showwarningcCs
|
t_
dS)
N)rd
r�
)r�fxnrrr	�restore_warnings_showwarning�s
z3saved_test_environment.restore_warnings_showwarningc
cs^xW|jD]L}
|
j
d
d�}d|}d|}|
t||�t||�fV
q
WdS)N�
.r�Zget_Zrestore_)�	resources�replacer�
)rr~Z
method_suffixZget_nameZrestore_namerrr	�
resource_info�s







z$saved_test_environment.resource_infoc

Cs&td
d�|j
�D�
�
|_|S)Nc
ss'|]\}
}}|
|�fV
qdS)
Nr)rr~r��restorerrr	r�
�sz3saved_test_environment.__enter__.<locals>.<genexpr>)r{r�
�saved_values)
rrrr	�	__enter__�s


z saved_test_environment.__enter__c
Cs�|j}|`x�|j
�D]�\}}}|�}|j|�
}	||	krd
|_||	�

|js�tdj||j�dtj	�


|j
dkr�tdj|	|�dtj	�


q�q�qqWdS)NTz Warning -- {} was modified by {}r�r
z  Before: {}
  After:  {} F)r�
r�
�pop�changedrRrir�r�ryrvrQ)
r�exc_typeZexc_valZexc_tbr�
r~r�r�
ZcurrentZoriginalrrr	�__exit__�s"
	


	

	


	
	




	


zsaved_test_environment.__exit__N)r0
zcwdr1
r2
r3
r4
r5
r6
z
__import__r8
r9
r:
r;
r<
r=
r>
r?
r@
rA
zfileszlocalerD
)=rrrr
r�
r
r�
rF
rG
rH
rJ
rK
rL
rM
rN
rP
rQ
rS
rV
rW
rX
rZ
r[
r]
r_
ra
rc
rf
rg
rj
rk
rn
rp
rr
rs
ru
rv
rw
rx
rz
r{
r}
r~
r�
r�
r�
r�
r�
r�
r�
r�
�dirrC
r�
r�
r�
r�
r�
r�
r�
r�
rrrr	r/
�s~





r/
Tcs�tj
|�

d
}d}y�|jd�
r4|}n
d|}t||
|���}tj�}	tj|�
�t�dd�}
|
dkr��f
dd�}
n|
�
|r�t�||
|�}ntj�|	}WdQXWn�
tj	k
r7

}
z5|s
t
|d|�
tjj
�
nt|fSWYdd}~Xn[
tjk
r�

}
z5|sr
t
|d|�
tjj
�
nt|fSWYdd}~Xn
tk
r�



�Yn�tjk
r
}
zZ|r�
t
d|d	|d
tj�

nt
d|dd
tj�

tjj
�
t|fSWYdd}~Xnt


tj�}t
d|d|d
tj�

tjj
�
t|fSYn.X|rut|fS|jr�t|fSt|fSdS)
NgFztest.Z	test_maincs,tj
�}|j��
}
tj|
�

dS)
N)r�Z
TestLoaderZloadTestsFromModulerZrun_unittest)�loaderr�)
�
the_modulerr	�test_runner�s


z"runtest_inner.<locals>.test_runnerz
skipped --r�z	failed --r��failedz
crashed --)rr�r�r/
r

�	importlib�
import_moduler�
�dash_RZResourceDeniedriryrur�r�r�ZSkipTestr�r�Z
TestFailedrvr�r��
format_excr�
r�r�)r�rQrRr9r%
r�ZrefleakZabstestZenvironmentZ
start_timer�
�msgr)
r�
r	r+
�sZ




	




































	


r+
c	Csj
d
dl}d
dl
}d
dl}|j�
x5
tjdfD]$
}tjj|�
s\q>ntjj	|�
r�d|j
}}n5tjj|�
r�dtj}}nt
d|�
�
|
r�td|||f�

nyAttd�r
tj||j|jB|jB�
n||�

Wq>tk
ra

}
z(td||||fdtj�


WYdd}~Xq>Xq>WdS)	Nr
Zdb_homeZ	directoryr�z8os.path says %r exists but is neither directory nor filez%r left behind %s %r�chmodz3%r left behind %s %r and it couldn't be removed: %s)rl
�statr�r�rr�
rr�existsr�
r�
r�
r

�SystemErrorrirbr�
�S_IRWXU�S_IRWXG�S_IRWXOr�ryrv)	r�rQrl
r�
r�r~ZkindZnukerr�
rrr	r-
"s.



	










$



r-
c s0d
dl}d
dl
�ttd�s6td�
�
ntjdd�}|jj�}tj	j�}yd
dl
}Wntk
r�


d}	YnX|jj�}	i}
xj�f
dd��j
jD�
D]I}t|�
s�q�nx.|j�|g
D]}|jj�|
|<q�Wq�W|\}
}}tjjtj|�}|
|}d
g
|}d
g
|}td|dd	tj�

td
|ddd|�d	tj�


tjj�
x�t|�
D]�}|�
t||||	|
�\}}tjjd
�

tjj�
||
kr.||||<||||<n||}}q�
Wtd	tj�

dd�}dd�}d}x�|d|f|d|fgD]�\}}}||�
r�d|
||
d�|t|�
f}t|d	tj�


tjj�
t|d��!}t|d	|�


|j�
WdQXd}q�q�W|S)z�Run a test multiple times, looking for reference leaks.

    Returns:
        False if the test didn't leak references; True if we detected refleaks.
    r
N�gettotalrefcountz9Tracking reference leaks requires a debug build of Pythonc
s"g|]}
t�j
|
��qSr)r�
�abc)rrp)
�collectionsrr	r
es	zdash_R.<locals>.<listcomp>Z	beginningZrepetitionsr�Z
1234567890r�r
r�
c

Ss
t|�
S)
N)
�any)
�deltasrrr	�check_rc_deltass
zdash_R.<locals>.check_rc_deltasc

SsFd
|jd�
t
|�
kr#dSt|�
dddhk
sBdSdS)Nrr
Tr
F���)r%rBr�)
r�
rrr	�check_alloc_deltas�s



z"dash_R.<locals>.check_alloc_deltasFZ
referencesz
memory blocksz%s leaked %s %s, sum=%srpT)�copyreg�collections.abcrbryr�rd
re
�dispatch_tabler��path_importer_cache�	zipimportr��_zip_directory_cacher�
�__all__r�__subclasses__�
_abc_registryrrr=rr>rirvr�r��dash_R_cleanupr
�sumr�) r�
r�Z
indirect_testr9r�
�fs�ps�picr�
�zdc�abcsr�
�objrDrErFZrepcountZ	rc_deltasZalloc_deltasr�Zalloc_afterZrc_afterZ	rc_beforeZalloc_beforer�
r�
r�
r�
Z	item_nameZcheckerr�
Zrefrepr)
r�
r	r�
Lsh










&











)


















#








r�
cs
d
dl}d
dl
}d
dl}d
dl}d
dl}	d
dl}	d
dl}
d
dl}d
dl}d
dl	}
d
dl
�d
dlm}
d
dl
m}
x/tjj�D]}t|d�r�|`q�q�W|tjdd�<|jj�
|jj|
�

tjj�
tjj|�

yd
dl}Wntk
rG



YnX|jj�
|jj|�

tj�
x��f
dd��jjD�
D]n}t |�
s�
q�
nxS|j!�|g
D]>}|j"||��j#�|_$|j%j�
|j&j�
q�
Wq�
Wx?tj'tj(tj)tj*fD]}|dk	r |j+�
q q W|j�
t,j-�
|j.j�
|	j/j0�
|	j1j2�
|j3�
|
j4�
|
j5j�
|j6�
d|_7yd
dl8}Wntk
r�


YnX|j9�
tj:}tj;}|j<�
|�|�fS)Nr
)
�
_path_created)
�WeakSet�__warningregistry__c
s"g|]}
t�j
|
��qSr)r�
r�
)rrp)
r�
rr	r
�s	z"dash_R_cleanup.<locals>.<listcomp>)=r�r�
�	_strptime�	linecacheZurllib.parseZurllib.request�	mimetypes�doctest�struct�filecmpr�
Zdistutils.dir_utilr�
�weakrefr�
ryr��valuesrbr�
rd
re
r�
rT
rU
r�
r�
r�r�
�_clear_type_cacher�
r�
rr�
r�r�r�
�
_abc_cache�_abc_negative_cacherurv�
__stdout__�
__stderr__r�r��purgeZ_regex_cache�parseZclear_cacheZrequestZ
urlcleanup�
clearcacheZ_default_mime_types�_cacheZ_clearcacheZmaster�ctypesZ_reset_cache�getallocatedblocksr�
r�)r�
r�
r�
r�
r�
r�r�
r�
r�
Zurllibr�
r�
r�
r�
r�
r�
r
r�
r�
r�
r.
r�
Zfunc1Zfunc2r)
r�
r	r�
�sd


0
$


















&






%



















	




	
	


r�
cCsmtt
d
�
�
}x&t
d
�
D]}
||
|
d�
qWdd�t
d
�
D�
}tt
dd��
}dS)N�
r
c
Ssg|]}
t|
�
�qSr)
�chr)rr�rrr	r
�s	zwarm_caches.<locals>.<listcomp>ri

���)�bytesr�r�)�
sr�rHrrr	r��s


r�c

Cs|ptj
jt�
ptjS)
N)rr�dirnamer�curdir)
rrrr	r
�s
r
c
Cs\|s
dSxKt|�
D]=\}
}t
jj|�
\}}|d
kr|||
<qqWdS)Nz.py)r�rrr
)r
�idxr~�basenamer
rrr	r��s





r�cCs,|d
krd||
fSd||
fSdS)Nr
z%d %sz%d %ssr)�
nZwordrrr	r%�s

r%�FcCsYd
dlm
}
d|}t|djdd�t|�
D�
�
|
d|d|��

dS)	z�Print the elements of iterable x to stdout.

    Optional arg width (default 70) is the maximum line length.
    Optional arg indent (default 4) is the number of blanks with which to
    begin each line.
    r
)
�fillr�c
ss|]}
t|
�
V
qdS)
N)
r�)rZeltrrr	r�
szprintlist.<locals>.<genexpr>Zinitial_indentZsubsequent_indentN)�textwrapr�
rir=r
)rH�width�indentr�
Zblanksrrr	r��s

+
r�c
Cs�tj
�r5ytjt�

Wq5tk
r1


Yq5Xnd
jtj��
}tjj	t|�}t
j|dd�

�
t�
WdQXdS)z,Run main() in a temporary working directory.ztest_python_{}rRTN)
r�
�is_python_buildr�mkdirr��FileExistsErrorr�r
rr=rZtemp_cwdr
)
Ztest_cwdrrr	�main_in_temp_cwds






r�
�__main__)dr
r0r1r2r�
r3r`
rhr'
r|rC
rt
rr�r�r�rl
r�ryr�
r�r

r�r�rd
�inspectrr�r�Z_multiprocessingZmultiprocessing.processr
r�r�
r
rbrrrrZresourceZ	getrlimitZRLIMIT_STACKZsoftZhard�min�maxZnewsoftZ	setrlimitr�r�r�r�r�r�r�r�rrMr�
r=r�
r�r��ArgumentParserrr<r8r9r7rqr�r
r�r�r�r��objectr�r�r�r&
r/
r+
r-
r�
r�
r�r
r�r%r�r�
r�normpathr�
r�ZmydirrBr�rrrr	�<module>s�
_

































	














!
q
F ��








		

	
E	
�9*LF
1




+