403Webshell
Server IP : 121.121.20.254  /  Your IP : 216.73.216.202
Web Server : Microsoft-IIS/10.0
System : Windows NT WEB-SERVER 10.0 build 20348 (Windows Server 2022) AMD64
User : IUSR ( 0)
PHP Version : 8.3.28
Disable Function : NONE
MySQL : ON  |  cURL : ON  |  WGET : OFF  |  Perl : OFF  |  Python : OFF  |  Sudo : OFF  |  Pkexec : OFF
Directory :  /Python313/Lib/test/__pycache__/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Command :


[ Back ]     

Current File : /Python313/Lib/test/__pycache__/test_regrtest.cpython-313.opt-2.pyc
�

��i�����SSKrSSKrSSKrSSKrSSKrSSKrSSKrSSKrSSK	r	SSK
r
SSKrSSKrSSK
r
SSKrSSKrSSKrSSKrSSKJr SSKJr SSKJrJr SSKJr SSKJr SSKJr SSKJr SS	KJrJ r J!r! SS
K"J#r# SSK$J%r% \RL(d\RN"S5e\RPRS\RPRU\+5S
S
5r,\RPR[\RPR]\,55r,Sr/Sr0SSRS\05S3r0Sr1Sr2Sr3Sr4Sr5\Rl"S5r7"SS\Rp5r9\Rt"SS9"SS55r;"SS \Rp5r<"S!S"\<5r=\R|"S#S$\<55r?\R|"S%S&\<55r@"S'S(\Rp5rA\BS):Xa\R6"5 gg)*�N)�ElementTree)�support)�	os_helper�without_optimizer)�cmdline)�main)�setup)�utils)�get_match_tests�set_match_tests�
match_test)�	TestStats)�normalize_test_nameztest module requires subprocessz..z5[0-9]+:[0-9]+:[0-9]+ (?:load avg: [0-9]+\.[0-9]{2} )?)�passed�failed�skipped�interruptedzenv changedz	timed outzran no testszworker non-zero exit codez(?:�|�)�����z�
    from signal import SIGINT, raise_signal
    try:
        raise_signal(SIGINT)
    except ImportError:
        import os
        os.kill(os.getpid(), SIGINT)
    c��\rSrSr\S5rSrSrSrSr	Sr
SrS	rS
r
SrSrS
rSrSrSrSrSrSrSrSrSrSrSrSrSrSrSr\ RB"\"RFS5S5r$Sr%S r&S!r'S"r(S#r)S$r*S%r+S&r,S'r-S(r.S)r/S*r0S+r1S,r2S-S-S-S..S/jr3S0r4S1r5S2r6S3r7S4r8S5r9S6r:S7r;S8r<S9r=S:r>g;)<�ParseArgsTestCase�Fc�.�[R"U5$�N)r�_parse_args)�argss �'C:\Python313\\Lib\test\test_regrtest.py�
parse_args�ParseArgsTestCase.parse_argsKs���"�"�4�(�(�c� �[R"5o0R[5 UR	U5 SSS5 SSS5 URUWR
55 g!,(df   N7=f!,(df   N@=fr)r�captured_stderr�assertRaises�
SystemExitr#�assertIn�getvalue)�selfr!�msg�errs    r"�
checkError�ParseArgsTestCase.checkErrorOsU��
�
$�
$�
&�#�/@�/@��/L��O�O�D�!�0M�
&��
�
�c�3�<�<�>�*�0M�/L��
&�
&�s!�A?�A.�A?�.
A<	�8A?�?
B
c	��SH�nURUS9 [R"5nUR[5 URU/5 SSS5 SSS5 UR
SWR55 SSS5 M� g!,(df   NC=f!,(df   NL=f!,(df   M�=f)N)z-hz--help��optzRun Python regression tests.)�subTestr�captured_stdoutr(r)r#r*r+)r,r3�outs   r"�	test_help�ParseArgsTestCase.test_helpTs���!�C����#��&��,�,�.�#��&�&�z�2��O�O�S�E�*�3�/��
�
�<�c�l�l�n�M�	'�&�"�3�2��/�.��'�&�s:�B3�B"�B	�B"�(B3�
B
�B"�"
B0�,B3�3
C	c�x�URSS/5nURURS5 SHLnURUS9 URSU3/5nURURS5 SSS5 MN UR	S/S5 UR	SS/S	5 g!,(df   M�=f)
N�	--timeoutz4.2g������@)z-1�0�)�valuez
--timeout=�expected one argument�foozinvalid timeout value:)r#�assertEqual�timeoutr4r/)r,�nsr=s   r"�test_timeout�ParseArgsTestCase.test_timeout\s���
�_�_�k�5�1�
2��������S�)�%�E����E��*��_�_�
�5�'�&:�%;�<��� � ����T�2�+�*�%�
	
����
�'>�?�����e�,�.F�G�+�*�s�2B*�*
B9	c�^�URS/5nURUR5 g)N�--wait)r#�
assertTrue�wait�r,rBs  r"�	test_wait�ParseArgsTestCase.test_waitis"��
�_�_�h�Z�
(�������� r%c���SH]nURUS9 URUS/5nURURS5 UR	U/S5 SSS5 M_ g!,(df   Mq=f)N)z-S�--startr2r?r>)r4r#r@�startr/�r,r3rBs   r"�
test_start�ParseArgsTestCase.test_startms`��"�C����#��&��_�_�c�5�\�2��� � ����5�1������'>�?�'�&�#�&�&���AA%�%
A4	c���URS/5nURURS5 URS/5nURURS5 URS/5nURURS5 URS/S-5nURURS5 UR/5nURURS5 g)N�-v�z-vvvr�	--verboser)r#r@�verboserIs  r"�test_verbose�ParseArgsTestCase.test_verbosets���
�_�_�d�V�
$��������Q�'�
�_�_�f�X�
&��������Q�'�
�_�_�k�]�
+��������Q�'�
�_�_�k�]�Q�.�
/��������Q�'�
�_�_�R�
 ��������Q�'r%c���SHHnURUS9 URU/5nURUR5 SSS5 MJ g!,(df   M\=f)N)z-w�--rerunz
--verbose2r2)r4r#rG�rerunrOs   r"�
test_rerun�ParseArgsTestCase.test_rerun�sI��0�C����#��&��_�_�c�U�+��������)�'�&�1�&�&���.A�
A	c���SHHnURUS9 URU/5nURUR5 SSS5 MJ g!,(df   M\=f)N)�-W�
--verbose3r2)r4r#rG�verbose3rOs   r"�
test_verbose3�ParseArgsTestCase.test_verbose3��I��%�C����#��&��_�_�c�U�+��������,�'�&�&�&�&�r_c��SHdnURUS9 URU/5nURUR5 UR	UR
S5 SSS5 Mf g!,(df   Mx=f)N)�-q�--quietr2r)r4r#rG�quietr@rWrOs   r"�
test_quiet�ParseArgsTestCase.test_quiet�s]��"�C����#��&��_�_�c�U�+��������)�� � ����Q�/�'�&�#�&�&�s�A
A,�,
A;	c���SHHnURUS9 URU/5nURUR5 SSS5 MJ g!,(df   M\=f)N)z-o�	--slowestr2)r4r#rG�
print_slowrOs   r"�test_slowest�ParseArgsTestCase.test_slowest�sI��$�C����#��&��_�_�c�U�+������
�
�.�'�&�%�&�&�r_c��URS/5nURUR5 URS/5nURUR5 g)Nz--headerrV)r#rG�headerrIs  r"�test_header�ParseArgsTestCase.test_header�sB��
�_�_�j�\�
*������	�	�"�
�_�_�k�]�
+������	�	�"r%c��SHHnURUS9 URU/5nURUR5 SSS5 MJ [R
"5nSUS'URS/5n[R"U5nURUR5 URUR[5 URURS5 US	URS/5n[R"U5nURUR5 URUR[5 SSS5 g!,(df   GMe=f!,(df   g=f)N)�-r�--randomizer2�
1697839080�SOURCE_DATE_EPOCHrx)r4r#rG�	randomizer�EnvironmentVarGuardr�Regrtest�assertFalse�assertIsInstance�random_seed�strr@�int)r,r3rB�env�regrtests     r"�test_randomize� ParseArgsTestCase.test_randomize�s&��(�C����#��&��_�_�c�U�+��������-�'�&�)�
�
*�
*�
,��'3�C�#�$����-��1�B��}�}�R�(�H����X�/�/�0��!�!�(�"6�"6��<����X�1�1�<�@��'�(����-��1�B��}�}�R�(�H��O�O�H�.�.�/��!�!�(�"6�"6��<�-�
,�	'�&��-�
,�s�.E�$C+E+�
E(	�+
E9c���UR/5nURURS5 URS/5nURURS5 URS/5nURURS5 URSS/5nURURS5 URSS/5nURURS5 g)NFrxT�--no-randomize)r#�assertIsr{rIs  r"�test_no_randomize�#ParseArgsTestCase.test_no_randomize�s���
�_�_�R�
 ���
�
�b�l�l�E�*�
�_�_�m�_�
-���
�
�b�l�l�D�)�
�_�_�.�/�
0���
�
�b�l�l�E�*�
�_�_�m�-=�>�
?���
�
�b�l�l�E�*�
�_�_�.�
�>�
?���
�
�b�l�l�E�*r%c�z�URSS/5nURURS5 URUR5 URS/S5 URSS/S5 UR/SQ5nURURS5 UR
UR5 g)N�
--randseed�12345i90r>r?�invalid int value)r�r�r�)r#r@r�rGr{r/r~rIs  r"�
test_randseed�ParseArgsTestCase.test_randseed�s���
�_�_�l�G�4�
5���������/�������%������(?�@�����u�-�/B�C�
�_�_�F�
G���������/�������&r%c��SHrnURUS9 URUS/5nURURS5 UR	U/S5 UR	USS/S5 SSS5 Mt g!,(df   M�=f)N)�-f�
--fromfiler2r?r>�-s�don't go together)r4r#r@�fromfiler/rOs   r"�
test_fromfile�ParseArgsTestCase.test_fromfile�sv��%�C����#��&��_�_�c�5�\�2��� � ����e�4������'>�?�����e�T� 2�4G�H�	'�&�&�&�&�s�AA:�:
B		c���SHHnURUS9 URU/5nURUR5 SSS5 MJ g!,(df   M\=f)N)�-x�	--excluder2)r4r#rG�excluderOs   r"�test_exclude�ParseArgsTestCase.test_exclude��I��$�C����#��&��_�_�c�U�+������
�
�+�'�&�%�&�&�r_c���SH]nURUS9 URU/5nURUR5 UR	USS/S5 SSS5 M_ g!,(df   Mq=f)N)r�z--singler2r�r?r�)r4r#rG�singler/rOs   r"�test_single�ParseArgsTestCase.test_single�s_��#�C����#��&��_�_�c�U�+������	�	�*�����d�E� 2�4G�H�'�&�$�&�&�rRc��SH^nURUS9 URUS/5nURURS/5 UR	U/S5 SSS5 M` SH^nURUS9 URUS/5nURURS/5 UR	U/S5 SSS5 M` UR/SQ5nURURS	S
/5 UR/SQ5nURURS	S/5 UR/S
Q5nURURSS
/5 UR[R[R5 [[RS5n[SUS9 [SUS9 SSS5 [RR[R5nURSSSU/5nURUR/SQ5 URSSSU/5nURUR/SQ5 g!,(df   GMb=f!,(df   GM=f!,(df   N�=f)N)�-mz--matchr2�pattern)r�Tr>)�-iz--ignore)r�F)r��pattern1r��pattern2)r�T)r�T)r�r�r�r�)r�F)r�r�r�r�)r�F�w�
matchfile1��file�
matchfile2r��match�--matchfile))r�T)r�T)r�Tr��--ignorefile))r�F)r�F)r�F)r4r#r@�match_testsr/�
addCleanupr�unlink�TESTFN�open�print�os�path�abspath)r,r3rB�fp�filenames     r"�
test_match�ParseArgsTestCase.test_match�s��"�C����#��&��_�_�c�9�%5�6��� � ����2C�1D�E������'>�?�'�&�#�$�C����#��&��_�_�c�9�%5�6��� � ����2D�1E�F������'>�?�'�&�$��_�_�A�
B��������*<�>P�)Q�R�
�_�_�A�
B��������*<�>Q�)R�S�
�_�_�A�
B��������*=�?Q�)R�S����	�(�(�)�*:�*:�;�
�)�"�"�C�
(�B��,�R�(��,�R�(�)��7�7�?�?�9�#3�#3�4��
�_�_�d�G�]�H�E�
F��������V�	X��_�_�d�G�^�X�F�
G��������Y�	[�?'�&��'�&��)�
(�s%�AI�9AI(�$I;�
I%	�(
I8	�;
J	c�H�SH�nURUS9 URUS/5nURUR5 URUS/5nURUR5 UR	U/S5 SSS5 M� g!,(df   M�=f)N)z-Gz
--failfastr2rTraz#-G/--failfast needs either -v or -W)r4r#rG�failfastr/rOs   r"�
test_failfast�ParseArgsTestCase.test_failfast
s~��%�C����#��&��_�_�c�4�[�1��������,��_�_�c�4�[�1��������,������'L�M�'�&�&�&�&�s�A0B�
B!	c
�z�SGH�nURUS9 URUS/5nURURSSS.5 URUSUS/5nURURSSS.5 URUS/5nURURSS05 URUSUSUS/5nURURSS05 [R[R5nUS	URUS	/5nURURU5 URU/S
5 URUS/S5 [R[R5nSUS
'URUS/5nURURU5 URUSUS
/5nURURU5 URUS/5nURURSS05 URUS/5nURURSS05 URUS/5nURURSS05 URUS/5nURUR05 URUS/5nURUR05 [R[R5nSUS'URUS/5nURURU5 URUSUS/5nURURU5 URUS/S5 URUS/S5 URUS/S5 SSS5 GM� g!,(df   GM�=f)N)�-uz--user2zgui,network)�gui�networkr�r�zgui,none,network�nonezall,-guir>r?zinvalid resource�tzdataz
all,tzdata�all�extralargefilezxpickle=2.7�xpicklez2.7zxpickle=2.7,xpickle=3.3z3.3zxpickle=2.7,nonezxpickle=2.7,-xpicklezall,xpickle=2.7zall=0zinvalid resource: all=0znone=0zinvalid resource: none=0z
all,-gui=0zinvalid resource: -gui=0)	r4r#r@�
use_resources�dict�fromkeysr�
ALL_RESOURCESr/)r,r3rB�expecteds    r"�test_use�ParseArgsTestCase.test_usesc�� �C����#��&��_�_�c�=�%9�:��� � ��!1�!1�4�D�3Q�R��_�_�c�5�#�y�%A�B��� � ��!1�!1�4�D�3Q�R��_�_�c�+=�%>�?��� � ��!1�!1�I�t�3D�E��_�_�c�5�#�v�s�I�%N�O��� � ��!1�!1�I�t�3D�E��=�=��)>�)>�?���U�O��_�_�c�:�%6�7��� � ��!1�!1�8�<������'>�?�����e��.@�A� �=�=��)>�)>�?��%)���"��_�_�c�<�%8�9��� � ��!1�!1�8�<��_�_�c�5�#�x�%@�A��� � ��!1�!1�8�<��_�_�c�+;�%<�=��� � ��!1�!1�4D�d�3K�L��_�_�c�=�%9�:��� � ��!1�!1�I�u�3E�F��_�_�c�+D�%E�F��� � ��!1�!1�I�u�3E�F��_�_�c�+=�%>�?��� � ��!1�!1�2�6��_�_�c�+A�%B�C��� � ��!1�!1�2�6��=�=��)>�)>�?��&+���#��_�_�c�+<�%=�>��� � ��!1�!1�8�<��_�_�c�5�#�}�%E�F��� � ��!1�!1�8�<�����g��0I�J�����h��1K�L�����l� 3�5O�P�g'�&�!�&�&�s�NN*�*
N:	c���SH]nURUS9 URUS/5nURURS5 UR	U/S5 SSS5 M_ g!,(df   Mq=f)N)z-Mz
--memlimitr2�4Gr>)r4r#r@�memlimitr/rOs   r"�
test_memlimit�ParseArgsTestCase.test_memlimitJs`��%�C����#��&��_�_�c�4�[�1��� � ����d�3������'>�?�'�&�&�&�&�rRc���URSS/5nURUR[RR[RS55 URS/S5 g)Nz	--testdirr?r>)	r#r@�testdirr�r��joinr�SAVEDCWDr/rIs  r"�test_testdir�ParseArgsTestCase.test_testdirQsO��
�_�_�k�5�1�
2��������R�W�W�\�\�)�2D�2D�e�%L�M�����
�'>�?r%c���SHHnURUS9 URU/5nURUR5 SSS5 MJ g!,(df   M\=f)N)z-Lz
--runleaksr2)r4r#rG�runleaksrOs   r"�
test_runleaks�ParseArgsTestCase.test_runleaksVrfr_c��SGH'nURUS9 URUS/5nURURS5 URUS/5nURURS5 URUS/5nURURS5 URUS	/5nURURS
5 UR	U/S5 UR	US/S
5 UR	US/S5 UR	US/S5 SSS5 GM* g!,(df   GM==f)N)�-R�--huntrleaksr2�:)rr�
reflog.txtz6:)�rr�z:3)rrr�z
6:3:leaks.log)r�rz	leaks.logr>�6z&needs 2 or 3 colon-separated argumentszfoo:zinvalid huntrleaks valuez6:foo)r4r#r@�
huntrleaksr/rOs   r"�test_huntrleaks�!ParseArgsTestCase.test_huntrleaks\s��'�C����#��&��_�_�c�3�Z�0��� � ����0D�E��_�_�c�4�[�1��� � ����0D�E��_�_�c�4�[�1��� � ����0D�E��_�_�c�?�%;�<��� � ����0C�D������'>�?�����c�
� H�J�����f�
�/I�J�����g��0J�K�'�&�(�&�&�s�DD0�0
E	c��SHqnURUS9 URUS/5nURURS5 UR	U/S5 UR	US/S5 SSS5 Ms g!,(df   M�=f)N)�-jz--multiprocessr2�2rr>r?r�)r4r#r@�use_mpr/rOs   r"�test_multiprocess�#ParseArgsTestCase.test_multiprocessmss��)�C����#��&��_�_�c�3�Z�0��� � ����A�.������'>�?�����e��.A�B�	'�&�*�&�&���AA9�9
B	c�b�SH�nURUS9 [R"5nURU/5nSSS5 UR	WR
5 UR
SWR55 SSS5 M� g!,(df   NV=f!,(df   M�=f)N�z-T�
--coverager2z+collecting coverage without -j is imprecise)r4rr'r#rG�tracer*r+)r,r3�stderrrBs    r"�test_coverage_sequential�*ParseArgsTestCase.test_coverage_sequentialus~��%�C����#��&��,�,�.�&����#��/�B�/�������)��
�
�A��O�O�%��	'�&�&�.�.��'�&�s"�B�B�AB�
B�B�
B.	�need a debug buildc���SHInURUS9 URUS/5nURUR5 SSS5 MK g!,(df   M]=f)Nr�r2�-j1)r4r#rGr�rOs   r"�test_coverage_mp�"ParseArgsTestCase.test_coverage_mp�sK��%�C����#��&��_�_�c�5�\�2��������)�'�&�&�&�&�s�/A�
A 	c	�F�SH�nURUS9 URUS/5nURUR[R
R
[RS55 URU/S5 SSS5 M� g!,(df   M�=f)N)z-Dz
--coverdirr2r?r>)
r4r#r@�coverdirr�r�r�rr�r/rOs   r"�
test_coverdir�ParseArgsTestCase.test_coverdir�sy��%�C����#��&��_�_�c�5�\�2��� � ����!#�����i�.@�.@�%�!H�J������'>�?�	'�&�&�&�&�s�A/B�
B 	c���SHHnURUS9 URU/5nURUR5 SSS5 MJ g!,(df   M\=f)N)z-Nz--nocoverdirr2)r4r#�assertIsNonerrOs   r"�test_nocoverdir�!ParseArgsTestCase.test_nocoverdir�sK��'�C����#��&��_�_�c�U�+���!�!�"�+�+�.�'�&�(�&�&�r_c��SHqnURUS9 URUS/5nURURS5 UR	U/S5 UR	US/S5 SSS5 Ms g!,(df   M�=f)N)z-tz--thresholdr2�1000��r>r?r�)r4r#r@�	thresholdr/rOs   r"�test_threshold� ParseArgsTestCase.test_threshold�ss��&�C����#��&��_�_�c�6�]�3��� � ����t�4������'>�?�����e��.A�B�	'�&�'�&�&�r�c��SH�nURUS9 [R"[R"55nURU/5nSSS5 UR
WR5 WR5nURSU5 SSS5 M� g!,(df   NX=f!,(df   M�=f)N)�-nz--nowindowsr2z)the --nowindows (-n) option is deprecated)
r4�
contextlib�redirect_stderr�io�StringIOr#rG�	nowindowsr+r*)r,r3r�rBr.s     r"�test_nowindows� ParseArgsTestCase.test_nowindows�s���&�C����#��&��/�/����
�>�&����#��/�B�?�������-��o�o�'���
�
�I�3�O�'�&�'�>�>��'�&�s#�*B5�B$�AB5�$
B2�.B5�5
C	c���SHHnURUS9 URU/5nURUR5 SSS5 MJ g!,(df   M\=f)N)z-F�	--foreverr2)r4r#rG�foreverrOs   r"�test_forever�ParseArgsTestCase.test_forever�r�r_c�*�URS/S5 g)Nz--xxxzusage:�r/�r,s r"�test_unrecognized_argument�,ParseArgsTestCase.test_unrecognized_argument�s������	�8�,r%c��URS/5nURUR5 URURS5 g)Nz--quir)r#rGrjr@rWrIs  r"�test_long_option__partial�+ParseArgsTestCase.test_long_option__partial�s6��
�_�_�g�Y�
'��������!�������Q�'r%c���URSS/5nURUR5 URURS5 URUR
5 g)Nrir�r)r#rGrjr@rWr�rIs  r"�test_two_options�"ParseArgsTestCase.test_two_options�sI��
�_�_�i��5�
6��������!�������Q�'�����
�
�#r%c�b�URSS/5nURURS5 g)NrMr<)r#r@rNrIs  r"�#test_option_with_empty_string_value�5ParseArgsTestCase.test_option_with_empty_string_value�s(��
�_�_�i��_�
-��������2�&r%c�b�URS/5nURURS/5 g)Nr?)r#r@r!rIs  r"�test_arg�ParseArgsTestCase.test_arg�s(��
�_�_�e�W�
%��������5�'�*r%c���URSS/5nURUR5 URURS5 URUR
S/5 g)Nrir?r)r#rGrjr@rWr!rIs  r"�test_option_and_arg�%ParseArgsTestCase.test_option_and_arg�sO��
�_�_�i��/�
0��������!�������Q�'�������5�'�*r%c��UR/SQ5nURURS5 URURSS/5 g)N)�test_unaryoprT�
test_binoprUr1r2)r#r@rWr!rIs  r"�test_arg_option_arg�%ParseArgsTestCase.test_arg_option_arg�s>��
�_�_�A�
B��������Q�'�������>�<�"@�Ar%c�*�URS/S5 g)Nz--unknown-optionz(unrecognized arguments: --unknown-optionrrs r"�test_unknown_option�%ParseArgsTestCase.test_unknown_option�s�����+�,�B�	Dr%c���[R"U5n[R"5nUS	[R
"U5nSSS5 U$!,(df   W$=f)Nrz)rr rr|rr})r,r!rBr�r�s     r"�create_regrtest�!ParseArgsTestCase.create_regrtest�sU��
�
 �
 ��
&���
*�
*�
,���'�(��}�}�R�(�H�	-���
-�
,���s�A�
AT)r\r{�output_on_failurec�$�URU5nURURS5 URURU5 URURS5 URUR
U5 UR
UR[5 URUR5 URUR5 URURU5 URURU5 U$)N���F)r9r@�num_workers�
want_rerun�
fail_rerunr{rr�r�rG�fail_env_changed�
print_slowestr;r�)r,r!r�r\r{r;r�s       r"�
check_ci_mode�ParseArgsTestCase.check_ci_mode�s����'�'��-������-�-�r�2�����,�,�e�4�����,�,�e�4�����+�+�Y�7����h�2�2�C�8�����1�1�2�����.�.�/�����3�3�5F�G�����/�/��?��r%c��S/n[R[R5nUS	UR	X5nURURS5 g)N�	--fast-ci�cpu�X�r�r�rr�rCr@rA�r,r!r�r�s    r"�test_fast_ci�ParseArgsTestCase.test_fast_ci�sK���}���
�
�g�&;�&;�<�
��%� ��%�%�d�:������)�)�7�3r%c���/SQn[R[R5nUS	UR	XSS9nURURS5 URURS5 g)N)rF�--pythonz
python -X devrGF)r\rH)�python�-X�dev)r�r�rr�rCr@rA�
python_cmdrJs    r"�test_fast_ci_python_cmd�)ParseArgsTestCase.test_fast_ci_python_cmd�se��9���
�
�g�&;�&;�<�
��%� ��%�%�d��%�G������)�)�7�3�����,�,�.E�Fr%c��SS/n[R[R5nUS	US	UR	X5 g)NrFz
-u-networkrGr��r�r�rr�rC)r,r!r�s   r"�test_fast_ci_resource�'ParseArgsTestCase.test_fast_ci_resource�s>���\�*���
�
�g�&;�&;�<�
��%� ��)�$����4�/r%c��SS/n[R[R5nUS	UR	XSS9nURURS5 g)NrFrVrGF)r;T)r�r�rr�rCr@rWrJs    r"�test_fast_ci_verbose�&ParseArgsTestCase.test_fast_ci_verbosesX���[�)���
�
�g�&;�&;�<�
��%� ��%�%�d�8=�&�?������)�)�4�0r%c��S/n[R[R5nUR	X5nURURS5 g)N�	--slow-cii�rIrJs    r"�test_slow_ci�ParseArgsTestCase.test_slow_cisC���}���
�
�g�&;�&;�<�
��%�%�d�:������)�)�7�3r%c��[R[R5nUR	SS/USS9 US	UR	SS/USS9 g)Nr]r�F)r{rGrFrV)r,r�s  r"�test_ci_no_randomize�&ParseArgsTestCase.test_ci_no_randomizes`���
�
�g�&;�&;�<�
����
�*�+�]�e�	�	
�
�%� ����
�*�+�]�e�	�	
r%c�l�S/n[R"U5nURUR5 g)Nz--dont-add-python-opts)rr r~�_add_python_opts)r,r!rBs   r"�test_dont_add_python_opts�+ParseArgsTestCase.test_dont_add_python_optss.��(�)��
�
 �
 ��
&������,�,�-r%c�b�S/nURU5nURUR5 g)N�--bisect)r9rG�want_bisect�r,r!r�s   r"�test_bisect�ParseArgsTestCase.test_bisect s+���|���'�'��-������,�,�-r%c��/SQn[R"5 URU5nSSS5 URWR5 URURRS5 URURRS5 URUR5 g!,(df   N�=f)N)r�z3:10rbr�
)
rr'r9�assertIsNotNone�hunt_refleakr@�warmups�runsr~r;rjs   r"�test_verbose3_huntrleaks�*ParseArgsTestCase.test_verbose3_huntrleaks%s���+��
�
$�
$�
&��+�+�D�1�H�'����X�2�2�3�����.�.�6�6��:�����.�.�3�3�R�8�����3�3�4�'�
&�s�B7�7
Cc���SS/n[R"5 URU5nSSS5 URWRS5 URUR5 SS/n[R"5 URU5nSSS5 URURS5 URUR5 g!,(df   N�=f!,(df   NW=f)N�-j2z--single-processrrF)rr'r9r@r>rG�single_processrjs   r"�test_single_process�%ParseArgsTestCase.test_single_process.s����)�*��
�
$�
$�
&��+�+�D�1�H�'�����-�-�q�1�����/�/�0��/�0��
�
$�
$�
&��+�+�D�1�H�'�����-�-�q�1�����/�/�0�'�
&��'�
&�s�C�C'�
C$�'
C5�N)?�__name__�
__module__�__qualname__�__firstlineno__�staticmethodr#r/r7rCrJrPrXr]rdrkrprtr�r�r�r�r�r�r�r�r�r�r�r�r�r�r��unittest�
skipUnlessr�Py_DEBUGr�rrrrrrr"r%r(r+r.r3r6r9rCrKrSrWrZr^rarerkrsrx�__static_attributes__rzr%r"rrFs[��
�)��)�+�
N�H�!�@�
(�*�-�0�/�#�=�,+� 	'�I�,�I�"[�HN�5Q�n@�@�
-�L�"C�	�����)�)�+?�@�*�A�*�@�/�C�P�,�-�(�
$�'�+�+�B�
D�� $�t�t��4�G�0�1�4�
�.�
.�
5�1r%rT)�slotsc�:�\rSrSr%\\S'\S-\S'\\S'Srg)�Reruni<�nameNr��successrz)r{r|r}r~r��__annotations__�boolr�rzr%r"r�r�<s��

�I���:��
�Mr%r�c��\rSrSrSrSrSrSrSSjrSr	SS
jr
SrSSSSSSSS	S	S	S	S	S	S
.
SjrS\
S\
4SjrSSjrSSjrSrg)�BaseTestCaseiCrU�test_regrtest_ztest_[a-zA-Z0-9_]+c��[RR[RR[55Ul[R"5UlUR[RUR5 gr)r�r��realpath�dirname�__file__r��tempfile�mkdtemp�
tmptestdirr�r�rmtreers r"�setUp�BaseTestCase.setUpHsM���w�w�'�'�������(A�B���"�*�*�,������	�(�(�$�/�/�:r%Nc�R�U(d,S[R-n[=RS-
slUc[R"S5nURU-n[
RRURUS-5nUR[RU5 [USSS9nURU5 SSS5 U$!,(df   U$=f![a9n[R "5(dUR#SU<S	U<35 eSnAff=f)
Nznoop%srUz�
                    import unittest

                    class Tests(unittest.TestCase):
                        def test_empty_test(self):
                            pass
                z.py�xzutf-8��encodingz
cannot write z: )r��TEST_UNIQUE_ID�textwrap�dedent�TESTNAME_PREFIXr�r�r�r�r�rr�r��write�PermissionError�	sysconfig�is_python_build�skipTest)r,r��coder�r��excs      r"�create_test�BaseTestCase.create_testNs�����l�9�9�9�D��'�'�1�,�'��<��?�?�$��D��#�#�d�*���w�w�|�|�D�O�O�T�E�\�:�����	�(�(�$�/�	��d�C�'�2�b������3���
3�2����	�	��,�,�.�.��
�
�t�S�A�B���	�s6�*C#�5C�C#�
C �C#� C#�#
D&�-4D!�!D&c��[R"X[R5nU(dURU<SU<35 U$)Nz not found in )�re�search�	MULTILINE�fail)r,�regex�outputr�s    r"�regex_search�BaseTestCase.regex_searchls/���	�	�%����6����I�I�e�V�<�=��r%Fc���U(d[R"U5nU(aUS-
n[R"SU-[R5nUR	X5 g)N�
�^)r��escape�compiler��assertRegex)r,r�r��fullr�s     r"�
check_line�BaseTestCase.check_linersE����i�i��(�G���t�O�G��
�
�4�'�>�2�<�<�8������'r%c��S[SURS[3n[R"X![R
5n[
SU55$)Nr�z\[ *[0-9]+(?:/ *[0-9]+)*\] (z) c3�B# �UHoRS5v� M g7f)rUN)�group)�.0r�s  r"�	<genexpr>�4BaseTestCase.parse_executed_tests.<locals>.<genexpr>~s���7��u�K�K��N�N��s�)�
LOG_PREFIX�TESTNAME_REGEX�RESULT_REGEXr��finditerr��list)r,r�r��parsers    r"�parse_executed_tests�!BaseTestCase.parse_executed_testszsL���j�\�"��)�)�*�"�\�N�<�����U�B�L�L�9���7��7�7�7r%rz)
rr�env_changed�omittedr\�run_no_tests�resource_deniedr{�parallelrrAr�filteredc	�2^"�[U[5(aU/n[U[5(aU/n[U
[5(aU
/n
[U[5(aU/n[U[5(aU/n[U[5(aU/n[U	[5(aU	/n	[U[5(a[U5nU(aSn/nUb@U(d9UR/nUR
(dUR
UR5 URU5n[U5nUbUR
UR5 U(a&UR[U5[U5U5 OURUUU5 Sm"U"4SjnU(aU"SU5nURUU5 U
(aU"SU
5nURUU5 U(aU"SU5nURUU5 U(aU"SU5nURUU5 U(aU"SU5nURUU5 Ub�U"S	UR/5nURUU5 [S
-nURUU5 SURS3nUR(aUS
URS3nURUU5 U	(aU"SU	5nURUU5 [U5[U5-
[U
5-
[U5-
[U5-
[U5-
[U	5-
nU(aNU<ST""U5<S3nU(d&U(dUbUR
(aUS:�aSU-nURUUSS9 U
(aURUS5 SURS3nU(aUS3nU/nUR (aUR
SUR S35 UR"(aUR
SUR"S35 SSR%U53nURUUSS9 [U5[U
5-
nUb[U5nSnO
[U5nSnU
(aSnSU3nU(dUS[U53nU(aUS3nU/nSU4S [U54S![U54S"[U
54S#U4S$[U	544H%unnU(dMUR
US%U35 M' S&SR%U53nURUUSS9 /n U(aU R
S'5 OU(aU(aU R
S(5 U
(aU R
S)5 ['UX]UXn45(dU R
S*5 OU (dU R
S+5 S,R%U 5n UbUR
(aS+OS'n!U S-U!3n URUS.U 3SS9 g)/NTc��US:waS$S$)NrU�sr<rz)�counts r"�plural�1BaseTestCase.check_executed_tests.<locals>.plural�s���1�*�3�,�"�,r%c�~>�[U5nSR[U55nXT"U54-nU<SU<S3nU$)N� z:\n    �$)�lenr��sorted)�line_format�testsr��namesr�r�s     �r"�
list_regex�5BaseTestCase.check_executed_tests.<locals>.list_regex�s>�����J�E��H�H�V�E�]�+�E��&��-�"8�8�E�',�e�4�E��Lr%z%s test%s skippedz%%s test%s skipped \(resource denied\)z%s test%s failedz;%s test%s altered the execution environment \(env changed\)z%s test%s omittedz%s re-run test%sz)Re-running 1 failed tests in verbose modezRe-running z in verbose modez
 \(matching: z\)z%s test%s run no testsz testz OK\.rUzAll %s)r�z(Test suite interrupted by signal SIGINT.zrun=�,z
 \(filtered\)z	failures=zskipped=z
Total tests: r�r�/rr�rr�r\r��=zTotal test files: �FAILUREzENV CHANGED�INTERRUPTEDzNO TESTS RAN�SUCCESS�, z then zResult: )�
isinstancer�r�rr�r��appendr�r�r@�setr�r�r�r��	tests_run�failuresrr��any)#r,r�r��statsrrr�r�r\r�r�r{r�rrArr��rerun_failed�executed�total_testsr�r��good�text�parts�line�run�total_failed�total_rerun�reportr��ntest�state�	new_stater�s#                                  @r"�check_executed_tests�!BaseTestCase.check_executed_tests�s�����e�S�!�!��G�E��g�s�#�#��i�G��o�s�+�+�.�/�O��f�c�"�"��X�F��k�3�'�'�&�-�K��g�s�#�#��i�G��l�C�(�(�(�>�L��e�S�!�!��e�$�E���I�����[��j�j�\�F��=�=��#�#�E�J�J�/��,�,�V�4���5�k�������u�z�z�*�����S��]�C��,<�f�E����X�{�F�;�	-�	���2�G�<�E��O�O�F�E�*���G��Y�E��O�O�F�E�*���1�6�:�E��O�O�F�E�*��� 2�*�,�E�
�O�O�F�E�*���2�G�<�E��O�O�F�E�*����1�E�J�J�<�@�E��O�O�F�E�*��!M�M�E��O�O�F�E�*�"�5�:�:�,�.>�?�E��{�{�!�7�-����}�B�?���O�O�F�E�*���7��F�E��O�O�F�E�*��E�
�S��\�)�C��,@�@�3�v�;�N��g�,��!$�[�!1�2�47��4E�F���)-�v�d�|�<�E��6�u�}��
�
�SW�Z[�S[� �5�(���O�O�F�E��O�5���O�O�F�$N�O��e�o�o�a�(�)����f�M�*�D�����>�>��L�L�9�U�^�^�A�$6�7�8��=�=��L�L�8�E�M�M�!�#4�5�6�������0�1�������4��0��+���_�!5�5�����|�,�L��K��v�;�L��K���C��c�U�|����V�1�S��Z�L�)�D���f�M�*�D����
�|�$�
�C��,�-�
��G��%�
��O� 4�5�
�k�"�
�S��.�/�

�K�D�%��u��
�
���a��w�/�0�
�%�S�X�X�f�%5�$6�7�������4��0�����L�L��#�
�+��L�L��'���L�L��'��D�&�w��3�4�4��L�L��(���L�L��#��	�	�%� ����%*�]�]�	�	�I��g�V�I�;�/�E�����(�5�'� 2���>r%r��returnc�H�URSU5nURS5$)NzUsing random seed: (.*)rU)r�r�)r,r�r�s   r"�parse_random_seed�BaseTestCase.parse_random_seeds#���!�!�"<�f�E���{�{�1�~�r%c	��U(dSnSU;a[RUS'URSS5nUc+[[R
5nURSS5 [R"U4SU[RUS.UD6nURU:wadS[U5<SUR<S	U<S
UR<S3	nUR(aUSUR--
nURU5 U$)
Nr<r�r�rzT)r��input�stdoutr�zCommand z failed with exit code z, but exit code z expected!

stdout:
---
z
---
z
stderr:
---
%s---
)
�
subprocess�STDOUT�popr�r��environr��PIPE�
returncoder�rr�r�)r,r!r�exitcode�kwr��procr-s        r"�run_command�BaseTestCase.run_command#s�����E��2��%�,�,�B�x�L��f�f�U�D�!���;��r�z�z�"�C��G�G�'��.��~�~�d�$�#'�$)�%/�_�_�"%�	$�
!#�$���?�?�h�&��$�i����(�D�K�K�
I�C��{�{�� �
�+�+�&�'��
�I�I�c�N��r%c��/nS[R;aURSS/5 [R/UQSPSPnU(aUR	S5 URU5 UR
"U40UD6nUR$)N�uopsrP�faulthandlerz-I)�sys�	_xoptions�extend�
executabler�r
r)r,r!�isolatedr�	extraargs�cmdrs       r"�
run_python�BaseTestCase.run_pythonFsz���	��S�]�]�"����d�F�^�,��~�~�@�	�@�4�@��@����J�J�t���
�
�4������*�r�*���{�{�r%)r�r�)NN�FT)Nr)T)r{r|r}r~r�r�r�r�r�r�r�r�r�r�r�r
rr�rzr%r"r�r�Csr���N�&�O�*�N�;��<�(�8�&(��)+�R�#'�b�-/�',�u�%�.3�%*�U�]?�~�����!�F
r%r�c��\rSrSrSrSrg)�CheckActualTestsiSc	��/SQnURU5n[UR55n[RR[R"[RR[55S5n[[R"U55nURUUS-S-SSRUR553S9 g)N)�-Wd�-E�-bbr��
test.regrtest�--list-testsztest*.py�	rnz+Unexpectedly low number of tests found in:
r�)r-)rr��
splitlinesr�r�r��globr�r�r��
assertGreater)r,r!r��rough_number_of_tests_found�actual_testsuite_glob�rough_counted_test_py_filess      r"�#test_finds_expected_number_of_tests�4CheckActualTests.test_finds_expected_number_of_testsTs���K������&��&)�&�*;�*;�*=�&>�#� "�����T�[�[�������9R�-S�-7�!9��&)�$�)�)�4I�*J�&K�#�	
���6�6�q�8�"�<�M�"�i�i��(9�(9�(;�<�=� ?�	�	@r%rzN)r{r|r}r~r+r�rzr%r"rrSs��@r%rc�H^�\rSrSrSrU4SjrSrSSjrSrSr	Sr
S	rS
rSr
Sr\R "\R$"5S
5\R "\R(S:HS5S55r\R "\R(S:HS5S5rSrU=r$)�ProgramsTestCaseikrc�r>�[TU]5 [UR5Vs/sHoR	5PM snUl/SQUlSSSUR-/UlURRS5 [RS:XaURRS5 ggs snf)N)rr r!z-uallz-rwW�--testdir=%s)r:�3600z-j4�win32r)
�superr��range�NTESTr�r��python_argsr��
regrtest_argsrr�platformr�)r,�index�	__class__s  �r"r��ProgramsTestCase.setUpts����
��
��7<�D�J�J�6G�H�6G�U�&�&�(�6G�H��
�/���%�v�,�t���>�@������!�!�">�?��<�<�7�"����%�%�d�+�#��
Is�B4c���URU5nURUR5U5 URXRS[UR5S9 g)NT)r{r�)r�rG�isdigitr�r�r�)r,r��randseeds   r"�check_output�ProgramsTestCase.check_output�sP���)�)�&�1������(�(�*�H�5��!�!�&�*�*�,0��D�J�J��	"�	Ir%c�F�URXUS9nURU5 g)N�r�r)rr?)r,r!r�rr�s     r"�	run_tests�ProgramsTestCase.run_tests�s"��������B�����&�!r%c���[RRURS5n/URQUPUR
QURQnURU5 g)Nzregrtest.py�r�r�r�r�r6r7r�rC�r,�scriptr!s   r"�test_script_regrtest�%ProgramsTestCase.test_script_regrtest�sO�������d�l�l�M�:��L��!�!�L�6�L�D�,>�,>�L����L�����t�r%c�z�/URQSPSPURQURQnURU5 g)Nr��test�r6r7r�rC�r,r!s  r"�test_module_test�!ProgramsTestCase.test_module_test�sJ��2��!�!�2�4�2��2��#�#�2�&*�j�j�2�����t�r%c�z�/URQSPSPURQURQnURU5 g)Nr�r"rMrNs  r"�test_module_regrtest�%ProgramsTestCase.test_module_regrtest��J��2��!�!�2�4�2��2��#�#�2�&*�j�j�2�����t�r%c�z�/URQSPSPURQURQnURU5 g)Nr�z
test.autotestrMrNs  r"�test_module_autotest�%ProgramsTestCase.test_module_autotest�rTr%c�~�Sn/URQSPUPURQURQnURU5 g)Nzfrom test import autotestz-crM)r,r�r!s   r"�test_module_from_test_autotest�/ProgramsTestCase.test_module_from_test_autotest�sO��*��2��!�!�2�4�2��2��#�#�2�&*�j�j�2�����t�r%c���[RRURS5n/URQUPUR
QURQnURU5 g)Nzautotest.pyrFrGs   r"�test_script_autotest�%ProgramsTestCase.test_script_autotest�sO�������d�l�l�M�:��L��!�!�L�6�L�D�,>�,>�L����L�����t�r%c�Z�URUSS9nURUR5 g)N�backslashreplace)�errors)r
r?r)r,r!rs   r"�	run_batch�ProgramsTestCase.run_batch�s2������(:� �;��	
���$�+�+�&r%z test.bat script is not installedr2zWindows onlyc�X�[RR[SSS5nSUR-/n[
R"5S:XaURS5 OX[
R"5S:XaURS5 O-[
R"5S	S
:XaURS5 [R(dURS5 [R"S
5(aURS5 UR"U/UQURQ76 g)N�Tools�buildbotztest.batr0�ARM64�-arm64�ARM�-arm32r�64bit�-x64z+d�Py_GIL_DISABLED�
--disable-gil)r�r�r��ROOT_DIRr�r8�machiner��architecturerr�r��get_config_varrar�)r,rH�	test_argss   r"�test_tools_buildbot_test�)ProgramsTestCase.test_tools_buildbot_test�s���
�����h���Z�H��#�d�o�o�5�6�	������(����X�&�
�
�
�
�5�
(����X�&�
�
"�
"�
$�Q�
'�7�
2����V�$�������T�"��#�#�$5�6�6����_�-����v�7�	�7�D�J�J�7r%c���[RR[S5n[RR	U5(dURSUS35 S/n[R"5S:XaURS5 OX[R"5S:XaURS5 O-[R"5S	S
:XaURS5 [R(aURS5 [R"S
5(aURS5 UR"U/UQURQUR Q76 g)NzPCbuild\rt.batzFile "z" does not existrhrfrgrhrirrjrkz-drlrm)r�r�r�rn�isfiler�r8ror�rprr�r�rqrar7r�)r,rH�rt_argss   r"�test_pcbuild_rt� ProgramsTestCase.test_pcbuild_rt�s��������h�(9�:���w�w�~�~�f�%�%��M�M�F�6�(�*:�;�<��&�������(��N�N�8�$�
�
�
�
�5�
(��N�N�8�$�
�
"�
"�
$�Q�
'�7�
2��N�N�6�"�����N�N�4� ��#�#�$5�6�6��N�N�?�+����v�J��J�$�*<�*<�J�t�z�z�Jr%)r6r7r�)NT)r{r|r}r~r5r�r?rCrIrOrRrVrYr\rar�r�r�r�rr8rsrxr��
__classcell__)r:s@r"r.r.ks����
�E�,�I�"�������'�����2�2�4�;�=�
�������0�.�A�8�B�=�8� �������0�.�A�K�B�Kr%r.c�&�\rSrSrSrSrSrSrSrSr	Sr
S	rS
rSr
SrS
rSr\SS.Sj5r\R("\R,S5S\4Sj5rSrSr\R("\R,S5S5r\R("\R,S5S5rSrSr\R>S5r Sr!Sr"Sr#Sr$S r%S!r&S"r'S#r(S$r)S%r*S&r+S'r,S(r-S)r.S*r/S+r0S,r1S-r2\R>S.5r3S/r4S0r5S1r6S2r7S3r8S4r9\Rt"\RvS55S65r<S7r=S8r>S\4S9jr?S:r@S;rAS<rBS=rCS>rDS?rE\Rt"\R�S@5SA5rGSBrHSCrISDrJSErKSFrLgG)H�ArgsTestCasei�c�P�SSSUR-/UQnUR"U40UD6$)Nr�rLr0)r�r)r,�testargsr�cmdargss    r"rC�ArgsTestCase.run_tests�s0�����$�/�/�!A�M�H�M�����w�-�"�-�-r%c���[R"S5n[SS5Vs/sHo RSU3US9PM nnUR"U6nURXCS[
U5-S9 gs snf)Na
            import unittest

            class PassingTests(unittest.TestCase):
                def test_test1(self):
                    pass

                def test_test2(self):
                    pass

                def test_test3(self):
                    pass
        rUr��ok�r�r�r�)r�r�r4r�rCr�r�)r,r��ir�r�s     r"�test_success�ArgsTestCase.test_success�s{����� �
��AF�a���L��1�!�!�B�q�c�(��!�6���L�����'���!�!�&�()�C��J��	"�	8��Ms�A/c��[R"S5nURS5nURSUS9nX#/nUR"U6nUR	XTU/SS9 g)NzQ
            import unittest
            raise unittest.SkipTest("nope")
        r��skipr�rU)rr��r�r�r�rCr�)r,r��test_ok�	test_skipr�r�s      r"r��ArgsTestCase.test_skip�so����� �
���"�"�4�(���$�$�V�$�$�7�	��$������'���!�!�&�+4�+�()�	"�	+r%c	���[R"S5nURS5nURSUS9nX#/nUR"US[06nURXTU[
SS5S9 g)	Nz�
            import unittest

            class FailingTest(unittest.TestCase):
                def test_failing(self):
                    self.fail("bug")
        r��failingr�r
rrU�rr��r�r�r�rC�EXITCODE_BAD_TESTr�r)r,r�r��test_failingr�r�s      r"�test_failing_test�ArgsTestCase.test_failing_testsx����� �
���"�"�4�(���'�'�	��'�=���'������C�1B�C���!�!�&��(1�!�Q��	"�	9r%c��0nSH/n[R"SU-5nURX#5X'M1 [UR	55nUR
"SS/UQ76nUR
XTSS9 UR
"S/UQ76nUR
XTUSS	S
9 UR
"US[06nUR
XTUSS
9 g)
N)�audior�a
                        from test import support; support.requires(%r)
                        import unittest
                        class PassingTest(unittest.TestCase):
                            def test_pass(self):
                                pass
                    r�r�rr�z-uaudior�rU)r�r�r
r)r�r�r�r��valuesrCr��EXITCODE_NO_TESTS_RAN)r,r��resourcer��
test_namesr�s      r"�test_resources�ArgsTestCase.test_resourcess�����,�H��?�?�$�#�
$#�$�D�#�.�.�x�>�E�O�-��E�L�L�N�+�
�����e�9�j�9���!�!�&�A�!�>����	�7�J�7���!�!�&�27�	�2B�()�	"�	+�
����L�6K�L���!�!�&�2<�()�	"�	+r%c��[R"S5nURSU5nURSU[S9nURU5nUR
SU5n[URS55nURSSU3U[S9nURU5nURXt5 UR
SU5n[URS55nURX�5 URU[S9nURU5nURUR5U5 Sn	[[RU	S	9n
URSU[U
S
9nURU5nURXI5 URUS5 [[RSS	9n
URSU[U
S
9nURU5nURUS5 URUS
5 [[RSS	9n
URSU[U
S
9nURU5nURUR5U5 g)Nza
            import random
            print("TESTRANDOM: %s" % random.randint(1, 1000))
        �randomrw�r
zTESTRANDOM: ([0-9]+)rU�--randseed=ry)rz�r
r�zTESTRANDOM: 520�XYZzTESTRANDOM: 22r<)r�r�r�rCr�r�r�r�r�r@rGr=r�r�rr�)r,r�rLr�r>r��test_random�	randseed2�test_random2�	timestampr�s           r"r��ArgsTestCase.test_random<s=����� �
������$�/������d�5J��K���)�)�&�1���!�!�"9�6�B���%�+�+�a�.�)�������H�:�&>��)>� �@���*�*�6�2�	�����-��!�!�"9�6�B���5�;�;�q�>�*������3�����/D��E���)�)�&�1������(�(�*�H�5�!�	��2�:�:��;������d�5J�$'� �)���)�)�&�1������-����� 1�2��2�:�:��7������d�5J�$'� �)���)�)�&�1������5�)����� 0�1��2�:�:��4������d�5J�$'� �)���)�)�&�1������(�(�*�H�5r%c
�R�[S5Vs/sHoR5PM nn[RnUR	[R
U5 [
US5nSn[US5H0upSX[U5U4-nU(aUSU--
n[XtS9 UnM2 SSS5 URSU5n[U5n	URX�U	S9 [
US5n[US5H$up[S	U<S
[U5<SU<3US9 M& SSS5 URSU5nURX�U	S9 [
US5nUHn[XdS9 M SSS5 URSU5nURX�U	S9 [
US5nUHn[SU-US9 M SSS5 URSU5nURX�U	S9 gs snf!,(df   GNC=f!,(df   N�=f!,(df   N�=f!,(df   Nj=f)
Nrr�rUz00:00:%02i [%s/%s] %sz -- %s took 0 secr�r�r��[r�z] zLib/test/%s.py)r4r�rr�r�r�r��	enumerater�r�rCr�)
r,r9r�r�r��previousr�r�r�r�s
          r"r��ArgsTestCase.test_fromfileqs���16�q��:���!�!�#���:�
�#�#�����	�(�(�(�3��(�C�
 �B��H�(���2���/� ��U��T�:�;����/�(�:�:�D��d�$���
 3�!�����h�7���E�
���!�!�&�u�!�=��(�C�
 �B�(���2����e�S��Z��>�R�H� 3�!�����h�7���!�!�&�u�!�=��(�C�
 �B����d�$��!�����h�7���!�!�&�u�!�=��(�C�
 �B����&��-�B�7��!�����h�7���!�!�&�u�!�=��[;�!�
 ��!�
 ��!�
 ��!�
 �s6�G�%AG$�)5G6�H�H�$
G3�6
H�
H�
H&c�|�[nURSUS9nURU[S9nUR	X2USSS9 g)N�sigintr�r�Tr�r�rr�)�TEST_INTERRUPTEDr�rC�EXITCODE_INTERRUPTEDr��r,r�rLr�s    r"�test_interrupted�ArgsTestCase.test_interrupted�sK��������t��4������/C��D���!�!�&��.2�!�	"�	=r%c��[S5Vs/sHoR5PM nnUR"S/UQ76nURX2[	U5S9 SUR
<S[	U5<S3nUR
X45 gs snf)Nrrnr�z10 slowest tests:
(?:- z: .*
){�})r4r�rCr�r�r�r�)r,r9r�r�r�s     r"rp�ArgsTestCase.test_slowest�sv��16�q��:���!�!�#���:�����4�e�4���!�!�&�s�5�z�!�B��'�'��U��5��	
����&��
;s�Bc
�.�[nURSUS9nSHgnURUS9 U(aSSU4nOSU4nUR"US[06nURXRUSS	S
9 SnUR
XV5 SSS5 Mi g!,(df   M{=f)Nr�r�r)�multiprocessingrnrvr
Trr�z10 slowest tests:
)r�r�r4rCr�r�r�)r,r�rLr�r!r�r�s       r"�test_slowest_interrupted�%ArgsTestCase.test_slowest_interrupted�s���������t��4��,�O����o��>�"�'���5�D�'��.�D�����M�8L�M���)�)�&�26�D�01�*�3�/������.�?�>� -�>�>�s�A
B�
B	c��URS5nURSU5nURX!/SS9 SnURX#5 g)N�coverager�rUr�zLlines +cov% +module +\(path\)\n(?: *[0-9]+ *[0-9]{1,2}% *[^ ]+ +\([^)]+\)+)+)r�rCr�r�)r,rLr�r�s    r"�
test_coverage�ArgsTestCase.test_coverage�sK�����
�+������d�3���!�!�&�&��!�:�B������&r%c�l�URS5nURSUSS9nURUS5 g)NrHrF�key)rzPress any key to continue)r�rCr�)r,rLr�s   r"rJ�ArgsTestCase.test_wait�s5������'������$�e��<������ ;�<r%c
�0�[R"S5nURSUS9nURSU[S9nURX2/S-U[
SS5SS	9 URSS
USS9nURX2/S-[USSS
9[
SS5SS9 g)NaL
            import builtins
            import unittest

            class ForeverTester(unittest.TestCase):
                def test_run(self):
                    # Store the state in the builtins module, because the test
                    # module is reload at each run
                    if 'RUN' in builtins.__dict__:
                        builtins.__dict__['RUN'] += 1
                        if builtins.__dict__['RUN'] >= 3:
                            self.fail("fail at the 3rd runs")
                    else:
                        builtins.__dict__['RUN'] = 1
        rr�rr�rrUT)rr�rr[r�test_run�r�r�r)r\r�r)r�r�r�rCr�r�rr�r�s    r"r�ArgsTestCase.test_forever�s������ �
�����	���5������T�<M��N���!�!�&�&��(�4�(1�!�Q��*.�	"�	0�
����Y��q��I���!�!�&�&��(�(-�d�4>�6:�)<�)2�!�Q��*.�	"�	0r%F��run_workersc��URSUS9nSnUR[RU5 SS/nU(aUR	S5 UR	U5 UR
"U[[RS.6nURXt/USS	9 S
nURXx5 U<SU<S3n	URX�5 [U5n
U
R5nURX�5 SSS5 g!,(df   g=f)
Nr�r�r�r��3:3:r��r
r�rUr�z6beginning 6 repetitions. .*\n123:456\n[.0-9X]{3} 111\nz leaked [1, 1, 1] z, sum=3
)r�r�rr�r�rCr�rrr�r�r*r��read)r,r��whatr�rLr�rr�r��line2r��reflogs            r"�
check_leak�ArgsTestCase.check_leak�s�������4��8�������	�(�(�(�3��v�&����J�J�u���
�
�4������):�'1�'8�'8�:��	
�!�!�&�&��Q�!�G�H������%�59�4�@���
�
�e�$�
�(�^�r��W�W�Y�F��M�M�%�(��^�^�s�"C;�;
D	r�r�c�R�[R"S5nURUSUS9 g)Nz�
            import unittest

            GLOBAL_LIST = []

            class RefLeakTest(unittest.TestCase):
                def test_leak(self):
                    GLOBAL_LIST.append(object())
        �
referencesr��r�r�r�)r,r�r�s   r"�check_huntrleaks�ArgsTestCase.check_huntrleakss+����� �
��	
����l���Dr%c�"�URSS9 g�NFr��r�rs r"r��ArgsTestCase.test_huntrleakss�����%��0r%c�"�URSS9 g�NTr�r�rs r"�test_huntrleaks_mp�ArgsTestCase.test_huntrleaks_mp!s�����$��/r%c��[R"S5nURSUS9nSnUR[R
U5 SSSU/nUR"U[[RS.6nURS	U3U5 URS	US
3U5 URSU5 URSUS
3U5 g)Nay
            import unittest

            GLOBAL_LIST = []

            class RefLeakTest(unittest.TestCase):
                def test1(self):
                    pass

                def test2(self):
                    pass

                def test3(self):
                    GLOBAL_LIST.append(object())

                def test4(self):
                    pass
        r�r�r�r�r�rhr�zBisect z
: exit code 0zBisection completed inz
Tests (1):
* z.RefLeakTest.test3
)r�r�r�r�rr�rCr�rrr*)r,r�rLr�rr�s      r"�test_huntrleaks_bisect�#ArgsTestCase.test_huntrleaks_bisect$s������ �
��&����4��8�������	�(�(�(�3��v�z�4�8������):�'1�'8�'8�:��	
�
�
���v�&��/��
�
���v�]�3�V�<�	
�
�
�.��7��
�
�
���*�
,��	r%c�T�[R"S5nURUS5 g)Na
            import os
            import unittest

            class FDLeakTest(unittest.TestCase):
                def test_leak(self):
                    fd = os.open(__file__, os.O_RDONLY)
                    # bug: never close the file descriptor
        zfile descriptorsr�)r,r�s  r"�test_huntrleaks_fd_leak�$ArgsTestCase.test_huntrleaks_fd_leakMs(����� �
��	
����0�1r%c���[S5Vs/sHoR5PM nnUR"S/UQ76nURUR	5R5U5 gs snf)Nrr#)r4r�rCr@�rstripr%)r,r�r�r�s    r"�test_list_tests�ArgsTestCase.test_list_tests[s[��-2�1�X�6�X��!�!�#�X��6�����7��7���������3�3�5��	 ��7s�A+c�:�[R"S5nURUS9nSU-SU-/nURSU5nUR	UR5U5 SU-/nURSSSU5nUR	UR5U5 g)Nz�
            import unittest

            class Tests(unittest.TestCase):
                def test_method1(self):
                    pass
                def test_method2(self):
                    pass
        r�z%s.Tests.test_method1z%s.Tests.test_method2z--list-casesr��test_method1)r�r�r�rCr@r%)r,r��testname�all_methodsr�s     r"�test_list_cases�ArgsTestCase.test_list_casesbs������ �
���#�#��#�.��/��9�.��9�;�������9������*�*�,�k�:�/��9�:������ $�n� (�*��	
����*�*�,�k�:r%c��SnURSUS9nU/nUR"S/UQ7S[06nURXCUSSS9 g)	Nz,import faulthandler; faulthandler._sigsegv()�crash�r�r�rvr
Tr�rr�r�)r�rCr�r�)r,r��
crash_testr�r�s     r"�test_crashed�ArgsTestCase.test_crashed|sZ��>���%�%�7��%�>�
��������J��J�8I�J���!�!�&�
�+/�q�	"�	:r%c��[R"S[RS9nURU5Vs/sHo3R	S5PM sn$s snf)Nz^(test[^ ]+).*ok$��flagsrU)r�r�r�r�r�)r,r�r�r�s    r"�
parse_methods�ArgsTestCase.parse_methods�s@���
�
�.�b�l�l�C��,1�N�N�6�,B�C�,B�5���A��,B�C�C��Cs�Ac��[R"S5nURUS9n[RnUR[RU5 SSU-/n[US5nUHn[XeS9 M SSS5 URSSX25nURU5nS	S
/nURX�5 g!,(df   NH=f)N�V
            import unittest

            class Tests(unittest.TestCase):
                def test_method1(self):
                    pass
                def test_method2(self):
                    pass
                def test_method3(self):
                    pass
                def test_method4(self):
                    pass
        r�r��%s.Tests.test_method3r�r�rTr��test_method2�test_method4)r�r�r�rr�r�r�r�r�rCr�r@)	r,r�r�r��subsetr�r�r��methodss	         r"�test_ignorefile�ArgsTestCase.test_ignorefile�s������ �
���#�#��#�.���#�#�����	�(�(�(�3�
�#�h�.�	0��
�(�C�
 �B����d�$��!�����n�h�I���$�$�V�,�� �.�1������)�!�
 �s�)B>�>
Cc��[R"S5n/SQnURUS9nURSU5nUR	U5nURXR5 [RnUR[RU5 SSU-/n[US5nUHn	[X�S9 M SSS5 URSS	Xc5nUR	U5nSS
/nURXW5 g!,(df   NH=f)Nr�)r�r��test_method3rr�rTr�r�r�r�r�r)r�r�r�rCr�r@rr�r�r�r�r�)
r,r�r�r�r�rr�rr�r�s
          r"�test_matchfile�ArgsTestCase.test_matchfile�s������ �
��7���#�#��#�.������h�/���$�$�V�,������.��#�#�����	�(�(�(�3�
�#�h�.�	0��
�(�C�
 �B����d�$��!�����m�X�H���$�$�V�,�� �.�1������)�!�
 �s�!C6�6
Dc�@�[R"S5nURUS9nURU5nUR	X2/USS9 URSU[
S9nUR	X2/USSS9 URS	U5nUR	X2/U[
USSS
9SS9 g)
Nz�
            import unittest

            class Tests(unittest.TestCase):
                def test_env_changed(self):
                    open("env_changed", "w").close()
        r�rU)r�r��--fail-env-changedr�T�r�rAr�r[r�r)r�r\r�)r�r�r�rCr��EXITCODE_ENV_CHANGEDr��r,r�r�r�s    r"�test_env_changed�ArgsTestCase.test_env_changed�s������ �
���#�#��#�.������)���!�!�&�*�.6�a�	"�	A���� 4�h�)=� �?���!�!�&�*�(�37�q�	"�	B����	�8�4���!�!�&�*�.6�(-�h�48�6:�)<�)*�	"�	+r%c
���[R"S5nURUS9nURSU[S9nURX2/[
USSS9[SS	5S
9 g)Na
            import unittest

            class Tests(unittest.TestCase):
                def test_succeed(self):
                    return

                def test_fail_always(self):
                    # test that always fails
                    self.fail("bug")
        r�r[r��test_fail_alwaysF)r�rr�r\r�)r�r�r�rCr�r�r�rr
s    r"�test_rerun_fail�ArgsTestCase.test_rerun_fail�sq�����
 �

���#�#��#�.�����	�8�>O��P���!�!�&�*�(-�h�.@�6;�)=�)2�!�Q��		"�	9r%c
�l�[RRS5nUR[R
U5 UR
[RRU55 [R"SU<S35nURUS9nURSUSS9nURXC/[USS	S
9[SS5S
9 [R
"U5 URSSU[S9nURXC/[USS	S
9[SS5S
9 [R
"U5 g)N�regrtest_marker_filenamezW
            import os.path
            import unittest

            marker_filename = aD

            class Tests(unittest.TestCase):
                def test_succeed(self):
                    return

                def test_fail_once(self):
                    if not os.path.exists(marker_filename):
                        open(marker_filename, "w").close()
                        self.fail("bug")
        r�r[rr��test_fail_onceTr�rrUrz--fail-rerun)r�r�r�r�rr�r~�existsr�r�r�rCr�r�r�EXITCODE_RERUN_FAIL)r,�marker_filenamer�r�r�s     r"�test_rerun_success�ArgsTestCase.test_rerun_success
s6���'�'�/�/�*D�E�����	�(�(�/�:����������8�9����$� /�1�
2	�	 �
���#�#��#�.�����	�8�a��@���!�!�&�*�(-�h�4D�6:�)<�)2�!�Q��		"�	9�
	����)����	�>�8�)<� �>���!�!�&�*�(-�h�4D�6:�)<�)2�!�Q��		"�	9�
	����)r%c��[R"S5nURUS9nURSU[S9nURX2U/[
USSS9SS	9 g)
Na
            import unittest

            class ExampleTests(unittest.TestCase):
                @classmethod
                def setUpClass(self):
                    raise RuntimeError('Fail')

                def test_success(self):
                    return
        r�r[r��ExampleTestsFr�r�rr\r��r�r�r�rCr�r�r�r
s    r"�#test_rerun_setup_class_hook_failure�0ArgsTestCase.test_rerun_setup_class_hook_failure5�n�����
 �

���#�#��#�.�����	�8�>O��P���!�!�&�*2��(-�h�4B�6;�)=�)*�	"�	+r%c��[R"S5nURUS9nURSU[S9nURX2U/[
USSS9SS	9 g)
Na
            import unittest

            class ExampleTests(unittest.TestCase):
                @classmethod
                def tearDownClass(self):
                    raise RuntimeError('Fail')

                def test_success(self):
                    return
        r�r[r�rFr�rrr r
s    r"�&test_rerun_teardown_class_hook_failure�3ArgsTestCase.test_rerun_teardown_class_hook_failureLr#r%c��[R"S5nURUS9nURSU[S9nURX2U/[
USSS9SS9 g)	Nz�
            import unittest

            def setUpModule():
                raise RuntimeError('Fail')

            class ExampleTests(unittest.TestCase):
                def test_success(self):
                    return
        r�r[r�Fr�rrr r
s    r"�$test_rerun_setup_module_hook_failure�1ArgsTestCase.test_rerun_setup_module_hook_failurecsn�����	 �	
���#�#��#�.�����	�8�>O��P���!�!�&�*2��(-�h�48�6;�)=�)*�	"�	+r%c��[R"S5nURUS9nURSU[S9nURX2/U/[
USSS9SS9 g)	Nz�
            import unittest

            def tearDownModule():
                raise RuntimeError('Fail')

            class ExampleTests(unittest.TestCase):
                def test_success(self):
                    return
        r�r[r�Fr�rrr r
s    r"�'test_rerun_teardown_module_hook_failure�4ArgsTestCase.test_rerun_teardown_module_hook_failureysp�����	 �	
���#�#��#�.�����	�8�>O��P���!�!�&�*�*2��(-�h�48�6;�)=�)*�	"�	+r%c��[R"S5nURUS9nURSU[S9nURX2U/[
USSS9SS	9 g)
Nz�
            import unittest

            class ExampleTests(unittest.TestCase):
                def setUp(self):
                    raise RuntimeError('Fail')

                def test_success(self):
                    return
        r�r[r�r�Fr�rrr r
s    r"�test_rerun_setup_hook_failure�*ArgsTestCase.test_rerun_setup_hook_failure��n�����	 �	
���#�#��#�.�����	�8�>O��P���!�!�&�*2��(-�h�4B�6;�)=�)*�	"�	+r%c��[R"S5nURUS9nURSU[S9nURX2U/[
USSS9SS	9 g)
Nz�
            import unittest

            class ExampleTests(unittest.TestCase):
                def tearDown(self):
                    raise RuntimeError('Fail')

                def test_success(self):
                    return
        r�r[r�r�Fr�rrr r
s    r"� test_rerun_teardown_hook_failure�-ArgsTestCase.test_rerun_teardown_hook_failure�r0r%c
��[R"S5nURUS9nURSU[S9nURX2[
USSS9SS	9 g)
Na

            import unittest

            class ExampleTests(unittest.IsolatedAsyncioTestCase):
                async def asyncSetUp(self):
                    raise RuntimeError('Fail')

                async def test_success(self):
                    return
        r�r[r�r�Fr�rrr r
s    r"�#test_rerun_async_setup_hook_failure�0ArgsTestCase.test_rerun_async_setup_hook_failure�si�����	 �	
���#�#��#�.�����	�8�>O��P���!�!�&�(-�h�4B�6;�)=�)*�		"�	+r%c��[R"S5nURUS9nURSU[S9nURX2U/[
USSS9SS	9 g)
Na
            import unittest

            class ExampleTests(unittest.IsolatedAsyncioTestCase):
                async def asyncTearDown(self):
                    raise RuntimeError('Fail')

                async def test_success(self):
                    return
        r�r[r�r�Fr�rrr r
s    r"�&test_rerun_async_teardown_hook_failure�3ArgsTestCase.test_rerun_async_teardown_hook_failure�r0r%c��[R"S5nURUS9nURUSS[S9nURX2/USSS9 g�	N��
            import unittest

            class Tests(unittest.TestCase):
                def test_bug(self):
                    pass
        r�r��
nosuchtestr�rT�r�r�r��r�r�r�rCr�r�r
s    r"�test_no_tests_ran�ArgsTestCase.test_no_tests_ran�sf����� �
���#�#��#�.������$��)>� �@���!�!�&�*�/7�()�D�	"�	:r%c	��[R"S5nURUS9nURU5nUR	X2/[SSS9S9 g)Nz�
            import unittest

            class Tests(unittest.TestCase):
                def test_skipped(self):
                    self.skipTest("because")
        r�rU)rr�)r�r�r�rCr�rr
s    r"�test_no_tests_ran_skip�#ArgsTestCase.test_no_tests_ran_skip�sZ����� �
���#�#��#�.������)���!�!�&�*�(1�!�Q�(?�	"�	Ar%c���[R"S5nURUS9nURUS9nURX#SS[S9nURXBU/X#/SSS9 gr;r?)r,r�r��	testname2r�s     r"�,test_no_tests_ran_multiple_tests_nonexistent�9ArgsTestCase.test_no_tests_ran_multiple_tests_nonexistents����� �
���#�#��#�.���$�$�$�$�/�	�����T�<�)>� �@���!�!�&�Y�*?�08�/D�()�D�	"�	:r%c
���[R"S5nURUS9n[R"S5nURUS9nURX$SSSSSS9nUR	XRU/U/S	S
S9 g)Nr<r�z�
            import unittest

            class Tests(unittest.TestCase):
                def test_other_bug(self):
                    pass
        r�r=�test_other_bugrr�rUTr>r�)r,r�r��
other_coderFr�s      r"�)test_no_test_ran_some_test_exist_some_not�6ArgsTestCase.test_no_test_ran_some_test_exist_some_nots������ �
���#�#��#�.���_�_�&�
�
��$�$�*�$�5�	�����T�<� $�&6�� �D���!�!�&�Y�*?�08�z�()�D�	"�	:r%c���SSKn[R
"S5nUR
US9nURSU[S9nURXC/U/SSS	9 g![a [R"S5ef=f)
Nrzrequires _testcapia�
            import _testcapi
            import gc
            import unittest

            @_testcapi.with_tp_del
            class Garbage:
                def __tp_del__(self):
                    pass

            class Tests(unittest.TestCase):
                def test_garbage(self):
                    # create an uncollectable object
                    obj = Garbage()
                    obj.ref_cycle = obj
                    obj = None
        r�r
r�TrUr)
�	_testcapi�ImportErrorr��SkipTestr�r�r�rCrr�)r,rOr�r�r�s     r"�test_uncollectable�ArgsTestCase.test_uncollectable-s���	:����� �
��"�#�#��#�.����� 4�h�)=� �?���!�!�&�*�/7�j�37�()�	"�	+��/�	:��#�#�$8�9�9�	:�s�A�!A6c��[R"S5nURUS9nURSSU[S9nURX2/USS9 UR
U[R"SU-[R55 g)	Naa
            import time
            import unittest
            try:
                import faulthandler
            except ImportError:
                faulthandler = None

            class Tests(unittest.TestCase):
                # test hangs and so should be stopped by the timeout
                def test_sleep(self):
                    # we want to test regrtest multiprocessing timeout,
                    # not faulthandler timeout
                    if faulthandler is not None:
                        faulthandler.cancel_dump_traceback_later()

                    time.sleep(60 * 5)
        r�rvz
--timeout=1.0r�rr�z%s timed out)
r�r�r�rCr�r�r�r�r�r�r
s    r"�test_multiprocessing_timeout�)ArgsTestCase.test_multiprocessing_timeoutMs������ �
��$�#�#��#�.��������):� �<���!�!�&�*�)1��	"�	<��������N�X�$=�r�|�|�L�	Nr%c���[R"S5nURUS9nURSSU[S9nURX2/U/SSS9 UR
S	U5 UR
S
U5 g)Na�
            import unittest
            import weakref
            from test.support import captured_stderr

            class MyObject:
                pass

            def weakref_callback(obj):
                raise Exception("weakref callback bug")

            class Tests(unittest.TestCase):
                def test_unraisable_exc(self):
                    obj = MyObject()
                    ref = weakref.ref(obj, weakref_callback)
                    with captured_stderr() as stderr:
                        # call weakref_callback() which logs
                        # an unraisable exception
                        obj = None
                    self.assertEqual(stderr.getvalue(), '')
        r�r
rTr�TrUrzWarning -- Unraisable exceptionzException: weakref callback bug�r�r�r�rCrr�r*r
s    r"�test_unraisable_exc� ArgsTestCase.test_unraisable_excis������ �
��*�#�#��#�.����� 4�d�H�)=� �?���!�!�&�*�/7�j�37�()�	"�	+�	
�
�
�7��@��
�
�7��@r%c���[R"S5nURUS9nURSSU[S9nURX2/U/SSS9 UR
S	U5 UR
S
U5 g)Na[
            import threading
            import unittest
            from test.support import captured_stderr

            class MyObject:
                pass

            def func_bug():
                raise Exception("bug in thread")

            class Tests(unittest.TestCase):
                def test_threading_excepthook(self):
                    with captured_stderr() as stderr:
                        thread = threading.Thread(target=func_bug)
                        thread.start()
                        thread.join()
                    self.assertEqual(stderr.getvalue(), '')
        r�r
rTr�TrUrz$Warning -- Uncaught thread exceptionzException: bug in threadrXr
s    r"�test_threading_excepthook�&ArgsTestCase.test_threading_excepthook�s������ �
��&�#�#��#�.����� 4�d�H�)=� �?���!�!�&�*�/7�j�37�()�	"�	+�	
�
�
�<�f�E��
�
�0�&�9r%c
�6�[R"S5nURUS9nSnSHZnURUS9 SXB/nUR"US[
06nUR
Xb/U/SS	S
9 URXc5 SSS5 M\ g!,(df   Mn=f)Na%
            import sys
            import unittest
            from test import support

            class MyObject:
                pass

            def func_bug():
                raise Exception("bug in thread")

            class Tests(unittest.TestCase):
                def test_print_warning(self):
                    print("msg1: stdout")
                    support.print_warning("msg2: print_warning")
                    # Fail with ENV CHANGED to see print_warning() log
                    support.environment_altered = True
        r�zFtest_print_warning.*msg1: stdout\nWarning -- msg2: print_warning\nok\n)rTra)�optionr
r
TrUr)r�r�r�r4rCrr�r�)r,r�r�r�r_rr�s       r"�test_print_warning�ArgsTestCase.test_print_warning�s������ �
��$�#�#��#�.����#�F����V��,�+�V�>������L�7K�L���)�)�&�*�7?�j�;?�01�*�3�� � ��/�-�,�#�,�,�s�AB	�	
B	c���[RR[R5nURU[RS35 UR
5(aURS5 gg)Nz not setzModified guard)r�r�getr	�UNICODE_GUARD_ENVro�isasciir�)r,�guards  r"�test_unicode_guard_env�#ArgsTestCase.test_unicode_guard_env�sW���
�
���u�6�6�7�����U�u�'>�'>�&?�x�$H�I��=�=�?�?�
�M�M�*�+�r%c���[RRURS5n[R"U5 [RRURS5n[US5R
5 X/nSSSUR-S/nURU5 UH2nUR[RRU5U5 M4 g)N�test_python_123�test_python_456�wbr�rLz--tempdir=%sz	--cleanup)
r�r�r�r��mkdirr��closerr~r)r,r�r�r�rr�s      r"�test_cleanup�ArgsTestCase.test_cleanup�s����'�'�,�,�t���0A�B��
������7�7�<�<����1B�C���X�t��"�"�$��#����!�D�O�O�3�� ��	
���� ��D����R�W�W�^�^�D�1�4�8�r%z.checking temp files is not implemented on WASIc
�6�[R"S5n[S5Vs/sHo RUS9PM nnUR"SSS/UQ7S[
06nUR
XCUSS[U5S	9 UHnURS
US3U5 M gs snf)Nam
            import os.path
            import tempfile
            import unittest

            class FileTests(unittest.TestCase):
                def test_leak_tmp_file(self):
                    filename = os.path.join(tempfile.gettempdir(), 'mytmpfile')
                    with open(filename, "wb") as fp:
                        fp.write(b'content')
        rr�r
rTrvr
T)r�rAr�r�zWarning -- z& leaked temporary files (1): mytmpfile)	r�r�r4r�rCrr�r�r*)r,r��_�	testnamesr�r�s      r"�test_leak_tmp_file�ArgsTestCase.test_leak_tmp_file�s������
 �

��;@��(�C�(�Q�%�%�4�%�0�(�	�C���� 4�d�E�?�I�?�)=�?���!�!�&�.7�37�+/�(+�I��		"�	8�
"�H��M�M�K��z�21�2� �
"�"��Ds�Bc��[RS:Xa[R"5nOK[RR
nUc.[RR
nUcURS5 [S[SS555nSU4-nSnX4RS5-
nURU5 URUS	35 URUS
5n[R"SU<S35nURUS
9nUR!SSSU5nUR#X�/SSS9 UR%X�SS9 g![a Nf=f)Nr2z#cannot get regrtest worker encodingc3�$# �UHov� M g7frrz)r��chs  r"r��8ArgsTestCase.test_worker_decode_error.<locals>.<genexpr>s���6�o���o�s���snonascii:%s
z*Assertion failed: tstate_is_alive(tstate)
z	utf-16-lez can decode non-ASCII bytesr_z�
            import sys
            import unittest

            class Tests(unittest.TestCase):
                def test_pass(self):
                    pass

            # bytes which cannot be decoded from UTF-8
            corrupted_output = ze
            sys.stdout.buffer.write(corrupted_output)
            sys.stdout.buffer.flush()
        r�r
rTr�TrU)r�r�F)r�)rr8�locale�getencodingrr��
__stdout__r��bytesr4�encode�decode�UnicodeDecodeErrorr�r�r�rCr�r�)	r,r��nonascii�corrupted_output�assertion_failed�
expected_liner�r�r�s	         r"�test_worker_decode_error�%ArgsTestCase.test_worker_decode_error	sb���<�<�7�"��)�)�+�H��z�z�*�*�H����>�>�2�2���#��M�M�"G�H��6�e�C��o�6�6��+�x�k�9��I���3�3�K�@�@��	D��#�#�H�-�
�M�M�X�J�&A�B�C�(�/�/��:L�M�
����	% �!1�3�4	� �
���#�#��#�.����� 4�d�E�8�L���!�!�&�*�+/�()�	"�	+�	
����U��;��5"�	��	�s�.E�
E�Ec��[R"S5nURUS9nURSSSU[S9nURX2/U/S[
SSS	5S
9 g)NaX
            import doctest
            import sys
            from test import support

            def my_function():
                """
                Pass:

                >>> 1 + 1
                2

                Failure:

                >>> 2 + 3
                23
                >>> 1 + 1
                11

                Skipped test (ignored):

                >>> id(1.0)  # doctest: +SKIP
                7948648
                """

            def load_tests(loader, tests, pattern):
                tests.addTest(doctest.DocTestSuite())
                return tests
        r�r
rTr�r�TrUrr�r�r
s    r"�test_doctest�ArgsTestCase.test_doctest8st����� �
��:�#�#��#�.����� 4�d�E�8�):� �<���!�!�&�*�*2��+/�(1�!�Q��(:�	"�	<r%c�T�[R"S5n[SS5Vs/sHnURSU3US9PM nnSnSSU3/nU(aUR	S	[U535 UR
U5 UR"U6n[R"U5 [S
5Vs/sHn[R"SS5PM n	nS
U	3n
Sn[R"X�[RS9nURX�/[U5-5 gs snfs snf)Na 
            import random
            import unittest

            class RandomSeedTest(unittest.TestCase):
                def test_randint(self):
                    numbers = [random.randint(0, 1000) for _ in range(10)]
                    print(f"Random numbers: {numbers}")
        rUrr�r�iJ�3rxr�r�rnrr
zRandom numbers: z^Random numbers: .*$r�)r�r�r4r�r�r�rrCr��seed�randintr��findallr�r@)
r,r�r�r�r�r�rr�rr�numbersr�r��matchess
             r"�_check_random_seed�ArgsTestCase._check_random_seed_s����� �
�� ��3�-�)�'�Q��!�!��Q�C�'8�t�!�D�'�	�)�"����K�=�9�:����J�J��C��J�<�(�)��
�
�5������%�����K� �5:�"�I�>�I�q�6�>�>�!�T�*�I��>�%�g�Y�/��'���*�*�U�"�,�,�?������*�s�5�z�"9�:��))��?s�D �4!D%c�"�URSS9 gr��r�rs r"�test_random_seed�ArgsTestCase.test_random_seed�s�����E��2r%c�"�URSS9 gr�r�rs r"�test_random_seed_workers�%ArgsTestCase.test_random_seed_workers�s�����D��1r%c�8�[R"S5n[S5Vs/sHo RUS9PM nn[R
SS/n[R"U5nUR"SUS/UQ76nURXS[U5SS	9 gs snf)
Nz�
            import sys
            import unittest

            class WorkerTests(unittest.TestCase):
                def test_dev_mode(self):
                    self.assertTrue(sys.flags.dev_mode)
        rr�rPrQrNz-j0T�r�r�)r�r�r4r�rr�shlexr�rCr�r�)r,r�rrr�rRr�s      r"�test_python_command� ArgsTestCase.test_python_command�s������ �
��7<�A�h�?�h��!�!�t�!�,�h��?��n�n�d�E�2�
��Z�Z�
�+�
����
�J��F��F���!�!�&�(+�E�
�T�	"�	C��@s�Bc��[RR[RR[5SS5nSVs/sHnSU3PM
 nnSSSSS	S
U-/UQnURU5nUR
XSSS9 gs snf)
N�regrtestdata�import_from_tests)�a�b�cr�rr r!r�rLr0rr�)r�r�r�r�r�rr�)r,r�r�r�r!r�s      r"�test_unload_tests�ArgsTestCase.test_unload_tests�s����'�'�,�,�r�w�w���x�8�-�/B�D��5D�E�_�T�>�$��(�_��E��t�U�D�&�.�7�2J�S�U�S������&���!�!�&�q�!�9��Fs�Bc��SSKn[R
"S5nUR
US9n[RSSUSUR3U/n[R"U[R[RSS	9nURURSU5 g![a [R"S5ef=f)
Nrzrequires _testinternalcapia)
            import sys
            import unittest
            from test import support
            try:
                from _testinternalcapi import get_config
            except ImportError:
                get_config = None

            # WASI/WASM buildbots don't use -E option
            use_environment = (support.is_emscripten or support.is_wasi)

            class WorkerTests(unittest.TestCase):
                @unittest.skipUnless(get_config is None, 'need get_config()')
                def test_config(self):
                    config = get_config()['config']
                    # -u option
                    self.assertEqual(config['buffered_stdio'], 0)
                    # -W default option
                    self.assertTrue(config['warnoptions'], ['default'])
                    # -bb option
                    self.assertTrue(config['bytes_warning'], 2)
                    # -E option
                    self.assertTrue(config['use_environment'], use_environment)

                def test_python_opts(self):
                    # -u option
                    self.assertTrue(sys.__stdout__.write_through)
                    self.assertTrue(sys.__stderr__.write_through)

                    # -W default option
                    self.assertTrue(sys.warnoptions, ['default'])

                    # -bb option
                    self.assertEqual(sys.flags.bytes_warning, 2)

                    # -E option
                    self.assertEqual(not sys.flags.ignore_environment,
                                     use_environment)
        r�r�rLz
--testdir=T)rr�r�)�_testinternalcapirPr�rQr�r�r�rrr�rr�rrr@r	)r,r_r�r�r�rrs       r"�check_add_python_opts�"ArgsTestCase.check_add_python_opts�s���	B�$����' �'
��P�#�#��#�.���~�~��V�V��D�O�O�,�-�����~�~�c�%/�_�_�%/�%6�%6�#'�)��	
������!�T�2��k�	B��#�#�$@�A�A�	B�s�B�!Cc��SH,nURUS9 URU5 SSS5 M. g!,(df   M@=f)N)rFr]r2)r4r�)r,r3s  r"�test_add_python_opts�!ArgsTestCase.test_add_python_opts�s7��-�C����#��&��*�*�3�/�'�&�.�&�&�s	�4�
A	z(raising SIGSEGV on Android is unreliablec��SSKJn [R
"S5nUR
US9n[[R5nSn[R"XE5 URSU[US9nURXcU/SS	S
9 [R(d0[!["R$5*nUR'SUS3U5 UR)US
S	SS9 g![a URS5 N�f=f)Nr)�_sigsegvzneed faulthandler._sigsegvak
            import faulthandler
            import unittest
            from test import support

            class CrashTests(unittest.TestCase):
                def test_crash(self):
                    print("just before crash!", flush=True)

                    with support.SuppressCrashReport():
                        faulthandler._sigsegv(True)
        r�z
handle_segv=0r�r�T)rr�r�z
Exit code z
 (SIGSEGV)zjust before crash!F)r�r�)rr�rPr�r�r�r�r�r�rr�set_sanitizer_env_varrCr�r��
MS_WINDOWSr��signal�SIGSEGVr*r�)r,r�r�r�r�r_r�r
s        r"�test_worker_output_on_failure�*ArgsTestCase.test_worker_output_on_failure�s���	8�-���� �
���#�#��#�.���2�:�:��� ���%�%�c�2�����x�):�$'� �)��	
�!�!�&�*2��()�D�	"�	:��!�!��F�N�N�+�+�H��M�M�J�x�j�
�;�V�D����� 4�4�u��M��?�	8��M�M�6�7�	8�s�C�C=�<C=c�R�[R"S5nURUS9nURSU5nUR	X2SS9 URSU5 [R(a9URSSS	SU5nUR	X2SS
S9 URSU5 gg)Nz�
            import unittest
            from test import support

            class VerboseTests(unittest.TestCase):
                def test_pass(self):
                    print("SPAM SPAM SPAM")
        r�rbrUr�zSPAM SPAM SPAMr�z3:3r�Tr�)r�r�r�rCr��assertNotInrr�r
s    r"rd�ArgsTestCase.test_verbose3	s������ �
���#�#��#�.������h�7���!�!�&�!�!�<����)�6�2�����^�^�D�%���h�O�F��%�%�f�a�$�%�O����-�v�6�	r%c
���[R"S5nURUS9n[RnUR[RU5 URUSU[S9nURXBU[SSS5S9 [USS	9nUR5nSSS5 [R"W5nUR[!UR#S
55S5 UR[!UR#S55S5 UR[!UR#S55S5 USSnURUR#S
5S5 URUR#S5S5 UR%['UR#S55S5 UR)S5Hn	URU	R*S5 M! g!,(df   GNL=f)Nz�
            import unittest

            class VerboseTests(unittest.TestCase):
                def test_failed(self):
                    print("abc \x1b def")
                    self.fail()
        r�z--junit-xmlr�rUrr��utf8r�r�r`r��statusr��result�	completed�timez
system-outzabc \x1b def)r�r�r�rr�r�r�rCr�r�rr�r�r�
fromstringr@r�rcr'�float�iterr�)
r,r�r�r�r�r��content�	testsuite�testcaser6s
          r"�test_xml�ArgsTestCase.test_xml-	s������ �
���#�#��#�.���#�#�����	�(�(�(�3�����-��):� �<���!�!�&�)1�(1�!�Q��(:�	"�	<�
�(�V�
,���g�g�i�G�-� �*�*�7�3�	�����Y�]�]�7�3�4�a�8�����Y�]�]�8�4�5�q�9�����Y�]�]�:�6�7��;��Q�<��?��������h�/��7�������h�/��=����5����f�!5�6��:��=�=��.�C����S�X�X��7�/�-�
,�s�G(�(
G7c�^^�[R"S5nTRUS9m[[R
5nSUS'UU4SjnTR
STUSS9nU"U5 TR
S	STUSS9nU"U5 g)
Na�
            import unittest

            class NonASCIITests(unittest.TestCase):
                def test_docstring(self):
                    '''docstring:\u20ac'''

                def test_subtest(self):
                    with self.subTest(param='subtest:\u20ac'):
                        pass

                def test_skip(self):
                    self.skipTest('skipped:\u20ac')
        r��ascii�PYTHONIOENCODINGc	�>�TRUT[SSS5S9 TRSU5 TRSU5 g)NrrrUr�zdocstring:\u20aczskipped:\u20ac)r�rr*)r�r,r�s ��r"�check�)ArgsTestCase.test_nonascii.<locals>.checkf	s?����%�%�f�h�i��1�a�>P�%�Q��M�M�-�v�6��M�M�+�V�4r%rTFrBr�)r�r�r�r�r�rrC)r,r�r�r�r�r�s`    @r"�
test_nonascii�ArgsTestCase.test_nonasciiR	s�������
 �

���#�#��#�.���2�:�:���")����	5�����h�C�%��H��
�f�
�����t�X�3���O��
�f�
r%c�:�URSS5nUR5R5nURSSSS5nUR5R5nURSU5 UR	[U5[U5S-
5 g)Nz--pgor#r��test_rerU)rC�strip�splitr�r@r�)r,r��	pgo_testsr�s    r"�test_pgo_exclude�ArgsTestCase.test_pgo_excludes	s}�������8���L�L�N�(�(�*�	�������y�I������$�$�&������E�*�����U��S��^�a�%7�8r%rzN)Mr{r|r}r~rCr�r�r�r�r�r�r�rpr�r�rJrrr�r�r�rr�r�r�r�r�r�r�r�r��cpython_onlyr�r�rrrrrr!r%r(r+r.r2r5r8r@rCrGrLrRrUrYr\r`rgro�skipIf�is_wasirtr�r�r�r�r�r�r�r�r��
is_androidr�rdr�r�r�r�rzr%r"r|r|�sQ��.�8�(+�9�"+�>36�j/>�b=�'�/�&'�=� 0�D�49�)��)�0����)�)�+?�@�E�t�E�A�E�1�0�����)�)�+?�@�&�A�&�P����)�)�+?�@�2�A�2� �;�4
���:��:�D� *�D'*�R+�<9�,)*�V+�.+�.+�,+�,+�,+�,+�*+�,:� A�:�":�0
���+��+�>N�8!A�F:�B'0�R,�
9��_�_�W�_�_�E�G�"�G�"�4-<�^%<�N ;�d� ;�D3�2�C�*:�&93�v0��_�_�W�'�'�?�A�"N�A�"N�H7�.#8�J�B	9r%r|c�8�\rSrSrSrSrSrSrSrSr	Sr
g	)
�	TestUtilsi	c��UR[R"S5S5 UR[R"S5S5 UR[R"S5S5 UR[R"S5S5 UR[R"S	5S
5 UR[R"S5S5 UR[R"S
5S5 UR[R"S5S5 UR[R"S5S5 UR[R"S5S5 g)Nrz0 msg��&�.>z1 msg{�G�z�?z10 msg�?z1.5 secrUz1.0 sec�xz2 min�yz2 min 1 seci0*z3 houri�*z3 hour 2 mini1*z3 hour 1 sec)r@r
�format_durationrs r"�test_format_duration�TestUtils.test_format_duration�	s/������.�.�q�1��	!�����.�.�t�4��	!�����.�.�u�5� �	"�����.�.�s�3�"�	$�����.�.�q�1�"�	$�����.�.�v�6� �	"�����.�.�z�:�&�	(�����.�.�x�8�!�	#�����.�.�/E�F�'�	)�����.�.�|�<�'�	)r%c���[nURU"S5S5 URU"SSS9S5 URU"SSS9S5 URU"S	SS95 URU"S
SS95 g)Nz0test_access (test.test_os.FileTests.test_access)�test_accessz(setUpClass (test.test_os.ChownFileTests)T)�is_error�ChownFileTestsz6test_success (test.test_bug.ExampleTests.test_success)r�zsetUpModule (test.test_x)z!tearDownModule (test.test_module))rr@r)r,�	normalizes  r"�test_normalize_test_name�"TestUtils.test_normalize_test_name�	s���'�	�����#U�V�&�	(�����#M�X\�]�)�	+�����#[�fj�k�'�	)����)�$?�$�O�P����)�$G�RV�W�Xr%c��[[R5*S4[[R5*S4S[[R5-S4SS4H+upUR[R"U5X!5 M- g)N�SIGINTr�rz�SIGABRT)l�STATUS_ACCESS_VIOLATION)l��STATUS_STACK_OVERFLOW)r�r�r�r�r�r@r
�get_signal_name)r,r
r�s   r"�test_get_signal_name�TestUtils.test_get_signal_name�	sr���&�-�-� �
 �(�+��&�.�.�!�
!�9�-�
�3�v�~�~�&�
&�	�2�3�1�#
��H�
���U�2�2�8�<�h�Q�#
r%c	���[Rn[RnURU"SS05S5 URU"[RS55S5 URU"[RU55S5 URU"UVs0sHnUS:wdMUS_M sn5S5 URU"0[RU5ESS0E5S	5 gs snf)
Nr�zresources (1): network)r��decimalr�z$resources (3): audio,decimal,networkzresources: allrGzresources: all,-cpur�zresources: all,tzdata)r
�format_resourcesr�r@r�r�)r,r�r�r�s    r"�test_format_resources�TestUtils.test_format_resources�	s��� �1�1���+�+�
�����i��.�/�$�	&�	
����T�]�]�+J�K�L�2�	4�	
����T�]�]�=�9�:��	�	
����]�0�]�T�!%���)�d�D�j�]�0�
1�!�	#�	
����M��
�
�m� <�M�h��M�N�#�	%��0s�"
C5�0C5c�f
�"SS5n[5nUR[U5 U"S5nU"S5nU"S5n[R"[SS5 [/5 UR[
U55 UR[
U55 [S5 UR[
U55 UR[
U55 [UR5S4/5 UR[
U55 UR[
U55 [S	/5 UR[
U55 UR[
U55 UR[
U55 [S
/5 UR[
U55 UR[
U55 [S/5 UR[
U55 [S/5 UR[
U55 [S
/5 UR[
U55 UR[
U55 UR[
U55 [UR5S4UR5S4/5 UR[
U55 UR[
U55 UR[
U55 [SS/5 UR[
U55 UR[
U55 SSS5 [R"[SS5 [UR5S4/5 UR[
U55 UR[
U55 [S/5 UR[
U55 UR[
U55 UR[
U55 [S/5 UR[
U55 UR[
U55 [S/5 UR[
U55 [S/5 UR[
U55 [S/5 UR[
U55 UR[
U55 UR[
U55 [UR5S4UR5S4/5 UR[
U55 UR[
U55 UR[
U55 [SS/5 UR[
U55 UR[
U55 SSS5 [R"[SS5 [SS/5 UR[
U55 UR[
U55 UR[
U55 [SS/5 UR[
U55 UR[
U55 UR[
U55 SSS5 g!,(df   GN\=f!,(df   N�=f!,(df   g=f)Nc� �\rSrSrSrSrSrg)�'TestUtils.test_match_test.<locals>.Testi�	c��Xlgr��test_id)r,r�s  r"�__init__�0TestUtils.test_match_test.<locals>.Test.__init__�	s��&�r%c��UR$rr�rs r"�id�*TestUtils.test_match_test.<locals>.Test.id�	s���|�|�#r%r�N)r{r|r}r~r�rr�rzr%r"�Testr��	s��
'�
$r%rz"test.test_os.FileTests.test_accessz'test.test_os.Win32ErrorTests.test_chdirz#test.test_shutil.TestCopy.test_copy�_test_matchersrzT)�test_osT)�test_*T)�	filetestsT)�	FileTestsT)�*test_os.*.test_*T)r�T)�	DONTMATCHTF)rF)rF)rF)rF)rF)r�F)r	F)�*test_osF)r
T)	rr�rr�	swap_attrrGr
rr~)r,r�patternsr��
test_chdir�	test_copys      r"�test_match_test�TestUtils.test_match_test�	s��	$�	$�#�$�������2��?�@���C�D�
��>�?�	��
�
�w�(8�"�
=��B���O�O�J�{�3�4��O�O�J�z�2�3�
�D�!��O�O�J�{�3�4��O�O�J�z�2�3�
�k�n�n�.��5�6�7��O�O�J�{�3�4����Z�
�3�4�
�.�/�0��O�O�J�{�3�4��O�O�J�z�2�3����Z�	�2�3�
�-�.�/��O�O�J�{�3�4��O�O�J�z�2�3�
�0�1�2����Z��4�5��0�1�2��O�O�J�{�3�4�
�8�9�:��O�O�J�{�3�4��O�O�J�z�2�3����Z�	�2�3�
�k�n�n�.��5�
�
�
���7N�O�P��O�O�J�{�3�4��O�O�J�z�2�3����Z�	�2�3��2�4G�H�I��O�O�J�{�3�4����Z�
�3�4�_>�d�
�
�w�(8�"�
=��k�n�n�.��6�7�8����Z��4�5��O�O�J�z�2�3�
�/�0�1����Z��4�5����Z�
�3�4��O�O�J�y�1�2�
�.�/�0����Z��4�5����Z�
�3�4�
�1�2�3��O�O�J�{�3�4��1�2�3����Z��4�5�
�9�:�;����Z��4�5����Z�
�3�4��O�O�J�y�1�2�
�k�n�n�.��6�����%�8P�Q�R����Z��4�5����Z�
�3�4��O�O�J�y�1�2��3�5I�J�K����Z��4�5��O�O�J�z�2�3�K>�P�
�
�w�(8�"�
=��0�2G�H�I��O�O�J�{�3�4����Z�
�3�4��O�O�J�y�1�2��/�1G�H�I����Z��4�5��O�O�J�z�2�3����Z�	�2�3�>�
=�u>�
=��d>�
=��P>�
=�s'�KY?�I
Z�?B7Z"�?
Z�
Z�"
Z0c�D�[RnURU"S5S5 URU"S5S5 URU"S5S5 URU"S5S5 URU"S	5S	5 URU"S
5S
5 g)Nz
abc  defzabc \x1b\x1f defz
nul:, bell:znul:\x00, bell:\x07u
surrogate:�zsurrogate:\udc80uillegal ￾ and ￿zillegal \ufffe and \uffffza
	buvalid téxt €)r
�sanitize_xmlr@)r,rs  r"�test_sanitize_xml�TestUtils.test_sanitize_xml5
s����)�)��	
����&8�9�,�	.�����&;�<�/�	1�����&8�9�,�	.�����&A�B�5�	7�	
����h�/�!�	#�����&<�=�/�	1r%rzN)r{r|r}r~r�r�r�r�rrr�rzr%r"r�r�	s$��)�,	Y�R�%�(t4�l1r%r��__main__)Cr�dataclassesr&rr|�os.pathr�r8r�r�r�r�rrr�r�r�r��	xml.etreerrLr�test.supportrr�test.libregrtestrrr	r
�test.libregrtest.filterrrr
�test.libregrtest.resultr�test.libregrtest.utilsr�has_subprocess_supportrQr�r�r�r�rnr��normpathr�r�r�rr�rr�r�r��TestCaser�	dataclassr�r�r�force_not_colorized_test_classr.r|r�r{rzr%r"�<module>r#s������	�
���
�	��
��
�����!��5�$�!�"�"�P�P�-�6��%�%�
�
�
�=�
>�>�
�7�7�<�<�������1�4��>��
�7�7�?�?�2�7�7�+�+�H�5�6��
E�
�	���c�h�h�|�,�-�Q�/�������������?�?�$�	��s1��)�)�s1�l
���T�"���#��M�8�$�$�M�`@�|�@�0	�'�'�qK�|�qK�(�qK�h	�'�'�[9�<�[9�(�[9�|,G1��!�!�G1�T�z���M�M�O�r%

Youez - 2016 - github.com/yon3zu
LinuXploit