Sindbad~EG File Manager

Current Path : /proc/2568807/root/usr/local/lib/python3.12/test/__pycache__/
Upload File :
Current File : //proc/2568807/root/usr/local/lib/python3.12/test/__pycache__/test_regrtest.cpython-312.pyc

�

'ΜgRo���dZddlZddlZddlZddlZddlZddlZddlZddl	Z	ddl
Z
ddlZddlZddl
Z
ddlZddlZddlZddlZddlZddlmZddlmZddlmZddlmZddlmZddlmZdd	lmZdd
lmZm Z m!Z!ddl"m#Z#ddl$m%Z%ejLsejNd
��ejPjSejPjUe+�dd�Z,ejPj[ejPj]e,��Z,dZ/dZ0dZ1dZ2dZ3dZ4ejjd�Z6Gd�dejn�Z8ejrd��Gd�d��Z:Gd�dejn�Z;Gd�de;�Z<Gd �d!e;�Z=Gd"�d#e;�Z>Gd$�d%ejn�Z?e@d&k(rej6�yy)'zM
Tests of regrtest.py.

Note: test_regrtest cannot be run twice in parallel.
�N)�ElementTree)�support)�	os_helper)�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} )?�����z�
    from signal import SIGINT, raise_signal
    try:
        raise_signal(SIGINT)
    except ImportError:
        import os
        os.kill(os.getpid(), SIGINT)
    c�<�eZdZdZed��Zd�Zd�Zd�Zd�Z	d�Z
d�Zd	�Zd
�Z
d�Zd�Zd
�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Z d�Z!d�Z"d �Z#d!�Z$d"�Z%d#�Z&d$�Z'd%�Z(d&�Z)d'�Z*d(�Z+d)�Z,d3d*�Z-d+�Z.d,�Z/d-�Z0d.�Z1d/�Z2d0�Z3d1�Z4y2)4�ParseArgsTestCasezC
    Test regrtest's argument parsing, function _parse_args().
    c�,�tj|�S�N)r�_parse_args)�argss �//usr/local/lib/python3.12/test/test_regrtest.py�
parse_argszParseArgsTestCase.parse_args@s���"�"�4�(�(�c��tj�5}|jt�5|j	|�ddd�ddd�|j|j
��y#1swY�2xYw#1swY�6xYwr)r�captured_stderr�assertRaises�
SystemExitr�assertIn�getvalue)�selfr�msg�errs    r�
checkErrorzParseArgsTestCase.checkErrorDsW��
�
$�
$�
&�#�t�/@�/@��/L��O�O�D�!�0M�
&��
�
�c�3�<�<�>�*�0M�/L��
&�
&�s!�A:�A.�A:�.A7	�3A:�:Bc	�j�dD]�}|j|��5tj�5}|jt�5|j|g�ddd�ddd�|j
dj��ddd���y#1swY�<xYw#1swY�@xYw#1swY��xYw)N)z-hz--help��optzRun Python regression tests.)�subTestr�captured_stdoutrr rr!r")r#r)�outs   r�	test_helpzParseArgsTestCase.test_helpIs���!�C����#��&��,�,�.�#��&�&�z�2��O�O�S�E�*�3�/��
�
�<�c�l�l�n�M�	'�&�"�3�2��/�.��'�&�s:�B)�B�B	�B�(B)�B
�B�B&�"B)�)B2	c�n�|jddg�}|j|jd�dD]N}|j|��5|jd|��g�}|j|jd�ddd��P|j	dgd�|j	ddgd	�y#1swY��xYw)
N�	--timeoutz4.2g������@)z-1�0�)�valuez
--timeout=�expected one argument�foozinvalid timeout value:)r�assertEqual�timeoutr*r&)r#�nsr2s   r�test_timeoutzParseArgsTestCase.test_timeoutQs���
�_�_�k�5�1�
2��������S�)�%�E����E��*��_�_�
�5�'�&:�%;�<��� � ����T�2�+�*�%�
	
����
�'>�?�����e�,�.F�G�+�*�s�2B+�+B4	c�^�|jdg�}|j|j�y)N�--wait)r�
assertTrue�wait�r#r7s  r�	test_waitzParseArgsTestCase.test_wait^s"��
�_�_�h�Z�
(�������� rc���dD]_}|j|��5|j|dg�}|j|jd�|j	|gd�ddd��ay#1swY�lxYw)N)z-S�--startr(r4r3)r*rr5�startr&�r#r)r7s   r�
test_startzParseArgsTestCase.test_startbs`��"�C����#��&��_�_�c�5�\�2��� � ����5�1������'>�?�'�&�#�&�&���AA&�&A/	c���|jdg�}|j|jd�|jdg�}|j|jd�|jdg�}|j|jd�|jdgdz�}|j|jd�|jg�}|j|jd�y)N�-v�z-vvvr�	--verboser)rr5�verboser=s  r�test_verbosezParseArgsTestCase.test_verboseis���
�_�_�d�V�
$��������Q�'�
�_�_�f�X�
&��������Q�'�
�_�_�k�]�
+��������Q�'�
�_�_�k�]�Q�.�
/��������Q�'�
�_�_�R�
 ��������Q�'rc��dD]J}|j|��5|j|g�}|j|j�ddd��Ly#1swY�WxYw)N)z-w�--rerunz
--verbose2r()r*rr;�rerunrBs   r�
test_rerunzParseArgsTestCase.test_rerunusI��0�C����#��&��_�_�c�U�+��������)�'�&�1�&�&���.A�A	c��dD]J}|j|��5|j|g�}|j|j�ddd��Ly#1swY�WxYw)N)�-W�
--verbose3r()r*rr;�verbose3rBs   r�
test_verbose3zParseArgsTestCase.test_verbose3{�I��%�C����#��&��_�_�c�U�+��������,�'�&�&�&�&�rOc���dD]f}|j|��5|j|g�}|j|j�|j	|j
d�ddd��hy#1swY�sxYw)N)�-q�--quietr(r)r*rr;�quietr5rIrBs   r�
test_quietzParseArgsTestCase.test_quiet�s]��"�C����#��&��_�_�c�U�+��������)�� � ����Q�/�'�&�#�&�&�s�A
A-�-A6	c��dD]J}|j|��5|j|g�}|j|j�ddd��Ly#1swY�WxYw)N)z-o�	--slowestr()r*rr;�
print_slowrBs   r�test_slowestzParseArgsTestCase.test_slowest�sI��$�C����#��&��_�_�c�U�+������
�
�.�'�&�%�&�&�rOc��|jdg�}|j|j�|jdg�}|j|j�y)Nz--headerrH)rr;�headerr=s  r�test_headerzParseArgsTestCase.test_header�sB��
�_�_�j�\�
*������	�	�"�
�_�_�k�]�
+������	�	�"rc���dD]J}|j|��5|j|g�}|j|j�ddd��Lt	j
�5}d|d<|jdg�}t
j|�}|j|j�|j|jt�|j|jd�|d=|jdg�}t
j|�}|j|j�|j|jt�ddd�y#1swY��]xYw#1swYyxYw)N)�-r�--randomizer(�
1697839080�SOURCE_DATE_EPOCHrd)r*rr;�	randomizer�EnvironmentVarGuardr�Regrtest�assertFalse�assertIsInstance�random_seed�strr5�int)r#r)r7�env�regrtests     r�test_randomizez 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 	�#E,c���|jddg�}|j|jd�|j|j�|jdgd�|jddgd�y)Nz
--randseed�12345i90r3r4�invalid int value)rr5rlr;rgr&r=s  r�
test_randseedzParseArgsTestCase.test_randseed�s^��
�_�_�l�G�4�
5���������/�������%������(?�@�����u�-�/B�Crc��dD]t}|j|��5|j|dg�}|j|jd�|j	|gd�|j	|ddgd�ddd��vy#1swY��xYw)N)�-f�
--fromfiler(r4r3�-s�don't go together)r*rr5�fromfiler&rBs   r�
test_fromfilezParseArgsTestCase.test_fromfile�sv��%�C����#��&��_�_�c�5�\�2��� � ����e�4������'>�?�����e�T� 2�4G�H�	'�&�&�&�&�s�AA;�;B	c��dD]J}|j|��5|j|g�}|j|j�ddd��Ly#1swY�WxYw)N)z-x�	--excluder()r*rr;�excluderBs   r�test_excludezParseArgsTestCase.test_exclude��I��$�C����#��&��_�_�c�U�+������
�
�+�'�&�%�&�&�rOc���dD]_}|j|��5|j|g�}|j|j�|j	|ddgd�ddd��ay#1swY�lxYw)N)ryz--singler(rwr4rz)r*rr;�singler&rBs   r�test_singlezParseArgsTestCase.test_single�s_��#�C����#��&��_�_�c�U�+������	�	�*�����d�E� 2�4G�H�'�&�$�&�&�rDc��dD]`}|j|��5|j|dg�}|j|jdg�|j	|gd�ddd��bdD]`}|j|��5|j|dg�}|j|jdg�|j	|gd�ddd��b|jgd��}|j|jd	d
g�|jgd��}|j|jd	dg�|jgd
��}|j|jdd
g�|jtjtj�ttjd�5}td|��td|��ddd�tjjtj�}|jddd|g�}|j|jgd��|jddd|g�}|j|jgd��y#1swY��dxYw#1swY��xYw#1swY��xYw)N)�-mz--matchr(�pattern)r�Tr3)�-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)r*rr5�match_testsr&�
addCleanupr�unlink�TESTFN�open�print�os�path�abspath)r#r)r7�fp�filenames     r�
test_matchzParseArgsTestCase.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�=AI*�&I7�I'	�*I4	�7Jc�>�dD]�}|j|��5|j|dg�}|j|j�|j|dg�}|j|j�|j	|gd�ddd���y#1swY��xYw)N)z-Gz
--failfastr(rFrQz#-G/--failfast needs either -v or -W)r*rr;�failfastr&rBs   r�
test_failfastzParseArgsTestCase.test_failfast�s~��%�C����#��&��_�_�c�4�[�1��������,��_�_�c�4�[�1��������,������'L�M�'�&�&�&�&�s�A0B�B	c��dD�]y}|j|��5|j|dg�}|j|jddg�|j|dg�}|j|jdg�t	t
j�}|jd�|j|dg�}|j|j|�|j|gd�|j|d	gd
�|j|dg�}|j|jt	t
j�dgz�|j|d
g�}|j|jd
g�ddd���|y#1swY���xYw)N)�-uz--user(zgui,network�gui�networkzgui,none,networkzall,-guir3r4zinvalid resourcez
all,tzdata�tzdata�extralargefile)	r*rr5�
use_resources�listr�
ALL_RESOURCES�remover&)r#r)r7�expecteds    r�test_usezParseArgsTestCase.test_use�s]�� �C����#��&��_�_�c�=�%9�:��� � ��!1�!1�E�9�3E�F��_�_�c�+=�%>�?��� � ��!1�!1�I�;�?��� 5� 5�6������&��_�_�c�:�%6�7��� � ��!1�!1�8�<������'>�?�����e��.@�A��_�_�c�<�%8�9��� � ��!1�!1�!%�g�&;�&;�!<��z�!I�K��_�_�c�+;�%<�=��� � ��!1�!1�4D�3E�F�+'�&�!�&�&�s�EF�F	c���dD]_}|j|��5|j|dg�}|j|jd�|j	|gd�ddd��ay#1swY�lxYw)N)z-Mz
--memlimitr(�4Gr3)r*rr5�memlimitr&rBs   r�
test_memlimitzParseArgsTestCase.test_memlimit
s`��%�C����#��&��_�_�c�4�[�1��� � ����d�3������'>�?�'�&�&�&�&�rDc���|jddg�}|j|jtjjtjd��|jdgd�y)Nz	--testdirr4r3)	rr5�testdirr�r��joinr�SAVEDCWDr&r=s  r�test_testdirzParseArgsTestCase.test_testdirsO��
�_�_�k�5�1�
2��������R�W�W�\�\�)�2D�2D�e�%L�M�����
�'>�?rc��dD]J}|j|��5|j|g�}|j|j�ddd��Ly#1swY�WxYw)N)z-Lz
--runleaksr()r*rr;�runleaksrBs   r�
test_runleakszParseArgsTestCase.test_runleaksrUrOc�|�dD�])}|j|��5|j|dg�}|j|jd�|j|dg�}|j|jd�|j|dg�}|j|jd�|j|d	g�}|j|jd
�|j	|gd�|j	|dgd
�|j	|dgd�|j	|dgd�ddd���,y#1swY��8xYw)N)�-R�--huntrleaksr(�:)rr�
reflog.txtz6:)�rr�z:3)rrr�z
6:3:leaks.log)r�rz	leaks.logr3�6z&needs 2 or 3 colon-separated argumentszfoo:zinvalid huntrleaks valuez6:foo)r*rr5�
huntrleaksr&rBs   r�test_huntrleaksz!ParseArgsTestCase.test_huntrleakss��'�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D1�1D;	c�`�dD]�}|j|��5|j|dg�}|j|jd�|j	|gd�|j	|dgd�|j	|ddgd	�|j	|d
dgd	�ddd���y#1swY��xYw)N)�-jz--multiprocessr(�2rr3r4rt�-Trzr0)r*rr5�use_mpr&rBs   r�test_multiprocessz#ParseArgsTestCase.test_multiprocess0s���)�C����#��&��_�_�c�3�Z�0��� � ����A�.������'>�?�����e��.A�B�����c�4� 0�2E�F�����c�4� 0�2E�F�
'�&�*�&�&�s�BB$�$B-	c��dD]J}|j|��5|j|g�}|j|j�ddd��Ly#1swY�WxYw)N)r��
--coverager()r*rr;�tracerBs   r�
test_coveragezParseArgsTestCase.test_coverage:sI��%�C����#��&��_�_�c�U�+��������)�'�&�&�&�&�rOc	�<�dD]�}|j|��5|j|dg�}|j|jtj
j
tjd��|j|gd�ddd���y#1swY��xYw)N)z-Dz
--coverdirr(r4r3)
r*rr5�coverdirr�r�r�rr�r&rBs   r�
test_coverdirzParseArgsTestCase.test_coverdir@sy��%�C����#��&��_�_�c�5�\�2��� � ����!#�����i�.@�.@�%�!H�J������'>�?�	'�&�&�&�&�s�A/B�B	c��dD]J}|j|��5|j|g�}|j|j�ddd��Ly#1swY�WxYw)N)z-Nz--nocoverdirr()r*r�assertIsNoner�rBs   r�test_nocoverdirz!ParseArgsTestCase.test_nocoverdirHsK��'�C����#��&��_�_�c�U�+���!�!�"�+�+�.�'�&�(�&�&�rOc��dD]s}|j|��5|j|dg�}|j|jd�|j	|gd�|j	|dgd�ddd��uy#1swY��xYw)N)z-tz--thresholdr(�1000��r3r4rt)r*rr5�	thresholdr&rBs   r�test_thresholdz ParseArgsTestCase.test_thresholdNss��&�C����#��&��_�_�c�6�]�3��� � ����t�4������'>�?�����e��.A�B�	'�&�'�&�&�s�AA:�:B	c�v�dD]�}|j|��5tjtj��5}|j|g�}ddd�|j
j�j�}|jd|�ddd���y#1swY�QxYw#1swY��xYw)N)�-nz--nowindowsr(z)the --nowindows (-n) option is deprecated)
r*�
contextlib�redirect_stderr�io�StringIOrr;�	nowindowsr"r!)r#r)�stderrr7r%s     r�test_nowindowsz ParseArgsTestCase.test_nowindowsVs���&�C����#��&��/�/����
�>�&����#��/�B�?�������-��o�o�'���
�
�I�3�O�'�&�'�>�>��'�&�s$�(B/�B#�AB/�#B,�(B/�/B8	c��dD]J}|j|��5|j|g�}|j|j�ddd��Ly#1swY�WxYw)N)z-F�	--foreverr()r*rr;�foreverrBs   r�test_foreverzParseArgsTestCase.test_forever_r�rOc�*�|jdgd�y)Nz--xxxzusage:�r&�r#s r�test_unrecognized_argumentz,ParseArgsTestCase.test_unrecognized_argumentes������	�8�,rc��|jdg�}|j|j�|j|jd�y)Nz--quir)rr;rYr5rIr=s  r�test_long_option__partialz+ParseArgsTestCase.test_long_option__partialhs6��
�_�_�g�Y�
'��������!�������Q�'rc���|jddg�}|j|j�|j|jd�|j|j
�y)NrXr~r)rr;rYr5rIrr=s  r�test_two_optionsz"ParseArgsTestCase.test_two_optionsmsI��
�_�_�i��5�
6��������!�������Q�'�����
�
�#rc�b�|jddg�}|j|jd�y)Nr@r1)rr5rAr=s  r�#test_option_with_empty_string_valuez5ParseArgsTestCase.test_option_with_empty_string_valuess(��
�_�_�i��_�
-��������2�&rc�b�|jdg�}|j|jdg�y)Nr4)rr5rr=s  r�test_argzParseArgsTestCase.test_argws(��
�_�_�e�W�
%��������5�'�*rc���|jddg�}|j|j�|j|jd�|j|j
dg�y)NrXr4r)rr;rYr5rIrr=s  r�test_option_and_argz%ParseArgsTestCase.test_option_and_arg{sO��
�_�_�i��/�
0��������!�������Q�'�������5�'�*rc��|jgd��}|j|jd�|j|jddg�y)N)�test_unaryoprF�
test_binoprGr�r�)rr5rIrr=s  r�test_arg_option_argz%ParseArgsTestCase.test_arg_option_arg�s>��
�_�_�A�
B��������Q�'�������>�<�"@�Arc�*�|jdgd�y)Nz--unknown-optionz(unrecognized arguments: --unknown-optionr�r�s r�test_unknown_optionz%ParseArgsTestCase.test_unknown_option�s�����+�,�B�	Drc��tj|�}tj�5}d|vr|d=t	j
|�}ddd�|S#1swYSxYw)Nrf)rrrrhrri)r#rr7rorps     r�create_regrtestz!ParseArgsTestCase.create_regrtest�sZ��
�
 �
 ��
&���
*�
*�
,��"�c�)��+�,��}�}�R�(�H�-���-���s�A�Ac�B�|j|�}|j|jd�|j|j|�|j	|j
�|j
|jt�|j	|j�|j	|j�|j	|j�|j	|j�|jt|j�t|��|S)N���)r�r5�num_workers�
want_rerunr;rgrkrlrn�fail_env_changed�
fail_rerun�
print_slowest�output_on_failure�sortedr�)r#rr�rMrps     r�
check_ci_modezParseArgsTestCase.check_ci_mode�s����'�'��-������-�-�r�2�����,�,�e�4�����*�*�+����h�2�2�C�8�����1�1�2�����+�+�,�����.�.�/�����2�2�3������ 6� 6�7��
�9N�O��rc��dg}ttj�}|jd�|j	||�}|j|jd�y)N�	--fast-ci�cpu�X)rrr�r�rr5r6�r#rr�rps    r�test_fast_cizParseArgsTestCase.test_fast_ci�sO���}���w�4�4�5�
����U�#��%�%�d�M�:������)�)�7�3rc��gd�}ttj�}|jd�|j	||d��}|j|jd�|j|jd�y)N)r�--pythonz
python -X devrF)rMr)�python�-X�dev)rrr�r�rr5r6�
python_cmdr	s    r�test_fast_ci_python_cmdz)ParseArgsTestCase.test_fast_ci_python_cmd�si��9���w�4�4�5�
����U�#��%�%�d�M��%�G������)�)�7�3�����,�,�.E�Frc��ddg}ttj�}|jd�|jd�|j	||�y)Nrz
-u-networkrr�)rrr�r�r)r#rr�s   r�test_fast_ci_resourcez'ParseArgsTestCase.test_fast_ci_resource�sH���\�*���w�4�4�5�
����U�#����Y�'����4��/rc��dg}ttj�}|j||�}|j	|j
d�y)N�	--slow-cii�)rrr�rr5r6r	s    r�test_slow_cizParseArgsTestCase.test_slow_ci�sA���}���w�4�4�5�
��%�%�d�M�:������)�)�7�3rc�j�dg}tj|�}|j|j�y)Nz--dont-add-python-opts)rrrj�_add_python_opts)r#rr7s   r�test_dont_add_python_optsz+ParseArgsTestCase.test_dont_add_python_opts�s.��(�)��
�
 �
 ��
&������,�,�-rc�b�dg}|j|�}|j|j�y)N�--bisect)r�r;�want_bisect�r#rrps   r�test_bisectzParseArgsTestCase.test_bisect�s+���|���'�'��-������,�,�-rc��gd�}tj�5|j|�}ddd�|jj�|j|jjd�|j|jjd�|j|j�y#1swY��xYw)N)r�z3:10rRr�
)
rrr��assertIsNotNone�hunt_refleakr5�warmups�runsrjrrs   r�test_verbose3_huntrleaksz*ParseArgsTestCase.test_verbose3_huntrleaks�s���+��
�
$�
$�
&��+�+�D�1�H�'����X�2�2�3�����.�.�6�6��:�����.�.�3�3�R�8�����3�3�4�'�
&�s�B6�6B?N)T)5�__name__�
__module__�__qualname__�__doc__�staticmethodrr&r-r8r>rCrJrNrTrZr^rarqrur|r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�rr
rrrrrr%�rrrr;s����)��)�+�
N�H�!�@�
(�*�-�0�/�#�=�,D�I�,�I�"[�HN�G�2@�@�
-�L�"G�*�@�/�C�P�,�-�(�
$�'�+�+�B�
D���4�G�0�4�.�
.�
5rrT)�slotsc�2�eZdZUeed<edzed<eed<y)�Rerun�nameNr��success)r&r'r(rm�__annotations__�boolr+rrr.r.�s��

�I���:��
�Mrr.c�|�eZdZdZdZdZd�Zdd�Zd�Zdd	�Z	d
�Z
dddddddddddddd�
d
�Zdedefd�Z
dd�Zd�Zy)�BaseTestCaserG�test_regrtest_ztest_[a-zA-Z0-9_]+c��tjjtjjt��|_t
j�|_|jtj|j�yr)r�r��realpath�dirname�__file__r��tempfile�mkdtemp�
tmptestdirr�r�rmtreer�s r�setUpzBaseTestCase.setUp�sM���w�w�'�'�������(A�B���"�*�*�,������	�(�(�$�/�/�:rNc�.�|s,dtjz}txjdz
c_|�tjd�}|j|z}t
jj|j|dz�}|jtj|�	t|dd��5}|j|�ddd�|S#1swY|SxYw#t$r1}tj �s|j#d|�d	|����d}~wwxYw)
Nznoop%srGz�
                    import unittest

                    class Tests(unittest.TestCase):
                        def test_empty_test(self):
                            pass
                z.py�xzutf-8��encodingz
cannot write z: )r4�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_testzBaseTestCase.create_test�s�����l�9�9�9�D��'�'�1�,�'��<��?�?�$��D��#�#�d�*���w�w�|�|�D�O�O�T�E�\�:�����	�(�(�$�/�	��d�C�'�2�b������3���
3����	�	��,�,�.��
�
�t�S�A�B���	�s6�#C�1C
�C�
C�C�C�	D�#,D�Dc��tj||tj�}|s|j|�d|���|S)Nz not found in )�re�search�	MULTILINE�fail)r#�regex�outputr�s    r�regex_searchzBaseTestCase.regex_searchs1���	�	�%�����6����I�I�e�V�<�=��rFc��|stj|�}|r|dz
}tjd|ztj�}|j	||�y)N�
�^)rP�escape�compilerR�assertRegex)r#rUr��fullrTs     r�
check_linezBaseTestCase.check_linesG����i�i��(�G���t�O�G��
�
�4�'�>�2�<�<�8�������'rc��dt�d|j�d�}tj||tj�}td�|D��S)NrYz\[ *[0-9]+(?:/ *[0-9]+)*\] (�)c3�>K�|]}|jd����y�w)rGN)�group)�.0r�s  r�	<genexpr>z4BaseTestCase.parse_executed_tests.<locals>.<genexpr>s����7��u�E�K�K��N��s�)�
LOG_PREFIX�TESTNAME_REGEXrP�finditerrRr�)r#rUrT�parsers    r�parse_executed_testsz!BaseTestCase.parse_executed_testss;���� 3� 3�5�����U�F�B�L�L�9���7��7�7�7rr+)
�skipped�failed�env_changed�omittedrM�run_no_tests�resource_deniedrg�parallel�interruptedr�r��filteredc	�
�"�t|t�r|g}t|t�r|g}t|
t�r|
g}
t|t�r|g}t|t�r|g}t|t�r|g}t|	t�r|	g}	t|t�rt|�}|rd}g}|�6|s4|jg}|j
s|j
|j�|j|�}t|�}|�|j
|j�|r&|jt|�t|�|�n|j|||�d��"�"fd�}|r|d|�}|j||�|
r|d|
�}|j||�|r|d|�}|j||�|r|d|�}|j||�|r|d|�}|j||�|��|d	|jg�}|j||�td
z}|j||�d|j�d�}|jr|�d
|j�d�}|j||�|	r|d|	�}|j||�t|�t|�z
t|
�z
t|�z
t|�z
t|�z
t|	�z
}|r>|�d�"|��d�}|s|s|�|j
r
|dkDrd|z}|j||d��|
r|j|d�d|jd��}|r|�d�}|g}|j r|j
d|j d���|j"r|j
d|j"d���ddj%|���}|j||d��t|�t|
�z
}|�t|�}d}n
t|�}d}|
rd}d|��}|s|�dt|���}|r|�d�}|g}d|fd t|�fd!t|�fd"t|
�fd#|fd$t|	�ffD]\}}|s�	|j
|�d%|���� d&dj%|���}|j||d��g} |r| j
d'�n|r|r| j
d(�|
r| j
d)�t'|||
|||f�s| j
d*�n| s| j
d+�d,j%| �} |�|j
rd+nd'}!| �d-|!��} |j|d.| ��d��y)/NTc��|dk7rdSdS)NrG�sr1r+)�counts r�pluralz1BaseTestCase.check_executed_tests.<locals>.pluralDs���1�*�3�,�"�,rc�|��t|�}djt|��}||�|�fz}|�d|�d�}|S)N� z:\n    �$)�lenr�r)�line_format�testsrv�namesrTrws     �r�
list_regexz5BaseTestCase.check_executed_tests.<locals>.list_regexGs@�����J�E��H�H�V�E�]�+�E��5�&��-�"8�8�E�',�e�4�E��Lrz%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\.rGzAll %s)r]z(Test suite interrupted by signal SIGINT.zrun=�,z
 \(filtered\)z	failures=zskipped=z
Total tests: ryr�/rkrlrjrorMrn�=zTotal test files: �FAILUREzENV CHANGED�INTERRUPTEDzNO TESTS RAN�SUCCESS�, z then zResult: )�
isinstancermrnr
r/r0�appendrir�r5�setr^rer�r{�	tests_run�failuresrjr��any)#r#rUr}�statsrjrkrlrmrMrnrorgrprqr�r�rr�rerun_failed�executed�total_testsrrT�good�text�parts�line�run�total_failed�total_rerun�reportr/�ntest�state�	new_staterws#                                  @r�check_executed_testsz!BaseTestCase.check_executed_testsso����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�%���
�
���a��w�/�0�
�%�S�X�X�f�%5�$6�7�������4��0�����L�L��#�
�+��L�L��'���L�L��'��D�&�+�w��!1�3�4��L�L��(���L�L��#��	�	�%� ����%*�]�]�	�	�I��g�V�I�;�/�E�����(�5�'� 2���>rrU�returnc�H�|jd|�}|jd�S)NzUsing random seed: (.*)rG)rVrb)r#rUr�s   r�parse_random_seedzBaseTestCase.parse_random_seed�s#���!�!�"<�f�E���{�{�1�~�rc	���|sd}d|vrtj|d<|jdd�}|�+ttj
�}|jdd�tj|fd|tj|d�|��}|j|k7r[dt|��d|j�d	|�d
|j�d�	}|jr|d|jzz
}|j|�|S)
Nr1r�rorfT)r��input�stdoutrozCommand z failed with exit code z, but exit code z expected!

stdout:
---
z
---
z
stderr:
---
%s---
)
�
subprocess�STDOUT�pop�dictr��environr��PIPE�
returncodermr�r�rS)r#rr��exitcode�kwro�procr$s        r�run_commandzBaseTestCase.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��rc���g}dtjvr|jddg�tjg|�d�d�d�|�}|j|fi|��}|j
S)N�uopsr�faulthandlerz-I)�sys�	_xoptions�extend�
executabler�r�)r#rr��	extraargsr�s     r�
run_pythonzBaseTestCase.run_python�sk���	��S�]�]�"����d�F�^�,����N��N�D�N�.�N�$�N��N���t����+��+���{�{�r)NN�FT)Nr)r&r'r(rCrFrfr>rNrVr^rir�rmr�r�r�r+rrr4r4�sr���N�&�O�*�N�;��<�(�8�&(��)+�R�#'�b�-/�',�u�%�.3�%*�U�]?�~�����!�Frr4c��eZdZd�Zy)�CheckActualTestsc	��gd�}|j|�}t|j��}tjjt
jtjjt��d�}tt
j|��}|j||dzdzddj|j������y)	zP
        Check that regrtest appears to find the expected set of tests.
        )�-Wd�-E�-bbr��
test.regrtest�--list-testsztest*.py�	r z+Unexpectedly low number of tests found in:
r�)r$N)r�r{�
splitlinesr�r�r��globrZr8r9�
assertGreater)r#rrU�rough_number_of_tests_found�actual_testsuite_glob�rough_counted_test_py_filess      r�#test_finds_expected_number_of_testsz4CheckActualTests.test_finds_expected_number_of_tests�s���K������&��&)�&�*;�*;�*=�&>�#� "�����T�[�[�������9R�-S�-7�!9��&)�$�)�)�4I�*J�&K�#�	
���6�6�q�8�"�<�M�"�i�i��(9�(9�(;�<�=� ?�	�	@rN)r&r'r(r�r+rrr�r��s��@rr�c�@��eZdZdZdZ�fd�Zd�Zdd�Zd�Zd�Z	d�Z
d	�Zd
�Zd�Z
d�Zej ej$�d
�ej ej(dk(d�d���Zej ej(dk(d�d��Z�xZS)�ProgramsTestCasezp
    Test various ways to run the Python test suite. Use options close
    to options used on the buildbot.
    rc�l��t�|��t|j�D�cgc]}|j	���c}|_gd�|_ddd|jzg|_|jjd�tjdk(r|jjd�yycc}w)N)r�r�r�z-uallz-rwW�--testdir=%s)r/�3600z-j4�win32r�)
�superr>�range�NTESTrNr}�python_argsr<�
regrtest_argsr�r��platformr�)r#�index�	__class__s  �rr>zProgramsTestCase.setUp
s����
��
��7<�D�J�J�6G�H�6G�U�d�&�&�(�6G�H��
�/���%�v�,�t���>�@������!�!�">�?��<�<�7�"����%�%�d�+�#��
Is�B1c���|j|�}|j|j�|�|j||jdt|j���y)NT)rgr�)r�r;�isdigitr�r}r{)r#rU�randseeds   r�check_outputzProgramsTestCase.check_outputsR���)�)�&�1������(�(�*�H�5��!�!�&�$�*�*�,0��D�J�J��	"�	Irc�L�|j||��}|j|�y)N)ro)r�r�)r#rrorUs    r�	run_testszProgramsTestCase.run_testss"������3��/�����&�!rc���tjj|jd�}g|j�|�|j
�|j�}|j|�y)Nzregrtest.py�r�r�r�r�r�r�r}r��r#�scriptrs   r�test_script_regrtestz%ProgramsTestCase.test_script_regrtest"sO�������d�l�l�M�:��L��!�!�L�6�L�D�,>�,>�L����L�����t�rc�z�g|j�d�d�|j�|j�}|j|�y)Nr��test�r�r�r}r��r#rs  r�test_module_testz!ProgramsTestCase.test_module_test)sJ��2��!�!�2�4�2��2��#�#�2�&*�j�j�2�����t�rc�z�g|j�d�d�|j�|j�}|j|�y)Nr�r�r�r�s  r�test_module_regrtestz%ProgramsTestCase.test_module_regrtest/�J��2��!�!�2�4�2��2��#�#�2�&*�j�j�2�����t�rc�z�g|j�d�d�|j�|j�}|j|�y)Nr�z
test.autotestr�r�s  r�test_module_autotestz%ProgramsTestCase.test_module_autotest5r�rc�~�d}g|j�d�|�|j�|j�}|j|�y)Nzfrom test import autotestz-cr�)r#rLrs   r�test_module_from_test_autotestz/ProgramsTestCase.test_module_from_test_autotest;sO��*��2��!�!�2�4�2��2��#�#�2�&*�j�j�2�����t�rc���tjj|jd�}g|j�|�|j
�|j�}|j|�y)Nzautotest.pyr�r�s   r�test_script_autotestz%ProgramsTestCase.test_script_autotestBsO�������d�l�l�M�:��L��!�!�L�6�L�D�,>�,>�L����L�����t�rc�\�|j|�}|j|j�yr)r�r�r�)r#rr�s   r�	run_batchzProgramsTestCase.run_batchHs$������%�����$�+�+�&rz test.bat script is not installedr�zWindows onlyc���tjjtddd�}d|jzg}tj�dk(r|jd�nTtj�dk(r|jd�n+tj�d	d
k(r|jd�tjs|jd�|j|g|�|j���y)
N�Tools�buildbotztest.batr��ARM64�-arm64�ARM�-arm32r�64bit�-x64z+d)
r�r�r��ROOT_DIRr<r��machiner��architecturer�Py_DEBUGr�r})r#r��	test_argss   r�test_tools_buildbot_testz)ProgramsTestCase.test_tools_buildbot_testLs���
�����h���Z�H��#�d�o�o�5�6�	������(����X�&�
�
�
�
�5�
(����X�&�
�
"�
"�
$�Q�
'�7�
2����V�$�������T�"�����v�7�	�7�D�J�J�7rc�L�tjjtd�}tjj	|�s|jd|�d��dg}t
j�dk(r|jd�nTt
j�dk(r|jd�n+t
j�d	d
k(r|jd�tjr|jd�|j|g|�|j�|j���y)
NzPCbuild\rt.batzFile "z" does not existrWr�r�r�r�rr�r�z-d)r�r�r�r��isfilerKr�r�r�r�rr�r�r�r})r#r��rt_argss   r�test_pcbuild_rtz 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� �����v�J��J�$�*<�*<�J�t�z�z�Jrr)r&r'r(r)r�r>r�r�r�r�r�r�r�r�r��unittest�
skipUnlessrIrJr�r�r�r�
__classcell__)r�s@rr�r�s�����

�E�,�I�"�������'��X���2��2�2�4�;�=��X�������0�.�A�8�B�=�8��X�������0�.�A�K�B�Krr�c��eZdZdZd�Zd�Zd�Zd�Zd�Zd�Z	d�Z
d	�Zd
�Zd�Z
d�Zd
�Zd�Zdd�d�Zej&ej*d�defd��Zd�Zd�Zej&ej*d�d��Zej&ej*d�d��Zd�Zd�Zej<d��Zd�Z d�Z!d�Z"d�Z#d �Z$d!�Z%d"�Z&d#�Z'd$�Z(d%�Z)d&�Z*d'�Z+d(�Z,d)�Z-d*�Z.d+�Z/d,�Z0d-�Z1ej<d.��Z2d/�Z3d0�Z4d1�Z5d2�Z6d3�Z7d4�Z8ejrejtd5�d6��Z;d7�Z<d8�Z=defd9�Z>d:�Z?d;�Z@d<�ZAd=�ZBd>�ZCd?�ZDejrej�d@�dA��ZFdB�ZGdC�ZHyD)E�ArgsTestCasez2
    Test arguments of the Python test suite.
    c�P�ddd|jzg|�}|j|fi|��S)Nr�r�r�)r<r�)r#�testargsr��cmdargss    rr�zArgsTestCase.run_teststs2�����$�/�/�!A�M�H�M���t���w�-�"�-�-rc���tjd�}tdd�D�cgc]}|jd|��|����}}|j|�}|j||dt
|�z��ycc}w)Na
            import unittest

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

                def test_test2(self):
                    pass

                def test_test3(self):
                    pass
        rGr��ok�rLr�r�)rDrEr�rNr�r�r{)r#rL�ir}rUs     r�test_successzArgsTestCase.test_successxs������ �
��AF�a���L��1��!�!�B�q�c�(��!�6���L������'���!�!�&�%�()�C��J��	"�	8��Ms�A3c���tjd�}|jd�}|jd|��}||g}|j|�}|j	|||gd��y)NzQ
            import unittest
            raise unittest.SkipTest("nope")
        r
�skiprrG)rjr��rDrErNr�r�)r#rL�test_ok�	test_skipr}rUs      rrzArgsTestCase.test_skip�su����� �
���"�"�4�(���$�$�V�$�$�7�	��)�$�������'���!�!�&�%�+4�+�()�	"�	+rc	���tjd�}|jd�}|jd|��}||g}|j|dti�}|j|||t
dd���y)	Nz�
            import unittest

            class FailingTest(unittest.TestCase):
                def test_failing(self):
                    self.fail("bug")
        r
�failingrr�rrG�rkr��rDrErNr��EXITCODE_BAD_TESTr�r
)r#rLr�test_failingr}rUs      r�test_failing_testzArgsTestCase.test_failing_test�s~����� �
���"�"�4�(���'�'�	��'�=���,�'�������C�1B�C���!�!�&�%��(1�!�Q��	"�	9rc��i}dD]/}tjd|z�}|j||�||<�1t|j	��}|j
ddg|���}|j
||d��|j
dg|���}|j
|||dd	�
�|j
|dti�}|j
|||d�
�y)
N)�audior�a
                        from test import support; support.requires(%r)
                        import unittest
                        class PassingTest(unittest.TestCase):
                            def test_pass(self):
                                pass
                    r��allrrz-uaudior�rG)ror�r�r)rDrErNr�valuesr�r��EXITCODE_NO_TESTS_RAN)r#r}�resourcerL�
test_namesrUs      r�test_resourceszArgsTestCase.test_resources�s�����,�H��?�?�$�#�
$#�$�D�#�.�.�x��>�E�(�O�-��E�L�L�N�+�
� �����e�9�j�9���!�!�&�*�A�!�>� ����	�7�J�7���!�!�&�*�27�	�2B�()�	"�	+�
 �����L�6K�L���!�!�&�*�2<�()�	"�	+rc��tjd�}|jd|�}|jd|t��}|j|�}|j
d|�}t|jd��}|jdd|��|t��}|j|�}|j||�|j
d|�}t|jd��}|j||�|j|t��}|j|�}|j|j�|�d}	ttj|	�	�}
|jd|t|
�
�}|j|�}|j||	�|j|d�ttjd�	�}
|jd|t|
�
�}|j|�}|j|d�|j|d
�ttjd�	�}
|jd|t|
�
�}|j|�}|j|j�|�y)Nza
            import random
            print("TESTRANDOM: %s" % random.randint(1, 1000))
        �randomrc�r�zTESTRANDOM: ([0-9]+)rG�--randseed=re)rf�r�rozTESTRANDOM: 520�XYZzTESTRANDOM: 22r1)rDrErNr�r"r�rVrnrbr5r;r�r�r�r�r^)r#rLr�rUr�r��test_random�	randseed2�test_random2�	timestampros           rr,zArgsTestCase.test_random�sC����� �
������$�/������d�5J��K���)�)�&�1���!�!�"9�6�B���%�+�+�a�.�)�������H�:�&>��)>� �@���*�*�6�2�	�����H�-��!�!�"9�6�B���5�;�;�q�>�*������{�3�����/D��E���)�)�&�1������(�(�*�H�5�!�	��2�:�:��;������d�5J�$'� �)���)�)�&�1������9�-����� 1�2��2�:�:��7������d�5J�$'� �)���)�)�&�1������5�)����� 0�1��2�:�:��4������d�5J�$'� �)���)�)�&�1������(�(�*�H�5rc
�P�td�D�cgc]}|j���}}tj}|j	tj
|�t
|d�5}d}t|d�D]0\}}d||t|�|fz}|r|d|zz
}t||��|}�2	ddd�|jd|�}t|�}	|j|||	��t
|d�5}t|d�D]$\}}td	|�d
t|��d|��|���&	ddd�|jd|�}|j|||	��t
|d�5}|D]}t||���	ddd�|jd|�}|j|||	��t
|d�5}|D]}td|z|���	ddd�|jd|�}|j|||	��ycc}w#1swY��SxYw#1swY��xYw#1swY��xYw#1swY�ZxYw)
Nrr�rGz00:00:%02i [%s/%s] %sz -- %s took 0 secr�rxr�[r�z] zLib/test/%s.py)r�rNrr�r�r�r��	enumerater{r�r�r�)
r#r�r}r�r��previousr/r�rUr�s
          rr|zArgsTestCase.test_fromfile�s
��16�q��:����!�!�#���:�
�#�#�����	�(�(�(�3��(�C�
 �B��H�(���2���t�/� �%��U��T�:�;����/�(�:�:�D��d��$���
 3�!�����h�7���E�
���!�!�&�%�u�!�=��(�C�
 �B�(���2���t��e�S��Z��>�R�H� 3�!�����h�7���!�!�&�%�u�!�=��(�C�
 �B����d��$��!�����h�7���!�!�&�%�u�!�=��(�C�
 �B����&��-�B�7��!�����h�7���!�!�&�%�u�!�=��[;�!�
 ��!�
 ��!�
 ��!�
 �s6�G2�#AG7�+4H�H�*H�7H�H
�H�H%c��t}|jd|��}|j|t��}|j	|||dd��y)N�sigintrr(Tr�rmrqr�)�TEST_INTERRUPTEDrNr��EXITCODE_INTERRUPTEDr��r#rLr�rUs    r�test_interruptedzArgsTestCase.test_interrupted0sM��������t��4������/C��D���!�!�&�$��.2�!�	"�	=rc��td�D�cgc]}|j���}}|jdg|���}|j||t	|���d|j
�dt	|��d�}|j
||�ycc}w)Nrr\rz10 slowest tests:
(?:- z: .*
){�})r�rNr�r�r{rfr^)r#r�r}rUrTs     rr^zArgsTestCase.test_slowest7s~��16�q��:����!�!�#���:������4�e�4���!�!�&�%�s�5�z�!�B��'�'��U��5��	
�����&��
;s�Bc	�*�t}|jd|��}dD]i}|j|��5|rdd|f}nd|f}|j|dti�}|j|||dd	�
�d}|j
||�ddd��ky#1swY�vxYw)Nr5rr�)�multiprocessingr\�-j2r�Trr6z10 slowest tests:
)r7rNr*r�r8r�r^)r#rLr�r>rrUrTs       r�test_slowest_interruptedz%ArgsTestCase.test_slowest_interruptedAs���������t��4��,�O����o��>�"�'���5�D�'��.�D�'�����M�8L�M���)�)�&�$�26�D�01�*�3�/�������.�?�>� -�>�>�s�A
B	�	B	c��|jd�}|jd|�}|j||gd��d}|j||�y)N�coverager�rGrzLlines +cov% +module +\(path\)\n(?: *[0-9]+ *[0-9]{1,2}% *[^ ]+ +\([^)]+\)+)+)rNr�r�r^)r#r�rUrTs    rr�zArgsTestCase.test_coverageTsO�����
�+������d�3���!�!�&�4�&��!�:�B�������&rc�r�|jd�}|jd|d��}|j|d�y)Nr<r:�key)r�zPress any key to continue)rNr�r^)r#r�rUs   rr>zArgsTestCase.test_wait]s5������'������$�e��<������ ;�<rc	�V�tjd�}|jd|��}|jd|t��}|j||gdz|t
dd�d�	�|jdd
|d��}|j||gdzt|dd�
�t
dd�d��y)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
        r�rr�r(rrGT)rkr�r�rLr�test_run�r�r0r)rMr�r�)rDrErNr�rr�r
r.r9s    rr�zArgsTestCase.test_forevercs������ �
�����	���5������T�<M��N���!�!�&�4�&��(�4�(1�!�Q��*.�	"�	0�
����Y��q��I���!�!�&�4�&��(�(-�d�4>�6:�)<�)2�!�Q��*.�	"�	0rF��run_workersc��|jd|��}d}|jtj|�ddg}|r|j	d�|j	|�|j
|ttjd��}|j||g|d�	�d
}|j||�|�d|�d�}	|j|	|�t|�5}
|
j�}|j|	|�ddd�y#1swYyxYw)
Nr�rr�r��3:3:�-j1�r�r�rGrz6beginning 6 repetitions. .*\n123:456\n[.0-9X]{3} 111\nz leaked [1, 1, 1] z, sum=3
)rNr�rr�r�r�rr�r�r�r^r!r��read)r#rL�whatrIr�r��cmdrUr��line2r��reflogs            r�
check_leakzArgsTestCase.check_leak�s�������4��8�������	�(�(�(�3��v�&����J�J�u���
�
�4�������):�'1�'8�'8�:��	
�!�!�&�4�&��Q�!�G�H�������%�59�4�@���
�
�e�V�$�
�(�^�r��W�W�Y�F��M�M�%��(��^�^�s�#C>�>Dzneed a debug buildrIc�V�tjd�}|j|d|��y)Nz�
            import unittest

            GLOBAL_LIST = []

            class RefLeakTest(unittest.TestCase):
                def test_leak(self):
                    GLOBAL_LIST.append(object())
        �
referencesrH�rDrErS)r#rIrLs   r�check_huntrleakszArgsTestCase.check_huntrleaks�s+����� �
��	
����l���Drc�(�|jd��y�NFrH�rWr�s rr�zArgsTestCase.test_huntrleaks�s�����%��0rc�(�|jd��y�NTrHrZr�s r�test_huntrleaks_mpzArgsTestCase.test_huntrleaks_mp�s�����$��/rc��tjd�}|jd|��}d}|jtj
|�ddd|g}|j|ttjd��}|jd	|��|�|jd	|�d
�|�|jd|�|jd|�d
�|�y)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�rr�r�rKrrMzBisect z
: exit code 0zBisection completed inz
Tests (1):
* z.RefLeakTest.test3
)rDrErNr�rr�r�rr�r�r!)r#rLr�r�rPrUs      r�test_huntrleaks_bisectz#ArgsTestCase.test_huntrleaks_bisect�s������ �
��&����4��8�������	�(�(�(�3��v�z�4�8�������):�'1�'8�'8�:��	
�
�
���v�&��/��
�
���v�]�3�V�<�	
�
�
�.��7��
�
�
���*�
,��	rc�R�tjd�}|j|d�y)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 descriptorsrV)r#rLs  r�test_huntrleaks_fd_leakz$ArgsTestCase.test_huntrleaks_fd_leak�s(����� �
��	
����0�1rc���td�D�cgc]}|j���}}|jdg|���}|j|j	�j�|�ycc}w)Nrr�)r�rNr�r5�rstripr�)r#rr}rUs    r�test_list_testszArgsTestCase.test_list_tests�s_��-2�1�X�6�X���!�!�#�X��6������7��7���������3�3�5��	 ��7s�A)c�>�tjd�}|j|��}d|zd|zg}|jd|�}|j	|j�|�d|zg}|jddd|�}|j	|j�|�y)Nz�
            import unittest

            class Tests(unittest.TestCase):
                def test_method1(self):
                    pass
                def test_method2(self):
                    pass
        rz%s.Tests.test_method1z%s.Tests.test_method2z--list-casesr��test_method1)rDrErNr�r5r�)r#rL�testname�all_methodsrUs     r�test_list_caseszArgsTestCase.test_list_cases�s������ �
���#�#��#�.��/��9�.��9�;�������9������*�*�,�k�:�/��9�:������ $�n� (�*��	
����*�*�,�k�:rc��d}|jd|��}|g}|jdg|��dti�}|j|||dd��y)	Nz,import faulthandler; faulthandler._sigsegv()�crash�r/rLr?r�Tr�rkrpr�)rNr�rr�)r#rL�
crash_testr}rUs     r�test_crashedzArgsTestCase.test_crashed	s^��>���%�%�7��%�>�
���������J��J�8I�J���!�!�&�%�
�+/�q�	"�	:rc��tjdtj��}|j|�D�cgc]}|j	d���c}Scc}w)Nz^(test[^ ]+).*ok$��flagsrG)rPr[rRrgrb)r#rUrTr�s    r�
parse_methodszArgsTestCase.parse_methodssB���
�
�.�b�l�l�C��,1�N�N�6�,B�C�,B�5����A��,B�C�C��Cs�Ac��tjd�}|j|��}tj}|jtj|�dd|zg}t|d�5}|D]}t||���	ddd�|jdd||�}|j|�}d	d
g}|j||�y#1swY�ExYw)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
        rrf�%s.Tests.test_method3r�r�rFr��test_method2�test_method4)rDrErNrr�r�r�r�r�r�rsr5)	r#rLrgr��subsetr�r/rU�methodss	         r�test_ignorefilezArgsTestCase.test_ignorefiles������ �
���#�#��#�.���#�#�����	�(�(�(�3�
�#�h�.�	0��
�(�C�
 �B����d��$��!�����n�h��I���$�$�V�,�� �.�1������&�)�!�
 �s�+C�Cc��tjd�}gd�}|j|��}|jd|�}|j	|�}|j||�tj}|jtj|�dd|zg}t|d�5}|D]}	t|	|���	ddd�|jdd	||�}|j	|�}dd
g}|j||�y#1swY�ExYw)Nru)rfrw�test_method3rxrrFrfrvr�r�r�r})rDrErNr�rsr5rr�r�r�r�r�)
r#rLrhrgrUrzr�ryr�r/s
          r�test_matchfilezArgsTestCase.test_matchfile:s����� �
��7���#�#��#�.������h�/���$�$�V�,������+�.��#�#�����	�(�(�(�3�
�#�h�.�	0��
�(�C�
 �B����d��$��!�����m�X�x�H���$�$�V�,�� �.�1������&�)�!�
 �s�$C>�>Dc
�h�tjd�}|j|��}|j|�}|j	||g|d��|jd|t
��}|j	||g|dd��|jd	|�}|j	||g|t
|dd�
�d��y)
Nz�
            import unittest

            class Tests(unittest.TestCase):
                def test_env_changed(self):
                    open("env_changed", "w").close()
        rrG)rlr��--fail-env-changedr(T�rlr�r�rLrGr)rlrMr�)rDrErNr�r��EXITCODE_ENV_CHANGEDr.�r#rLrgrUs    r�test_env_changedzArgsTestCase.test_env_changedcs������ �
���#�#��#�.������)���!�!�&�8�*�.6�a�	"�	A���� 4�h�)=� �?���!�!�&�8�*�(�37�q�	"�	B����	�8�4���!�!�&�8�*�.6�(-�h�48�6:�)<�)*�	"�	+rc	���tjd�}|j|��}|jd|t��}|j||gt
|dd��tdd	��
�y)Na
            import unittest

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

                def test_fail_always(self):
                    # test that always fails
                    self.fail("bug")
        rrLr(�test_fail_alwaysF)r0rr�rMr�)rDrErNr�rr�r.r
r�s    r�test_rerun_failzArgsTestCase.test_rerun_fail�ss�����
 �

���#�#��#�.�����	�8�>O��P���!�!�&�8�*�(-�h�.@�6;�)=�)2�!�Q��		"�	9rc	��tjjd�}|jtj
|�|j
tjj|��tjd|�d��}|j|��}|jd|d��}|j||gt|dd	�
�tdd��
�t	j
|�|jdd|t��}|j||gt|dd	�
�tdd��
�t	j
|�y)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")
        rrLrr(�test_fail_onceTrGrrGr�z--fail-rerun)r�r�r�r�rr�rj�existsrDrErNr�r�r.r
�EXITCODE_RERUN_FAIL)r#�marker_filenamerLrgrUs     r�test_rerun_successzArgsTestCase.test_rerun_success�s:���'�'�/�/�*D�E�����	�(�(�/�:����������8�9����$� /�1�
2	�	 �
���#�#��#�.�����	�8�a��@���!�!�&�8�*�(-�h�4D�6:�)<�)2�!�Q��		"�	9�
	����)����	�>�8�)<� �>���!�!�&�8�*�(-�h�4D�6:�)<�)2�!�Q��		"�	9�
	����)rc
���tjd�}|j|��}|jd|t��}|j|||gt
|dd��d�	�y)
Na
            import unittest

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

                def test_success(self):
                    return
        rrLr(�ExampleTestsFrGr�rkrMr��rDrErNr�rr�r.r�s    r�#test_rerun_setup_class_hook_failurez0ArgsTestCase.test_rerun_setup_class_hook_failure��p�����
 �

���#�#��#�.�����	�8�>O��P���!�!�&�(�*2��(-�h�4B�6;�)=�)*�	"�	+rc
���tjd�}|j|��}|jd|t��}|j|||gt
|dd��d�	�y)
Na
            import unittest

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

                def test_success(self):
                    return
        rrLr(r�FrGrr�r�r�s    r�&test_rerun_teardown_class_hook_failurez3ArgsTestCase.test_rerun_teardown_class_hook_failure�r�rc
���tjd�}|j|��}|jd|t��}|j|||gt
|dd��d��y)	Nz�
            import unittest

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

            class ExampleTests(unittest.TestCase):
                def test_success(self):
                    return
        rrLr(FrGrr�r�r�s    r�$test_rerun_setup_module_hook_failurez1ArgsTestCase.test_rerun_setup_module_hook_failure�sp�����	 �	
���#�#��#�.�����	�8�>O��P���!�!�&�(�*2��(-�h�48�6;�)=�)*�	"�	+rc
���tjd�}|j|��}|jd|t��}|j||g|gt
|dd��d��y)	Nz�
            import unittest

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

            class ExampleTests(unittest.TestCase):
                def test_success(self):
                    return
        rrLr(FrGrr�r�r�s    r�'test_rerun_teardown_module_hook_failurez4ArgsTestCase.test_rerun_teardown_module_hook_failuresr�����	 �	
���#�#��#�.�����	�8�>O��P���!�!�&�8�*�*2��(-�h�48�6;�)=�)*�	"�	+rc
���tjd�}|j|��}|jd|t��}|j|||gt
|dd��d�	�y)
Nz�
            import unittest

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

                def test_success(self):
                    return
        rrLr(rFrGrr�r�r�s    r�test_rerun_setup_hook_failurez*ArgsTestCase.test_rerun_setup_hook_failure�p�����	 �	
���#�#��#�.�����	�8�>O��P���!�!�&�(�*2��(-�h�4B�6;�)=�)*�	"�	+rc
���tjd�}|j|��}|jd|t��}|j|||gt
|dd��d�	�y)
Nz�
            import unittest

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

                def test_success(self):
                    return
        rrLr(rFrGrr�r�r�s    r� test_rerun_teardown_hook_failurez-ArgsTestCase.test_rerun_teardown_hook_failure2r�rc	���tjd�}|j|��}|jd|t��}|j||t
|dd��d�	�y)
Na

            import unittest

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

                async def test_success(self):
                    return
        rrLr(rFrGrr�r�r�s    r�#test_rerun_async_setup_hook_failurez0ArgsTestCase.test_rerun_async_setup_hook_failureHsk�����	 �	
���#�#��#�.�����	�8�>O��P���!�!�&�(�(-�h�4B�6;�)=�)*�		"�	+rc
���tjd�}|j|��}|jd|t��}|j|||gt
|dd��d�	�y)
Na
            import unittest

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

                async def test_success(self):
                    return
        rrLr(rFrGrr�r�r�s    r�&test_rerun_async_teardown_hook_failurez3ArgsTestCase.test_rerun_async_teardown_hook_failure]r�rc��tjd�}|j|��}|j|ddt��}|j||g|dd��y�	N��
            import unittest

            class Tests(unittest.TestCase):
                def test_bug(self):
                    pass
        rr��
nosuchtestr(rT�rnr�rr�rDrErNr�r"r�r�s    r�test_no_tests_ranzArgsTestCase.test_no_tests_ranssh����� �
���#�#��#�.������$��)>� �@���!�!�&�8�*�/7�()�D�	"�	:rc��tjd�}|j|��}|j|�}|j	||gtdd����y)Nz�
            import unittest

            class Tests(unittest.TestCase):
                def test_skipped(self):
                    self.skipTest("because")
        rrG)rjr)rDrErNr�r�r
r�s    r�test_no_tests_ran_skipz#ArgsTestCase.test_no_tests_ran_skip�s\����� �
���#�#��#�.������)���!�!�&�8�*�(1�!�Q�(?�	"�	Arc���tjd�}|j|��}|j|��}|j||ddt��}|j|||g||gdd��yr�r�)r#rLrg�	testname2rUs     r�,test_no_tests_ran_multiple_tests_nonexistentz9ArgsTestCase.test_no_tests_ran_multiple_tests_nonexistent�s������ �
���#�#��#�.���$�$�$�$�/�	�����)�T�<�)>� �@���!�!�&�8�Y�*?�08�)�/D�()�D�	"�	:rc	��tjd�}|j|��}tjd�}|j|��}|j||ddddd��}|j	|||g|gd	d
��y)Nr�rz�
            import unittest

            class Tests(unittest.TestCase):
                def test_other_bug(self):
                    pass
        r�r��test_other_bugrr(rGTr�r)r#rLrg�
other_coder�rUs      r�)test_no_test_ran_some_test_exist_some_notz6ArgsTestCase.test_no_test_ran_some_test_exist_some_not�s������ �
���#�#��#�.���_�_�&�
�
��$�$�*�$�5�	�����)�T�<� $�&6�� �D���!�!�&�8�Y�*?�08�z�()�D�	"�	:rc��tjd�}|j|��}|jd|t��}|j||g|gdd��y)Na�
            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
        rr�r(TrGr�)rDrErNr�r�r�r�s    r�test_uncollectablezArgsTestCase.test_uncollectable�si����� �
��"�#�#��#�.����� 4�h�)=� �?���!�!�&�8�*�/7�j�37�()�	"�	+rc��tjd�}|j|��}|jdd|t��}|j||g|d��|j
|tjd|ztj��y)	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)
        rr?z
--timeout=1.0r(rrz%s timed out)
rDrErNr�rr�r\rPr[rRr�s    r�test_multiprocessing_timeoutz)ArgsTestCase.test_multiprocessing_timeout�s������ �
��$�#�#��#�.��������):� �<���!�!�&�8�*�)1��	"�	<��������N�X�$=�r�|�|�L�	Nrc��tjd�}|j|��}|jdd|t��}|j||g|gdd��|j
d	|�|j
d
|�y)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(), '')
        rr�rFr(TrGr�zWarning -- Unraisable exceptionzException: weakref callback bug�rDrErNr�r�r�r!r�s    r�test_unraisable_excz ArgsTestCase.test_unraisable_exc�s������ �
��*�#�#��#�.����� 4�d�H�)=� �?���!�!�&�8�*�/7�j�37�()�	"�	+�	
�
�
�7��@��
�
�7��@rc��tjd�}|j|��}|jdd|t��}|j||g|gdd��|j
d	|�|j
d
|�y)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(), '')
        rr�rFr(TrGr�z$Warning -- Uncaught thread exceptionzException: bug in threadr�r�s    r�test_threading_excepthookz&ArgsTestCase.test_threading_excepthooks������ �
��&�#�#��#�.����� 4�d�H�)=� �?���!�!�&�8�*�/7�j�37�()�	"�	+�	
�
�
�<�f�E��
�
�0�&�9rc	�<�tjd�}|j|��}d}dD]b}|j|��5d||g}|j|dt
i�}|j
||g|gdd	�
�|j||�ddd��dy#1swY�oxYw)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
        rzFtest_print_warning.*msg1: stdout\nWarning -- msg2: print_warning\nok\n)rFrQ)�optionr�r�TrGr�)rDrErNr*r�r�r�r\)r#rLrgrTr�rPrUs       r�test_print_warningzArgsTestCase.test_print_warning6s������ �
��$�#�#��#�.����#�F����V��,�+�V�X�>��'�����L�7K�L���)�)�&�8�*�7?�j�;?�01�*�3�� � ���/�-�,�#�,�,�s
�AB�B	c���tjjtj�}|j|tj�d��|j
�r|jd�yy)Nz not setzModified guard)r�r��getr�UNICODE_GUARD_ENVr!�isasciirK)r#�guards  r�test_unicode_guard_envz#ArgsTestCase.test_unicode_guard_env_sU���
�
���u�6�6�7�����U�u�'>�'>�&?�x�$H�I��=�=�?�
�M�M�*�+�rc���tjj|jd�}tj|�tjj|jd�}t|d�j
�||g}ddd|jzdg}|j|�|D]1}|jtjj|�|��3y)N�test_python_123�test_python_456�wbr�r�z--tempdir=%sz	--cleanup)
r�r�r�r<�mkdirr��closer�rjr�)r#r8r�r~rr/s      r�test_cleanupzArgsTestCase.test_cleanupgs����'�'�,�,�t���0A�B��
������7�7�<�<����1B�C���X�t��"�"�$��(�#����!�D�O�O�3�� ��	
���� ��D����R�W�W�^�^�D�1�4�8�rz.checking temp files is not implemented on WASIc
�:�tjd�}td�D�cgc]}|j|����}}|jdddg|��dt
i�}|j
|||ddt|��	�|D]}|jd
|�d�|��ycc}w)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')
        rrr�rFr?r�T)rlr�rpr�zWarning -- z& leaked temporary files (1): mytmpfile)	rDrEr�rNr�r�r�r{r!)r#rL�_�	testnamesrUrgs      r�test_leak_tmp_filezArgsTestCase.test_leak_tmp_filevs������
 �

��;@��(�C�(�Q�T�%�%�4�%�0�(�	�C����� 4�d�E�?�I�?�)=�?���!�!�&�)�.7�37�+/�(+�I��		"�	8�
"�H��M�M�K��z�21�2� �
"�"��Ds�Bc��tjdk(rtj�}nItjj
}|�-tjj
}|�|jd�td�tdd�D��}d|fz}d}||jd�z
}	|j|�|j|�d	��|j|d
�}tjd|�d��}|j|�
�}|j!ddd|�}|j#||gdd��|j%||d��y#t$rY��wxYw)Nr�z#cannot get regrtest worker encodingc3� K�|]}|���y�wrr+)rc�chs  rrdz8ArgsTestCase.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 bytes�backslashreplacez�
            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()
        rr�rFrLTrG)rpr�F)rT)r�r��locale�getencodingr�rB�
__stdout__rK�bytesr��encode�decode�UnicodeDecodeErrorrDrErNr�r�r^)	r#rB�nonascii�corrupted_output�assertion_failed�
expected_linerLrgrUs	         r�test_worker_decode_errorz%ArgsTestCase.test_worker_decode_error�si���<�<�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���!�!�&�8�*�+/�()�	"�	+�	
����
�U��;��5"�	��	�s�+E�	E�Ec���tjd�}|j|��}|jddd|t��}|j||g|gdt
ddd	��
�y)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
        rr�rFrLr(TrGrrmrr�s    r�test_doctestzArgsTestCase.test_doctest�sv����� �
��:�#�#��#�.����� 4�d�E�8�):� �<���!�!�&�8�*�*2��+/�(1�!�Q��(:�	"�	<rc�F�tjd�}tdd�D�cgc]}|jd|��|����}}d}dd|��g}|r|j	d	t|����|j
|�|j|�}tj|�td
�D�cgc]}tjdd���}	}d
|	��}
d}tj||tj��}|j||
gt|�z�ycc}wcc}w)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}")
        rGrr,rliJ�3rdr)r�r rr�zRandom numbers: z^Random numbers: .*$rq)rDrEr�rNr�r{r�r�r'�seed�randintrP�findallrRr5)
r#rIrLrr}rlrPrUr��numbersr�rT�matchess
             r�_check_random_seedzArgsTestCase._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�F�"�,�,�?������8�*�s�5�z�"9�:��))��?s�D�-Dc�(�|jd��yrY�r�r�s r�test_random_seedzArgsTestCase.test_random_seed
s�����E��2rc�(�|jd��yr\r�r�s r�test_random_seed_workersz%ArgsTestCase.test_random_seed_workers
s�����D��1rc�>�tjd�}td�D�cgc]}|j|����}}tj
ddg}t
j|�}|jd|dg|���}|j||t|�d�	�ycc}w)
Nz�
            import sys
            import unittest

            class WorkerTests(unittest.TestCase):
                def test_dev_mode(self):
                    self.assertTrue(sys.flags.dev_mode)
        rrrrrz-j0T�r�rp)rDrEr�rNr�r��shlexr�r�r�r{)r#rLr�r}rrUs      r�test_python_commandz ArgsTestCase.test_python_commands������ �
��7<�A�h�?�h���!�!�t�!�,�h��?��n�n�d�E�2�
��Z�Z�
�+�
�����
�J��F��F���!�!�&�%�(+�E�
�T�	"�	C��@s�Bc��tjjtjjt�dd�}dD�cgc]}d|����	}}ddddd	d
|zg|�}|j|�}|j
||d��ycc}w)
N�regrtestdata�import_from_tests)�a�b�cr5r�r�r�r�r�r�rr)r�r�r�r8r9r�r�)r#r�r/r}rrUs      r�test_unload_testszArgsTestCase.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�<�tjd�}|j|��}tjdd|d|j
��|g}t
j|tjtjd��}|j|jd|�y)	Na)
            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)
        rr�r�z
--testdir=T)r�r�r�r)rDrErNr�r�r<r�r�r�r�r5r�)r#r�rLrgrPr�s      r�check_add_python_optsz"ArgsTestCase.check_add_python_opts8s������' �'
��P�#�#��#�.���~�~��V�V��D�O�O�,�-�����~�~�c�%/�_�_�%/�%6�%6�#'�)��	
������!�T�2rc��dD].}|j|��5|j|�ddd��0y#1swY�;xYw)N)rrr()r*r�)r#r)s  r�test_add_python_optsz!ArgsTestCase.test_add_python_optsos7��-�C����#��&��*�*�3�/�'�&�.�&�&�s�5�>	z(raising SIGSEGV on Android is unreliablec��	ddlm}t	j
d�}|j
|��}ttj�}d}tj||�|jd|t|��}|j|||gdd	�
�tjs0t!t"j$�}|j'd|�d�|�|j)|d
d	d��y#t$r|jd�Y��wxYw)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)
        rz
handle_segv=0rLr*T)rkr�rpz
Exit code z
 (SIGSEGV)zjust before crash!F)r]rT)r�r�ImportErrorrKrDrErNr�r�r�r�set_sanitizer_env_varr�rr��
MS_WINDOWSrn�signal�SIGSEGVr!r^)r#rrLrgror�rUr�s        r�test_worker_output_on_failurez*ArgsTestCase.test_worker_output_on_failureus���	8�-���� �
���#�#��#�.���2�:�:��� ���%�%�c�6�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&�&D�Dc�\�tjd�}|j|��}|jd|�}|j	||d��|jd|�tjr=|jddd	d|�}|j	||dd
��|jd|�yy)Nz�
            import unittest
            from test import support

            class VerboseTests(unittest.TestCase):
                def test_pass(self):
                    print("SPAM SPAM SPAM")
        rrRrGrzSPAM SPAM SPAMr�z3:3rLTr�)rDrErNr�r��assertNotInrr�r�s    rrTzArgsTestCase.test_verbose3�s������ �
���#�#��#�.������h�7���!�!�&�(�!�!�<����)�6�2�����^�^�D�%���h�O�F��%�%�f�h�a�$�%�O����-�v�6�	rc
��tjd�}|j|��}tj}|jtj|�|j|d|t��}|j|||tddd���t|d�	�5}|j�}ddd�tj�}|jt!|j#d
��d�|jt!|j#d��d�|jt!|j#d��d�|dd}|j|j#d
�d�|j|j#d�d�|j%t'|j#d��d�|j)d�D]}	|j|	j*d�� y#1swY��DxYw)Nz�
            import unittest
            from test import support

            class VerboseTests(unittest.TestCase):
                def test_failed(self):
                    print("abc \x1b def")
                    self.fail()
        rz--junit-xmlr(rGrr�utf8rAr}�errorsr��statusr��result�	completed�timez
system-outzabc \x1b def)rDrErNrr�r�r�r�rr�r
r�rNr�
fromstringr5rnr�r��float�iterr�)
r#rLrgr�rUr��content�	testsuite�testcaser,s
          r�test_xmlzArgsTestCase.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�G1�1G;N)Ir&r'r(r)r�rrrr%r,r|r:r^r@r�r>r�rSrrrr�r2rWr�r]r_rardri�cpython_onlyrorsr{r~r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r��skipIf�is_wasir�r�r�r�r�r�r�r�r�r�
is_androidrrTrr+rrrrosG���.�8�(+�9�"+�>36�j/>�b=�'�/�&'�=� 0�D5:�)�0�X����)�)�+?�@�E�t�E�A�E�1�0��X����)�)�+?�@�&�A�&�P�X����)�)�+?�@�2�A�2� �;�4
���:��:�D� *�D'*�R+�<9�,)*�V+�.+�.+�,+�,+�,+�,+�*+�,:� A�:�":�0
���+��+�6N�8!A�F:�B'0�R,�
9��X�_�_�W�_�_�E�G�"�G�"�4-<�^%<�N ;�d� ;�D3�2�C�*:�&53�n0��X�_�_�W�'�'�?�A�"N�A�"N�H7�.$8rrc�0�eZdZd�Zd�Zd�Zd�Zd�Zd�Zy)�	TestUtilsc���|jtjd�d�|jtjd�d�|jtjd�d�|jtjd�d�|jtjd	�d
�|jtjd�d�|jtjd
�d�|jtjd�d�|jtjd�d�|jtjd�d�y)Nrz0 msg��&�.>z1 msg{�G�z�?z10 msg�?z1.5 secrGz1.0 sec�xz2 min�yz2 min 1 seci0*z3 houri�*z3 hour 2 mini1*z3 hour 1 sec)r5r	�format_durationr�s r�test_format_durationzTestUtils.test_format_duration�s/������.�.�q�1��	!�����.�.�t�4��	!�����.�.�u�5� �	"�����.�.�s�3�"�	$�����.�.�q�1�"�	$�����.�.�v�6� �	"�����.�.�z�:�&�	(�����.�.�x�8�!�	#�����.�.�/E�F�'�	)�����.�.�|�<�'�	)rc��t}|j|d�d�|j|dd��d�|j|dd��d�|j|d	d���|j|d
d���y)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)rzsetUpModule (test.test_x)z!tearDownModule (test.test_module))rr5r�)r#�	normalizes  r�test_normalize_test_namez"TestUtils.test_normalize_test_name�s���'�	�����#U�V�&�	(�����#M�X\�]�)�	+�����#[�fj�k�'�	)����)�$?�$�O�P����)�$G�RV�W�Xrc���ttj�dfttj�dfddfD]+\}}|j	tj|�||��-y)N�SIGINTr)l�STATUS_ACCESS_VIOLATION)l��STATUS_STACK_OVERFLOW)rnrr+rr5r	�get_signal_name)r#r�r�s   r�test_get_signal_namezTestUtils.test_get_signal_name�s`���&�-�-� �
 �(�+��&�.�.�!�
!�9�-�3�1�	#
��H�h�
���U�2�2�8�<�h��Q�
#
rc�^�tj}tj}|j|d�d�|j|d�d�|j||�d�|j|t	d�|D���d�|j|g|�d���d	�y)
N)r�zresources (1): network)r�decimalr�z$resources (3): audio,decimal,networkzresources: allc3�*K�|]}|dk7r|���
y�w)rNr+)rcr/s  rrdz2TestUtils.test_format_resources.<locals>.<genexpr>	s����#5�M�D�&*�e�m�$(�M�s�zresources: all,-cpur�zresources: all,tzdata)r	�format_resourcesr�r5�tuple)r#r3r�s   r�test_format_resourceszTestUtils.test_format_resources	s��� �1�1���+�+�
�����\�*�$�	&�	
����<�=�2�	4�	
����]�+��	�	
����U�#5�M�#5�5�
6�!�	#�	
����7�}�7�h�7�8�#�	%rc�B
�Gd�d�}t�}|jt|�|d�}|d�}|d�}tjtdd�5tg�|jt
|��|jt
|��td�|jt
|��|jt
|��t|j�dfg�|jt
|��|jt
|��td	g�|jt
|��|jt
|��|jt
|��td
g�|jt
|��|jt
|��tdg�|jt
|��tdg�|jt
|��td
g�|jt
|��|jt
|��|jt
|��t|j�df|j�dfg�|jt
|��|jt
|��|jt
|��tddg�|jt
|��|jt
|��ddd�tjtdd�5t|j�dfg�|jt
|��|jt
|��tdg�|jt
|��|jt
|��|jt
|��tdg�|jt
|��|jt
|��tdg�|jt
|��tdg�|jt
|��tdg�|jt
|��|jt
|��|jt
|��t|j�df|j�dfg�|jt
|��|jt
|��|jt
|��tddg�|jt
|��|jt
|��ddd�tjtdd�5tddg�|jt
|��|jt
|��|jt
|��tddg�|jt
|��|jt
|��|jt
|��ddd�y#1swY��UxYw#1swY��xYw#1swYyxYw)Nc��eZdZd�Zd�Zy)�'TestUtils.test_match_test.<locals>.Testc��||_yr��test_id)r#r;s  r�__init__z0TestUtils.test_match_test.<locals>.Test.__init__	s	��&��rc��|jSrr:r�s r�idz*TestUtils.test_match_test.<locals>.Test.id	s���|�|�#rN)r&r'r(r<r>r+rr�Testr8	s��
'�
$rr?z"test.test_os.FileTests.test_accessz'test.test_os.Win32ErrorTests.test_chdirz#test.test_shutil.TestCopy.test_copy�_test_matchersr+T)�test_osT)�test_*T)�	filetestsT)�	FileTestsT)�*test_os.*.test_*T)r%T)�	DONTMATCHTF)rAF)rBF)rCF)rDF)rEF)r%F)rFF)�*test_osF)rGT)	r
r�rr�	swap_attrr;rr>rj)r#r?�patternsr%�
test_chdir�	test_copys      r�test_match_testzTestUtils.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�Zc�D�tj}|j|d�d�|j|d�d�|j|d�d�|j|d�d�|j|d	�d	�|j|d
�d
�y)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_xmlr5)r#rNs  r�test_sanitize_xmlzTestUtils.test_sanitize_xml�	s����)�)��	
����&8�9�,�	.�����&;�<�/�	1�����&8�9�,�	.�����&A�B�5�	7�	
����h�/�!�	#�����&<�=�/�	1rN)	r&r'r(r#r)r/r5rLrOr+rrrr�s$��)�,	Y�R�%�(t4�l1rr�__main__)Ar)r��dataclassesr�r�r��os.pathr�r�r'rPr�rr�r�rIr:rDr�	xml.etreerr�r�test.supportr�test.libregrtestrrrr	�test.libregrtest.filterr
rr�test.libregrtest.resultr
�test.libregrtest.utilsr�has_subprocess_support�SkipTestr�r�r8r9r�r��normpathrerr�r"r�r8rEr7�TestCaser�	dataclassr.r4r�r�rrr&r+rr�<module>r^s�������	�
���
�	��
��
�����!��"�$�!�"�"�P�P�-�6��%�%�
�(�
�
�=�
>�>�
�7�7�<�<�������1�4��>��
�7�7�?�?�2�7�7�+�+�H�5�6��
E�
�����������"�8�?�?�$�	��X5��)�)�X5�v����T�"���#��J�8�$�$�J�Z@�|�@�0jK�|�jK�Zg8�<�g8�T+F1��!�!�F1�R�z���H�M�M�O�r

Sindbad File Manager Version 1.0, Coded By Sindbad EG ~ The Terrorists