HEX
Server: Apache
System: Linux bd12.noc223.com 4.18.0-553.121.1.lve.el8.x86_64 #1 SMP Thu Apr 30 16:40:41 UTC 2026 x86_64
User: handcraf (1693)
PHP: 8.1.28
Disabled: NONE
Upload Files
File: //opt/alt/python312/lib64/python3.12/test/__pycache__/test_regrtest.cpython-312.pyc
�

h�e�^��z�dZddlZddlZddlZddlZddlZddlZddlZddl	Z	ddl
Z
ddlZddlZddl
Z
ddlZddlZddlZddlZddlZddlmZddlmZddlmZddlmZddlmZddlmZdd	lmZmZdd
lm Z ddl!m"Z"ejFsejHd��ejJjMejJjOe(�d
d
�Z)ejJjUejJjWe)��Z)dZ,dZ-dZ.dZ/dZ0dZ1ejdd�Z3Gd�dejh�Z5ejld��Gd�d��Z7Gd�dejh�Z8Gd�de8�Z9Gd�d e8�Z:Gd!�d"e8�Z;Gd#�d$ejh�Z<e=d%k(rej2�yy)&zM
Tests of regrtest.py.

Note: test_regrtest cannot be run twice in parallel.
�N)�support)�	os_helper)�cmdline)�main)�setup)�utils)�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+d0d)�Z,d*�Z-d+�Z.d,�Z/d-�Z0d.�Z1y/)1�ParseArgsTestCasezC
    Test regrtest's argument parsing, function _parse_args().
    c�,�tj|�S�N)r�_parse_args)�argss �9/opt/alt/python312/lib64/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.checkErrorBsg��
�
$�
$�
&�	"�#�t�/@�/@��/L�	"��O�O�D�!�	"�	"��
�
�c�3�<�<�>�*�	"�	"��	"�	"�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_stdoutrrrrr )r!r'�outs   r�	test_helpzParseArgsTestCase.test_helpGs���!�	N�C����#��&�
N��,�,�.�+�#��&�&�z�2�+��O�O�S�E�*�+�+��
�
�<�c�l�l�n�M�	
N�
N�	N�+�+��+�+��
N�
N�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!�nsr0s   r�test_timeoutzParseArgsTestCase.test_timeoutOs���
�_�_�k�5�1�
2��������S�)�%�	3�E����E��*�
3��_�_�
�5�'�&:�%;�<��� � ����T�2�
3�
3�	3�
	
����
�'>�?�����e�,�.F�G�
3�
3�s�2B+�+B4	c�^�|jdg�}|j|j�y)N�--wait)r�
assertTrue�wait�r!r5s  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&r2r1)r(rr3�startr$�r!r'r5s   r�
test_startzParseArgsTestCase.test_start`sw��"�	@�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)rr3�verboser;s  r�test_verbosezParseArgsTestCase.test_verbosegs���
�_�_�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(rr9�rerunr@s   r�
test_rerunzParseArgsTestCase.test_rerunssY��0�	*�C����#��&�
*��_�_�c�U�+��������)�
*�
*�	*�
*�
*���.A�A	c��dD]J}|j|��5|j|g�}|j|j�ddd��Ly#1swY�WxYw)N)�-W�
--verbose3r&)r(rr9�verbose3r@s   r�
test_verbose3zParseArgsTestCase.test_verbose3y�Y��%�	-�C����#��&�
-��_�_�c�U�+��������,�
-�
-�	-�
-�
-�rMc���dD]f}|j|��5|j|g�}|j|j�|j	|j
d�ddd��hy#1swY�sxYw)N)�-q�--quietr&r)r(rr9�quietr3rGr@s   r�
test_quietzParseArgsTestCase.test_quietsm��"�	0�C����#��&�
0��_�_�c�U�+��������)�� � ����Q�/�
0�
0�	0�
0�
0�s�A
A-�-A6	c��dD]J}|j|��5|j|g�}|j|j�ddd��Ly#1swY�WxYw)N)z-o�	--slowestr&)r(rr9�
print_slowr@s   r�test_slowestzParseArgsTestCase.test_slowest�sY��$�	/�C����#��&�
/��_�_�c�U�+������
�
�.�
/�
/�	/�
/�
/�rMc��|jdg�}|j|j�|jdg�}|j|j�y)Nz--headerrF)rr9�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_EPOCHrb)r(rr9�	randomizer�EnvironmentVarGuardr�Regrtest�assertFalse�assertIsInstance�random_seed�strr3�int)r!r'r5�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�12345i90r1r2�invalid int value)rr3rjr9rer$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&r2r1�-s�don't go together)r(rr3�fromfiler$r@s   r�
test_fromfilezParseArgsTestCase.test_fromfile�s���%�	I�C����#��&�
I��_�_�c�5�\�2��� � ����e�4������'>�?�����e�T� 2�4G�H�	
I�
I�	I�
I�
I�s�AA;�;B	c��dD]J}|j|��5|j|g�}|j|j�ddd��Ly#1swY�WxYw)N)z-x�	--excluder&)r(rr9�excluder@s   r�test_excludezParseArgsTestCase.test_exclude��Y��$�	,�C����#��&�
,��_�_�c�U�+������
�
�+�
,�
,�	,�
,�
,�rMc���dD]_}|j|��5|j|g�}|j|j�|j	|ddgd�ddd��ay#1swY�lxYw)N)rwz--singler&rur2rx)r(rr9�singler$r@s   r�test_singlezParseArgsTestCase.test_single�sv��#�	I�C����#��&�
I��_�_�c�U�+������	�	�*�����d�E� 2�4G�H�
I�
I�	I�
I�
I�rBc��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�Tr1)�-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(rr3�match_testsr$�
addCleanupr�unlink�TESTFN�open�print�os�path�abspath)r!r'r5�fp�filenames     r�
test_matchzParseArgsTestCase.test_match�sG��"�	@�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&rDrOz#-G/--failfast needs either -v or -W)r(rr9�failfastr$r@s   r�
test_failfastzParseArgsTestCase.test_failfast�s���%�	N�C����#��&�
N��_�_�c�4�[�1��������,��_�_�c�4�[�1��������,������'L�M�
N�
N�	N�
N�
N�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,-guir1r2zinvalid resourcez
all,tzdata�tzdata�extralargefile)	r(rr3�
use_resources�listr�
ALL_RESOURCES�remover$)r!r'r5�expecteds    r�test_usezParseArgsTestCase.test_use�st�� �	G�C����#��&�
G��_�_�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�+
G�
G�	G�
G�
G�s�EF�F	c���dD]_}|j|��5|j|dg�}|j|jd�|j	|gd�ddd��ay#1swY�lxYw)N)z-Mz
--memlimitr&�4Gr1)r(rr3�memlimitr$r@s   r�
test_memlimitzParseArgsTestCase.test_memlimitsw��%�	@�C����#��&�
@��_�_�c�4�[�1��� � ����d�3������'>�?�
@�
@�	@�
@�
@�rBc���|jddg�}|j|jtjjtjd��|jdgd�y)Nz	--testdirr2r1)	rr3�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(rr9�runleaksr@s   r�
test_runleakszParseArgsTestCase.test_runleaksrSrMc�|�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.logr1�6z&needs 2 or 3 colon-separated argumentszfoo:zinvalid huntrleaks valuez6:foo)r(rr3�
huntrleaksr$r@s   r�test_huntrleaksz!ParseArgsTestCase.test_huntrleakss*��'�	L�C����#��&�

L��_�_�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�

L�

L�	L�

L�

L�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&�2r
r1r2rr�-Trxr.)r(rr3�use_mpr$r@s   r�test_multiprocessz#ParseArgsTestCase.test_multiprocess.s���)�	G�C����#��&�
G��_�_�c�3�Z�0��� � ����A�.������'>�?�����e��.A�B�����c�4� 0�2E�F�����c�4� 0�2E�F�

G�
G�	G�
G�
G�s�BB$�$B-	c��dD]J}|j|��5|j|g�}|j|j�ddd��Ly#1swY�WxYw)N)r��
--coverager&)r(rr9�tracer@s   r�
test_coveragezParseArgsTestCase.test_coverage8sY��%�	*�C����#��&�
*��_�_�c�U�+��������)�
*�
*�	*�
*�
*�rMc	�<�dD]�}|j|��5|j|dg�}|j|jtj
j
tjd��|j|gd�ddd���y#1swY��xYw)N)z-Dz
--coverdirr&r2r1)
r(rr3�coverdirr�r�r�rr�r$r@s   r�
test_coverdirzParseArgsTestCase.test_coverdir>s���%�	@�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�r@s   r�test_nocoverdirz!ParseArgsTestCase.test_nocoverdirFs[��'�	/�C����#��&�
/��_�_�c�U�+���!�!�"�+�+�.�
/�
/�	/�
/�
/�rMc��dD]s}|j|��5|j|dg�}|j|jd�|j	|gd�|j	|dgd�ddd��uy#1swY��xYw)N)z-tz--thresholdr&�1000��r1r2rr)r(rr3�	thresholdr$r@s   r�test_thresholdz ParseArgsTestCase.test_thresholdLs���&�	C�C����#��&�
C��_�_�c�6�]�3��� � ����t�4������'>�?�����e��.A�B�	
C�
C�	C�
C�
C�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�StringIOrr9�	nowindowsr r)r!r'�stderrr5r#s     r�test_nowindowsz ParseArgsTestCase.test_nowindowsTs���&�	P�C����#��&�
P��/�/����
�>�0�&����#��/�B�0�������-��o�o�'���
�
�I�3�O�
P�
P�	P�0�0��
P�
P�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(rr9�foreverr@s   r�test_foreverzParseArgsTestCase.test_forever]rrMc�*�|jdgd�y)Nz--xxxzusage:�r$�r!s r�test_unrecognized_argumentz,ParseArgsTestCase.test_unrecognized_argumentcs������	�8�,rc��|jdg�}|j|j�|j|jd�y)Nz--quir)rr9rWr3rGr;s  r�test_long_option__partialz+ParseArgsTestCase.test_long_option__partialfs6��
�_�_�g�Y�
'��������!�������Q�'rc���|jddg�}|j|j�|j|jd�|j|j
�y)NrVr|r)rr9rWr3rGr}r;s  r�test_two_optionsz"ParseArgsTestCase.test_two_optionsksI��
�_�_�i��5�
6��������!�������Q�'�����
�
�#rc�b�|jddg�}|j|jd�y)Nr>r/)rr3r?r;s  r�#test_option_with_empty_string_valuez5ParseArgsTestCase.test_option_with_empty_string_valueqs(��
�_�_�i��_�
-��������2�&rc�b�|jdg�}|j|jdg�y)Nr2)rr3rr;s  r�test_argzParseArgsTestCase.test_argus(��
�_�_�e�W�
%��������5�'�*rc���|jddg�}|j|j�|j|jd�|j|j
dg�y)NrVr2r)rr9rWr3rGrr;s  r�test_option_and_argz%ParseArgsTestCase.test_option_and_argysO��
�_�_�i��/�
0��������!�������Q�'�������5�'�*rc��|jgd��}|j|jd�|j|jddg�y)N)�test_unaryoprD�
test_binoprEr�r�)rr3rGrr;s  r�test_arg_option_argz%ParseArgsTestCase.test_arg_option_args>��
�_�_�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�|j
jd�|j
|j|�|j|j�|j|jt�|j|j�|j|j�|j|j �|j|j"�|j
t%|j&�t%|��|S#1swY��xYw)Nrd���)rrrrfrrgr3�num_workers�
want_rerunr9rerirjrl�fail_env_changed�
fail_rerun�
print_slowest�output_on_failure�sortedr�)r!rr�rKr5rmrns       r�
check_ci_modezParseArgsTestCase.check_ci_mode�s��
�
 �
 ��
&���
*�
*�
,�	)��"�c�)��+�,��}�}�R�(�H�	)�	
����-�-�r�2�����,�,�e�4�����*�*�+����h�2�2�C�8�����1�1�2�����+�+�,�����.�.�/�����2�2�3������ 6� 6�7��
�9N�O���!	)�	)�s�E�E(c��dg}ttj�}|jd�|j	||�}|j|jd�y)N�	--fast-ci�cpu�X)r�rr�r�rr3r4�r!rr�rns    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)rKr)�python�-X�dev)r�rr�r�rr3r4�
python_cmdrs    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�)r�rr�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�)r�rr�rr3r4rs    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)rrrh�_add_python_opts)r!rr5s   r�test_dont_add_python_optsz+ParseArgsTestCase.test_dont_add_python_opts�s.��(�)��
�
 �
 ��
&������,�,�-rN)T)2�__name__�
__module__�__qualname__�__doc__�staticmethodrr$r+r6r<rArHrLrRrXr\r_rorsrzr~r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�rrr
rrr�rrrr9s����)��)�+�
N�H�!�@�
(�*�-�0�/�#�=�,D�I�,�I�"[�HN�G�2@�@�
-�L�"G�*�@�/�C�P�,�-�(�
$�'�+�+�B�
D��.4�G�0�4�.rrT)�slotsc�2�eZdZUeed<edzed<eed<y)�Rerun�nameNr��success)rrrrk�__annotations__�boolrrrrr�s��

�I���:��
�Mrrc�|�eZdZdZdZdZd�Zdd�Zd�Zdd	�Z	d
�Z
dddddddddddddd�
d
�Zdedefd�Z
dd�Zd�Zy)�BaseTestCaserE�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%srEz�
                    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_testzBaseTestCase.create_test�s�����l�9�9�9�D��'�'�1�,�'��<��?�?�$��D��#�#�d�*���w�w�|�|�D�O�O�T�E�\�:�����	�(�(�$�/�	��d�C�'�2�
�b������
���

����	�	��,�,�.��
�
�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_search�s1���	�	�%�����6����I�I�e�V�<�=��rFc��|stj|�}|r|dz
}tjd|ztj�}|j	||�y)N�
�^)r?�escape�compilerA�assertRegex)r!rDr��fullrCs     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)NrHz\[ *[0-9]+(?:/ *[0-9]+)*\] (�)c3�>K�|]}|jd����y�w)rEN)�group)�.0r�s  r�	<genexpr>z4BaseTestCase.parse_executed_tests.<locals>.<genexpr>s����7�u�E�K�K��N�7�s�)�
LOG_PREFIX�TESTNAME_REGEXr?�finditerrAr�)r!rDrC�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�omittedrK�run_no_tests�resource_deniedre�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)NrE�sr/r)�counts r�pluralz1BaseTestCase.check_executed_tests.<locals>.plural0s���1�*�3�,�"�,rc�|��t|�}djt|��}||�|�fz}|�d|�d�}|S)N� z:\n    �$)�lenr�r�)�line_format�testsre�namesrCrfs     �r�
list_regexz5BaseTestCase.check_executed_tests.<locals>.list_regex3s@�����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\.rEzAll %s)rLz(Test suite interrupted by signal SIGINT.zrun=�,z
 \(filtered\)z	failures=zskipped=z
Total tests: rhr�/rZr[rYr^rKr]�=zTotal test files: �FAILUREzENV CHANGED�INTERRUPTEDzNO TESTS RAN�SUCCESS�, z then zResult: )�
isinstancerkrlrrr �appendrXr�r3�setrMrTr�rj�	tests_run�failuresrYr��any)#r!rDrl�statsrYrZr[r\rKr]r^rer_r`r�r�ra�rerun_failed�executed�total_testsrnrC�good�text�parts�line�run�total_failed�total_rerun�reportr�ntest�state�	new_staterfs#                                  @r�check_executed_testsz!BaseTestCase.check_executed_testsst����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��.�/�

�		1�K�D�%���
�
���a��w�/�0�		1�%�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���>rrD�returnc�H�|jd|�}|jd�S)NzUsing random seed: (.*)rE)rErQ)r!rDr�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)
Nr/r�rmrdT)r��input�stdoutrmzCommand z failed with exit code z, but exit code z expected!

stdout:
---
z
---
z
stderr:
---
%s---
)
�
subprocess�STDOUT�pop�dictr��environr��PIPE�
returncoderkr�r�rB)r!rr��exitcode�kwrm�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)rrrr2r5rUr.r=rErMrXr�rkr�r�r�rrrr$r$�sr���N�&�O�*�N�;��<�(�8�&(��)+�R�#'�b�-/�',�u�%�.3�%*�U�]?�~�����!�Frr$c��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�	�
z+Unexpectedly low number of tests found in:
ru)r"N)r�rj�
splitlinesr�r�r��globrIr(r)�
assertGreater)r!rrD�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)rrrr�rrrr�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�NTESTr=rl�python_argsr,�
regrtest_argsr�r��platformrw)r!�index�	__class__s  �rr.zProgramsTestCase.setUp�s����
��
��7<�D�J�J�6G�H�U�d�&�&�(�H��
�/���%�v�,�t���>�@������!�!�">�?��<�<�7�"����%�%�d�+�#��
Is�B1c���|j|�}|j|j�|�|j||jdt|j���y)NT)rer|)r�r9�isdigitr�rlrj)r!rD�randseeds   r�check_outputzProgramsTestCase.check_outputsR���)�)�&�1������(�(�*�H�5��!�!�&�$�*�*�,0��D�J�J��	"�	Irc�L�|j||��}|j|�y)N)rm)r�r�)r!rrmrDs    r�	run_testszProgramsTestCase.run_tests
s"������3��/�����&�!rc���tjj|jd�}g|j�|�|j
�|j�}|j|�y)Nzregrtest.py�r�r�r�r�r�r�rlr��r!�scriptrs   r�test_script_regrtestz%ProgramsTestCase.test_script_regrtestsO�������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�rlr��r!rs  r�test_module_testz!ProgramsTestCase.test_module_testsJ��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_autotest!r�rc�~�d}g|j�d�|�|j�|j�}|j|�y)Nzfrom test import autotestz-cr�)r!r;rs   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_autotest.sO�������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_batch4s$������%�����$�+�+�&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��machinerw�architecturer�Py_DEBUGr�rl)r!r��	test_argss   r�test_tools_buildbot_testz)ProgramsTestCase.test_tools_buildbot_test8s���
�����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 existrUr�r�r�r�rr�r�z-d)r�r�r�r��isfiler:r�r�rwr�rr�r�r�rl)r!r��rt_argss   r�test_pcbuild_rtz ProgramsTestCase.test_pcbuild_rtIs��������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)rrrrr�r.r�r�r�r�r�r�r�r�r��unittest�
skipUnlessr8r9r�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��Zd�Zd�Zej:d��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,d)�Z-d*�Z.d+�Z/d,�Z0ej:d-��Z1d.�Z2d/�Z3d0�Z4d1�Z5d2�Z6d3�Z7ejpejrd4�d5��Z:d6�Z;d7�Z<defd8�Z=d9�Z>d:�Z?d;�Z@d<�ZAd=�ZBd>�ZCejpej�d?�d@��ZEdA�ZFyB)C�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_tests`s2�����$�/�/�!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
        rEr��ok�r;r�r|)r3r4r�r=r�r�rj)r!r;�irlrDs     r�test_successzArgsTestCase.test_successds������ �
��AF�a���L�1��!�!�B�q�c�(��!�6�L��L������'���!�!�&�%�()�C��J��	"�	8��Ms�A3c���tjd�}|jd�}|jd|��}||g}|j|�}|j	|||gd��y)NzQ
            import unittest
            raise unittest.SkipTest("nope")
        r��skipr�rE)rYr|�r3r4r=r�r�)r!r;�test_ok�	test_skiprlrDs      rrzArgsTestCase.test_skipxsu����� �
���"�"�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��failingr�r�r
rE�rZr|�r3r4r=r��EXITCODE_BAD_TESTr�r)r!r;r�test_failingrlrDs      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��allr
r�z-uaudior�rE)r^r|r�r)r3r4r=r��valuesr�r��EXITCODE_NO_TESTS_RAN)r!rl�resourcer;�
test_namesrDs      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))
        �randomra�r�zTESTRANDOM: ([0-9]+)rE�--randseed=rc)rd�r�rmzTESTRANDOM: 520�XYZzTESTRANDOM: 22r/)r3r4r=r�rr�rErlrQr3r9r�r�r�r�rM)r!r;r�rDr�r��test_random�	randseed2�test_random2�	timestamprms           rrzArgsTestCase.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�rEz00:00:%02i [%s/%s] %sz -- %s took 0 secr�rvr��[rpz] zLib/test/%s.py)r�r=rr�r�r�r��	enumeraterjr�r�r�)
r!r�rlr�r��previousrr�rDr|s
          rrzzArgsTestCase.test_fromfile�sB��16�q��:���!�!�#�:��:�
�#�#�����	�(�(�(�3��(�C�
 �	 �B��H�(���2�
 ���t�/� �%��U��T�:�;����/�(�:�:�D��d��$���

 �	 �����h�7���E�
���!�!�&�%�u�!�=��(�C�
 �	I�B�(���2�
I���t��e�S��Z��>�R�H�
I�	I�����h�7���!�!�&�%�u�!�=��(�C�
 �	%�B��
%���d��$�
%�	%�����h�7���!�!�&�%�u�!�=��(�C�
 �	8�B��
8���&��-�B�7�
8�	8�����h�7���!�!�&�%�u�!�=��[;�	 �	 ��	I�	I��	%�	%��	8�	8�s6�G2�#AG7�+4H�H�*H�7H�H
�H�H%c��t}|jd|��}|j|t��}|j	|||dd��y)N�sigintr�rTr�r\r`r|)�TEST_INTERRUPTEDr=r��EXITCODE_INTERRUPTEDr��r!r;r�rDs    r�test_interruptedzArgsTestCase.test_interruptedsM��������t��4������/C��D���!�!�&�$��.2�!�	"�	=rc��td�D�cgc]}|j���}}|jdg|���}|j||t	|���d|j
�dt	|��d�}|j
||�ycc}w)NrrZr�z10 slowest tests:
(?:- z: .*
){�})r�r=r�r�rjrUrM)r!r�rlrDrCs     rr\zArgsTestCase.test_slowest#s}��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)Nr%r�r�)�multiprocessingrZ�-j2r�Trr&z10 slowest tests:
)r'r=r(r�r(r�rM)r!r;r�r.rrDrCs       r�test_slowest_interruptedz%ArgsTestCase.test_slowest_interrupted-s���������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�rEr�zLlines +cov% +module +\(path\)\n(?: *[0-9]+ *[0-9]{1,2}% *[^ ]+ +\([^)]+\)+)+)r=r�r�rM)r!r�rDrCs    rr�zArgsTestCase.test_coverage@sO�����
�+������d�3���!�!�&�4�&��!�:�B�������&rc�r�|jd�}|jd|d��}|j|d�y)Nr:r8�key)r�zPress any key to continue)r=r�rM)r!r�rDs   rr<zArgsTestCase.test_waitIs5������'������$�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�r�r�rrrET)rZr|r�rJr�test_run�r�r r)rKr|r�)r3r4r=r�rr�rrr)s    rr�zArgsTestCase.test_foreverOs������ �
�����	���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|tj|��|�d|�d�}	|j|	|�t|�5}
|
j�}|j|	|�ddd�y#1swYyxYw)
Nr�r�r�r�z3:3:�-j1)r�r�rEr	z&beginning 6 repetitions
123456
......
z leaked [1, 1, 1] z, sum=3
)r=r�rr�rwr�rr�r�r�rMr?rIrr��read)r!r;�whatr9r�r��cmdrDr��line2r��reflogs            r�
check_leakzArgsTestCase.check_leakqs�������4��8�������	�(�(�(�3��v�&����J�J�u���
�
�4�������):�'1�'8�'8�:��	
�!�!�&�4�&��Q�!�G�:�������	�	�$��0�59�4�@���
�
�e�V�$�
�(�^�	)�r��W�W�Y�F��M�M�%��(�	)�	)�	)�s�%#D�Dzneed a debug buildr9c�V�tjd�}|j|d|��y)Nz�
            import unittest

            GLOBAL_LIST = []

            class RefLeakTest(unittest.TestCase):
                def test_leak(self):
                    GLOBAL_LIST.append(object())
        �
referencesr8�r3r4rA)r!r9r;s   r�check_huntrleakszArgsTestCase.check_huntrleaks�s+����� �
��	
����l���Drc�(�|jd��y�NFr8�rEr�s rr�zArgsTestCase.test_huntrleaks�s�����%��0rc�(�|jd��y�NTr8rHr�s r�test_huntrleaks_mpzArgsTestCase.test_huntrleaks_mp�s�����$��/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 descriptorsrD)r!r;s  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�r=r�r3�rstripr�)r!rrlrDs    r�test_list_testszArgsTestCase.test_list_tests�s^��-2�1�X�6���!�!�#�6��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
        r�z%s.Tests.test_method1z%s.Tests.test_method2z--list-casesr��test_method1)r3r4r=r�r3r�)r!r;�testname�all_methodsrDs     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�rr;r/r�Tr�rZr_r|)r=r�rr�)r!r;�
crash_testrlrDs     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$��flagsrE)r?rJrArVrQ)r!rDrCr�s    r�
parse_methodszArgsTestCase.parse_methods�s<���
�
�.�b�l�l�C��,1�N�N�6�,B�C�5����A��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
        r�rR�%s.Tests.test_method3r�r�rDr��test_method2�test_method4)r3r4r=rr�r�r�r�r�r�r_r3)	r!r;rSr��subsetr�rrD�methodss	         r�test_ignorefilezArgsTestCase.test_ignorefile�s������ �
���#�#��#�.���#�#�����	�(�(�(�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)Nra)rRrc�test_method3rdr�rDrRrbr�r�r�ri)r3r4r=r�r_r3rr�r�r�r�r�)
r!r;rTrSrDrfr�rer�rs
          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()
        r�rE)r[r|�--fail-env-changedrT�r[r�r|rJr7r
)r[rKr|)r3r4r=r�r��EXITCODE_ENV_CHANGEDr�r!r;rSrDs    r�test_env_changedzArgsTestCase.test_env_changed&s������ �
���#�#��#�.������)���!�!�&�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")
        r�rJr�test_fail_alwaysF)r rr
�rKr|)r3r4r=r�rr�rrros    r�test_rerun_failzArgsTestCase.test_rerun_failDss�����
 �

���#�#��#�.�����	�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")
        r�rJrr�test_fail_onceTr7rrErsz--fail-rerun)r�r�r�r�rr�rh�existsr3r4r=r�r�rr�EXITCODE_RERUN_FAIL)r!�marker_filenamer;rSrDs     r�test_rerun_successzArgsTestCase.test_rerun_successZs:���'�'�/�/�*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
        r�rJr�ExampleTestsFr7r�rZrKr|�r3r4r=r�rr�rros    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
        r�rJrr}Fr7r
r~rros    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
        r�rJrFr7rr~rros    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
        r�rJrFr7r
r~rros    r�'test_rerun_teardown_module_hook_failurez4ArgsTestCase.test_rerun_teardown_module_hook_failure�sr�����	 �	
���#�#��#�.�����	�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
        r�rJrrFr7r
r~rros    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
        r�rJrrFr7r
r~rros    r� test_rerun_teardown_hook_failurez-ArgsTestCase.test_rerun_teardown_hook_failure�r�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
        r�rJrrFr7r
rsrros    r�#test_rerun_async_setup_hook_failurez0ArgsTestCase.test_rerun_async_setup_hook_failuresk�����	 �	
���#�#��#�.�����	�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
        r�rJrrFr7r
r~rros    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
        r�r��
nosuchtestrrT�r]r|ra�r3r4r=r�rr�ros    r�test_no_tests_ranzArgsTestCase.test_no_tests_ran6sh����� �
���#�#��#�.������$��)>� �@���!�!�&�8�*�/7�()�D�	"�	:rc��tjd�}|j|��}|j|�}|j	||gtdd����y)Nz�
            import unittest

            class Tests(unittest.TestCase):
                def test_skipped(self):
                    self.skipTest("because")
        r�rE)rYr�)r3r4r=r�r�rros    r�test_no_tests_ran_skipz#ArgsTestCase.test_no_tests_ran_skipFs\����� �
���#�#��#�.������)���!�!�&�8�*�(1�!�Q�(?�	"�	Arc���tjd�}|j|��}|j|��}|j||ddt��}|j|||g||gdd��yr�r�)r!r;rS�	testname2rDs     r�,test_no_tests_ran_multiple_tests_nonexistentz9ArgsTestCase.test_no_tests_ran_multiple_tests_nonexistentTs������ �
���#�#��#�.���$�$�$�$�/�	�����)�T�<�)>� �@���!�!�&�8�Y�*?�08�)�/D�()�D�	"�	:rc	��tjd�}|j|��}tjd�}|j|��}|j||ddddd��}|j	|||g|gd	d
��y)Nr�r�z�
            import unittest

            class Tests(unittest.TestCase):
                def test_other_bug(self):
                    pass
        r�r��test_other_bugrrrETr�r)r!r;rS�
other_coder�rDs      r�)test_no_test_ran_some_test_exist_some_notz6ArgsTestCase.test_no_test_ran_some_test_exist_some_notes������ �
���#�#��#�.���_�_�&�
�
��$�$�*�$�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
        r�rlrTrErm)r3r4r=r�rnr�ros    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)
        r�r/z
--timeout=1.0rrr	z%s timed out)
r3r4r=r�rr�rKr?rJrAros    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(), '')
        r�rlrDrTrErmzWarning -- Unraisable exceptionzException: weakref callback bug�r3r4r=r�rnr�rros    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(), '')
        r�rlrDrTrErmz$Warning -- Uncaught thread exceptionzException: bug in threadr�ros    r�test_threading_excepthookz&ArgsTestCase.test_threading_excepthook�s������ �
��&�#�#��#�.����� 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
        r�zFtest_print_warning.*msg1: stdout\nWarning -- msg2: print_warning\nok\n)rDrO)�optionrlr�TrErm)r3r4r=r(r�rnr�rK)r!r;rSrCr�r>rDs       r�test_print_warningzArgsTestCase.test_print_warning�s������ �
��$�#�#��#�.����#�	0�F����V��,�
0�+�V�X�>��'�����L�7K�L���)�)�&�8�*�7?�j�;?�01�*�3�� � ���/�
0�
0�	0�
0�
0�s
�AB�B	c���tjjtj�}|j|tj�d��|j
�r|jd�yy)Nz not setzModified guard)r�r��getr�UNICODE_GUARD_ENV�assertIsNotNone�isasciir:)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�rhrx)r!r(r�rmr�rs      r�test_cleanupzArgsTestCase.test_cleanup*s����'�'�,�,�t���0A�B��
������7�7�<�<����1B�C���X�t��"�"�$��(�#����!�D�O�O�3�� ��	
���� ��	9�D����R�W�W�^�^�D�1�4�8�	9rz.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')
        rr�rlrDr/r�T)r[r�r_r|zWarning -- z& leaked temporary files (1): mytmpfile)	r3r4r�r=r�rnr�rjr)r!r;�_�	testnamesrDrSs      r�test_leak_tmp_filezArgsTestCase.test_leak_tmp_file9s������
 �

��;@��(�C�Q�T�%�%�4�%�0�C�	�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)rR�chs  rrSz8ArgsTestCase.test_worker_decode_error.<locals>.<genexpr>`s����6���6�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()
        r�rlrDr;TrE)r_r|F)rC)r�r��locale�getencodingr�r1�
__stdout__r:�bytesr��encode�decode�UnicodeDecodeErrorr3r4r=r�r�rM)	r!r1�nonascii�corrupted_output�assertion_failed�
expected_liner;rSrDs	         r�test_worker_decode_errorz%ArgsTestCase.test_worker_decode_errorUsi���<�<�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
        r�rlrDr;rTrErrYr
ros    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}")
        rErrrXiJ�3rbrr�r�rr�zRandom numbers: z^Random numbers: .*$r])r3r4r�r=rwrjr�r�r�seed�randintr?�findallrAr3)
r!r9r;rrlrjr>rDr��numbersr�rC�matchess
             r�_check_random_seedzArgsTestCase._check_random_seed�s����� �
�� ��3�-�)���!�!��Q�C�'8�t�!�D�)��)�"����K�=�9�:����J�J��C��J�<�(�)��
�
�5�������%�����K� �5:�"�I�>�q�6�>�>�!�T�*�>��>�%�g�Y�/��'���*�*�U�F�"�,�,�?������8�*�s�5�z�"9�:��))��?s�D�-Dc�(�|jd��yrG�r�r�s r�test_random_seedzArgsTestCase.test_random_seed�s�����E��2rc�(�|jd��yrJr�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)
        rr�r
rrz-j0T�r|r_)r3r4r�r=r�r��shlexr�r�r�rj)r!r;r�rlrrDs      r�test_python_commandz ArgsTestCase.test_python_command�s������ �
��7<�A�h�?���!�!�t�!�,�?��?��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�cr%r�r�r�r�r�r�rr�)r�r�r�r(r)r�r�)r!r�rrlrrDs      r�test_unload_testszArgsTestCase.test_unload_tests�s����'�'�,�,�r�w�w���x�8�-�/B�D��5D�E�T�>�$��(�E��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)
        r�r�r�z
--testdir=T)r�r�r�r)r3r4r=r�r�r,r�r�r�r�r3r�)r!r�r;rSr>r�s      r�check_add_python_optsz"ArgsTestCase.check_add_python_opts�s������' �'
��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_opts2sG��-�	0�C����#��&�
0��*�*�3�/�
0�
0�	0�
0�
0�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)
        r�z
handle_segv=0r;rT)rZr|r_z
Exit code z
 (SIGSEGV)zjust before crash!F)rLrC)r�r��ImportErrorr:r3r4r=r�r�r�r�set_sanitizer_env_varr�rr��
MS_WINDOWSrl�signal�SIGSEGVrrM)r!r�r;rSrmr�rDr�s        r�test_worker_output_on_failurez*ArgsTestCase.test_worker_output_on_failure8s���	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")
        r�rPrEr�zSPAM SPAM SPAMr�z3:3r;Tr�)r3r4r=r�r��assertNotInrr�ros    rrRzArgsTestCase.test_verbose3^s������ �
���#�#��#�.������h�7���!�!�&�(�!�!�<����)�6�2�����^�^�D�%���h�O�F��%�%�f�h�a�$�%�O����-�v�6�	rN)Grrrrr�rrr
rrrzr*r\r0r�r<r�rAr�r�rr�r"rEr�rKrMrPrU�cpython_onlyr[r_rgrjrprtr{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_androidr�rRrrrr�r�[s���.�8�(+�9�"+�>36�j/>�b=�'�/�&'�=� 0�D5:�)�0�X����)�)�+?�@�E�t�E�A�E�1�0��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�H7rr�c�*�eZdZd�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 secrEz1.0 sec�xz2 min�yz2 min 1 seci0*z3 houri�*z3 hour 2 mini1*z3 hour 1 sec)r3r�format_durationr�s r�test_format_durationzTestUtils.test_format_durationws/������.�.�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))rr3r�)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)rlr�r
r�r3r�get_signal_name)r!r�r�s   r�test_get_signal_namezTestUtils.test_get_signal_name�sg���&�-�-� �
 �(�+��&�.�.�!�
!�9�-�3�1�	#
�	R��H�h�
���U�2�2�8�<�h��Q�
	Rrc�^�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)rRrs  rrSz2TestUtils.test_format_resources.<locals>.<genexpr>�s����#5�D�&*�e�m�$(�#5�s�zresources: all,-cpur�zresources: all,tzdata)r�format_resourcesr�r3�tuple)r!rr�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�
�Gd�d�}|d�}|d�}|d�}tjtdd�5tg�|jt	|��|jt	|��td�|jt	|��|jt	|��t|j�dfg�|jt	|��|j
t	|��td	g�|jt	|��|jt	|��|j
t	|��td
g�|jt	|��|jt	|��tdg�|j
t	|��tdg�|jt	|��td
g�|jt	|��|jt	|��|j
t	|��t|j�df|j�dfg�|jt	|��|jt	|��|j
t	|��tddg�|jt	|��|j
t	|��ddd�tjtdd�5t|j�dfg�|j
t	|��|jt	|��tdg�|j
t	|��|j
t	|��|jt	|��tdg�|j
t	|��|j
t	|��tdg�|jt	|��tdg�|j
t	|��tdg�|j
t	|��|j
t	|��|jt	|��t|j�df|j�dfg�|j
t	|��|j
t	|��|jt	|��tddg�|j
t	|��|jt	|��ddd�tjtdd�5tddg�|jt	|��|j
t	|��|jt	|��tddg�|j
t	|��|jt	|��|j
t	|��ddd�y#1swY��UxYw#1swY��xYw#1swYyxYw)Nc��eZdZd�Zd�Zy)�'TestUtils.test_match_test.<locals>.Testc��||_yr��test_id)r!rs  r�__init__z0TestUtils.test_match_test.<locals>.Test.__init__�s	��&��rc��|jSrrr�s r�idz*TestUtils.test_match_test.<locals>.Test.id�s���|�|�#rN)rrrrrrrr�Testr�s��
'�
$rrz"test.test_os.FileTests.test_accessz'test.test_os.Win32ErrorTests.test_chdirz#test.test_shutil.TestCopy.test_copy�_test_matchersrT)�test_osT)�test_*T)�	filetestsT)�	FileTestsT)�*test_os.*.test_*T)rT)�	DONTMATCHTF)r F)r!F)r"F)r#F)r$F)rF)r%F)�*test_osF)r&T)r�	swap_attrr	r9r
rrh)r!rr�
test_chdir�	test_copys     r�test_match_testzTestUtils.test_match_test�s��	$�	$��?�@���C�D�
��>�?�	��
�
�w�(8�"�
=�/	5��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�_/	5�d�
�
�w�(8�"�
=�%	4��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%	4�P�
�
�w�(8�"�
=�		4��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�		4�		4�u/	5�/	5��d%	4�%	4��P		4�		4�s&�KY�,I
Y)�B7Y5�Y&�)Y2�5Y>N)rrrrrrrr*rrrr�r�vs��)�,	Y�R�%�(p4rr��__main__)>rr��dataclassesr�r�r��os.pathr�r�rr?r�r�r�r�r8r*r3r�r�r�test.supportr�test.libregrtestrrrr�test.libregrtest.filterr	r
�test.libregrtest.resultr�test.libregrtest.utilsr�has_subprocess_support�SkipTestr�r�r(r)r�r��normpathrTrrnrryr(r4r'�TestCaser�	dataclassrr$r�r�r�r�rrrr�<module>r8s�������	�
���
�	��
��
������"�$�!�"�"�?�-�6��%�%�
�(�
�
�=�
>�>�
�7�7�<�<�������1�4��>��
�7�7�?�?�2�7�7�+�+�H�5�6��
E�
�����������"�8�?�?�$�	��F.��)�)�F.�R����T�"���#��J�8�$�$�J�Z@�|�@�0jK�|�jK�ZX7�<�X7�v(o4��!�!�o4�d�z���H�M�M�O�r