Uname:Linux ip-10-0-5-176 6.8.0-1057-aws #60~22.04.1-Ubuntu SMP Wed May 27 08:16:59 UTC 2026 x86_64

403WebShell
403Webshell
Server IP : 3.111.61.48  /  Your IP : 216.73.216.67
Web Server : Apache
System : Linux ip-10-0-5-176 6.8.0-1057-aws #60~22.04.1-Ubuntu SMP Wed May 27 08:16:59 UTC 2026 x86_64
User : ubuntu ( 1000)
PHP Version : 8.2.31
Disable Function : exec,passthru,shell_exec,system
MySQL : OFF  |  cURL : ON  |  WGET : ON  |  Perl : ON  |  Python : OFF  |  Sudo : ON  |  Pkexec : ON
Directory :  /usr/lib/python3.10/test/__pycache__/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Command :

[ Back ]     

Current File : /usr/lib/python3.10/test/__pycache__/test_pprint.cpython-310.pyc
o

�9j9��@sddlZddlZddlZddlZddlZddlZddlZddlZddl	Z	ddl
Z
Gdd�de�ZGdd�de�Z
Gdd�de�ZGdd	�d	e�ZGd
d�de�ZGdd
�d
e�ZGdd�de�ZGdd�de�ZGdd�de�ZGdd�de�ZGdd�de�ZGdd�de�ZGdd�de�ZGdd�de�ZGdd�de�ZejGd d!�d!��Z ejGd"d#�d#��Z!ejd$d%�Gd&d'�d'��Z"ejGd(d)�d)��Z#ejGd*d+�d+��Z$ejGd,d-�d-��Z%Gd.d/�d/�Z&Gd0d1�d1�Z'Gd2d3�d3e
j(�Z)Gd4d5�d5ej*�Z+e,d6k�r
e
�-�dSdS)7�Nc@�eZdZdS)�list2N��__name__�
__module__�__qualname__�rr�'/usr/lib/python3.10/test/test_pprint.pyr�rc@�eZdZdd�ZdS)�list3cC�
t�|�S�N)�list�__repr__��selfrrr	r�
zlist3.__repr__N�rrrrrrrr	r�rc@r)�list_custom_reprcC�dtt�|��S�N�*)�lenrrrrrr	r�zlist_custom_repr.__repr__Nrrrrr	rrrc@r)�tuple2Nrrrrr	rr
rc@r)�tuple3cCr
r)�tuplerrrrr	rrztuple3.__repr__Nrrrrr	rrrc@r)�tuple_custom_reprcCrr)rrrrrrr	r"rztuple_custom_repr.__repr__Nrrrrr	r!rrc@r)�set2Nrrrrr	r %r
r c@r)�set3cCr
r)�setrrrrr	r)rz
set3.__repr__Nrrrrr	r!(rr!c@r)�set_custom_reprcCrr)rr"rrrrr	r-rzset_custom_repr.__repr__Nrrrrr	r#,rr#c@r)�
frozenset2Nrrrrr	r$0r
r$c@r)�
frozenset3cCr
r)�	frozensetrrrrr	r4rzfrozenset3.__repr__Nrrrrr	r%3rr%c@r)�frozenset_custom_reprcCrr)rr&rrrrr	r8rzfrozenset_custom_repr.__repr__Nrrrrr	r'7rr'c@r)�dict2Nrrrrr	r(;r
r(c@r)�dict3cCr
r)�dictrrrrr	r?rzdict3.__repr__Nrrrrr	r)>rr)c@r)�dict_custom_reprcCrr)rr*rrrrr	rCrzdict_custom_repr.__repr__Nrrrrr	r+Brr+c@s@eZdZUeed<eed<dZeed<ej	ddd�Z
eed<dS)	�
dataclass1�field1�field2F�field3�)�default�repr�field4N)rrr�str�__annotations__�intr/�bool�dataclasses�fieldr3rrrr	r,Fs

r,c@s"eZdZUdZeed<dd�ZdS)�
dataclass2r0�acC�dS)N�0custom repr that doesn't fit within pprint widthrrrrr	rP�zdataclass2.__repr__N)rrrr;r6r5rrrrr	r:Ms
r:F)r2c@seZdZUdZeed<dS)�
dataclass3r0r;N)rrrr;r6r5rrrr	r?Ss
r?c@s"eZdZUded<dZeed<dS)�
dataclass4r;r0�bN�rrrr5rAr6rrrr	r@W�
r@c@�"eZdZUded<dZeed<dS)�
dataclass5�
dataclass6r;r0rANrBrrrr	rE\rCrEc@rD)rFrE�cr0�dN)rrrr5rHr6rrrr	rFarCrFc@r)�UnorderablecCstt|��Sr)r4�idrrrr	rgszUnorderable.__repr__Nrrrrr	rIfrrIc@sLeZdZdd�Zdd�Zdd�Zdd�Zd	d
�Zdd�Zd
d�Z	dd�Z
dS)�	OrderablecCs
||_dSr��_hash)r�hashrrr	�__init__lrzOrderable.__init__cCr<)NFr�r�otherrrr	�__lt__nr>zOrderable.__lt__cCs||kSrrrPrrr	�__gt__p�zOrderable.__gt__cCs||kSrrrPrrr	�__le__rrTzOrderable.__le__cCr<)NTrrPrrr	�__ge__tr>zOrderable.__ge__cCs||uSrrrPrrr	�__eq__vrTzOrderable.__eq__cCs||uSrrrPrrr	�__ne__xrTzOrderable.__ne__cCs|jSrrLrrrr	�__hash__zszOrderable.__hash__N)rrrrOrRrSrUrVrWrXrYrrrr	rKksrKc@szeZdZdd�Zdd�Zdd�Zdd�Zd	d
�Zdd�Zd
d�Z	dd�Z
dd�Zdd�Zdd�Z
dd�Zdd�Zdd�Zdd�Zdd �Zd!d"�Zd#d$�Zd%d&�Zd'd(�Zd)d*�Zd+d,�Zd-d.�Zd/d0�Zd1d2�Zd3d4�Zd5d6�Zd7d8�Zej e!j"j#d9d:���Z$d;d<�Z%d=d>�Z&d?d@�Z'dAdB�Z(dCdD�Z)dEdF�Z*dGdH�Z+dIdJ�Z,dKdL�Z-dMdN�Z.dOdP�Z/dQdR�Z0dSdT�Z1dUdV�Z2dWdX�Z3dYS)Z�
QueryTestCasecCs,ttd��|_ttd��|_|j|jd<dS)N�d��i�)r�ranger;rArrrr	�setUpszQueryTestCase.setUpcCs�t��}tjdddt��dd�}t�dddt���}tjdd�}|�t��t�dddt��d�}Wd�n1s;wY|jttjdd	�|jttjd
d�|jttjdd�|jttjd
d�dS)
N��(�T)�indent�width�depth�stream�compactF��
sort_dicts����rbr�rd�rc)�pprint�
PrettyPrinter�io�StringIO�assertRaises�	TypeError�
ValueError)r�pprrr	�	test_init�s
��zQueryTestCase.test_initcCs�t��}dddddgdddidtd�d	d
dd|j|jfD]2}|�t�|�d|f�|�t�|�d
|f�|�|�|�d|f�|�|�|�d
|f�qdS)N�g@y@�abc�)rvrvsdefsghiTF.�expected not isrecursive for %r�expected isreadable for %r)	rmrn�	bytearrayr;rA�assertFalse�isrecursive�
assertTrue�
isreadable)rrt�saferrr	�
test_basic�s$������zQueryTestCase.test_basiccCsH|j|jd<i|_|j|jd<|jd<|jd<t��}|j|j|j|j|jffD]&}|�t�|�d�|�t�|�d�|�|�|�d�|�|�|�d�q*|j�	�|jdd�=|jdd�=|j|j|j|j|jffD]2}|�t�|�d|f�|�t�|�d|f�|�|�|�d|f�|�|�|�d|f�qodS)	N�Crr0rvzexpected isrecursivezexpected not isreadableryrz)
r;rArHrmrnr~r}r|r�clear)rrt�ickyr�rrr	�test_knotted�s4 
�����zQueryTestCase.test_knottedcCs�t��}td�ttjfD]2}|�t�|�d|f�|�t�|�d|f�|�|�|�d|f�|�|�|�d|f�qdS)Nrxryzexpected not isreadable for %r)rmrn�typer}r|r)rrt�
unreadablerrr	�test_unreadable�s�����zQueryTestCase.test_unreadablecCs�gd�d�d�d�d�d�t��d�t��t��g�t��t��t��t��t��t��t	��t
��i�t��t��|j
�t�d�d�d�d	�d
�d�td��d�d
g�d
di�d�d
dg�ddi�td��td��ttd���d
dg�td
dg��td
dg��ttd���tdh��tdh��tdh��tdh��t	dh��t
dh��tddi��tddi��tddd��d�d�d�d�RD]3}t|�}|�t�|�|�|�tj|ddd��dd�|�|�tj|dd�|�|�t�|�|�q�dS) Nryg��ri����y��g���x�x�rxrx�)r0rvr_rar[���
i����riTF.r0�rcrb�
� ��underscore_numbers)r{rrrrr"r r!r&r$r%r(r)r~rmr]r2�assertEqual�pformat�replace�saferepr)r�simple�nativerrr	�test_same_as_repr�s� 
���������������������������	�	�	�
�
�

��
�
�
����
�
�
�
�
�
����
�
��zQueryTestCase.test_same_as_reprcCs�d}t�tgd��tt|��t�tgd��tt|��t�tgd��tt|��t�tgd��tt|��t�tddi�ttt|�t|���fD]*}t|�}dt|�}|�	t
�|�|�|�	t
j|ddd�|�|�	t
�|�|�qEdS)	N��)r0rvrxrar�rr0rr�)
rr]rr#r'r+�zipr2rr�rmr�r�)r�N�contr��expectedrrr	�#test_container_repr_override_called�s.








��z1QueryTestCase.test_container_repr_override_calledcCsdddddddd�}d}ttfD]
}|�t�||��|�qtd�}dd�tt|��}t	t
fD]
}|�t�||��|�q0ttd��}d	d�tt|��}ttfD]
}|�t�||��|�qRtd�}d
d�tt|��}t	t
fD]}|�tj||�dd
�|�qrdS)Nri��i��)�RPM_cal�RPM_cal2�	Speed_cal�controldesk_runtime_us�main_code_runtime_us�read_io_runtime_us�write_io_runtime_usz�{'RPM_cal': 0,
 'RPM_cal2': 48059,
 'Speed_cal': 0,
 'controldesk_runtime_us': 0,
 'main_code_runtime_us': 0,
 'read_io_runtime_us': 0,
 'write_io_runtime_us': 43690}r[z[%s]z,
 z(%s)z[   %s]z,
    r_rj)
r*r(r�rmr�r]�join�mapr4rrrr)r�o�expr�rrr	�test_basic_line_wraps0��z"QueryTestCase.test_basic_line_wrapcCs^ttd��}tdddd�}||g}d}|�tj|ddd	�|�d
}|�tj|ddd	�|�dS)Nr�r0rvrx)�first�second�thirdzN[   [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
    {'first': 1, 'second': 2, 'third': 3}]r_�*)rbrcza[   [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
    {   'first': 1,
        'second': 2,
        'third': 3}]�))rr]r*r�rmr�)r�o1�o2r�r�rrr	�test_nested_indentations3sz&QueryTestCase.test_nested_indentationscCshd}t|�}|�tj|dd�|�|�tj|dd�|�|�tj|dd�|�|�tj|dd�d�dS)Nz�[[[[[[1, 2, 3],
     '1 2']]]],
 {1: [1, 2, 3],
  2: [12, 34]},
 'abc def ghi',
 ('ab cd ef',),
 set2({1, 23}),
 [[[[[1, 2, 3],
     '1 2']]]]]�rl���z�[[[[[[1,
      2,
      3],
     '1 '
     '2']]]],
 {1: [1,
      2,
      3],
  2: [12,
      34]},
 'abc def '
 'ghi',
 ('ab cd '
  'ef',),
 set2({1,
       23}),
 [[[[[1,
      2,
      3],
     '1 '
     '2']]]]])�evalr�rmr�)rr�r�rrr	�
test_widthBs
zQueryTestCase.test_widthcsV|�t�d�d�|�tjddd�d�G�fdd�dt��|�t��d��d	�dS)
Ni���1234567Tr��	1_234_567cs&eZdZ��fdd�Zdd�Z�ZS)z/QueryTestCase.test_integer.<locals>.Temperaturecst���|�Sr)�super�__new__)�cls�celsius_degrees)�Temperature�	__class__rr	r�msz7QueryTestCase.test_integer.<locals>.Temperature.__new__cSs|d}|�d�S)Ngfffffq@u°Kr)r�kelvin_degreesrrr	ros
z8QueryTestCase.test_integer.<locals>.Temperature.__repr__)rrrr�r�
__classcell__r�r�)r�r	r�lsr�r�u
1273.15°K)r�rmr�r6rrr�r	�test_integerhszQueryTestCase.test_integercCsTdddd�}|�t�|�d�|�t�||g�d�|�t�dggid��d�dS)Nr0�r;rArGz{'a': 1, 'b': 1, 'c': 1}z4[{'a': 1, 'b': 1, 'c': 1}, {'a': 1, 'b': 1, 'c': 1}]r�)zxy	ab
rarz#{5: [[]], 'xy\tab\n': (3,), (): {}})r�rmr��rrHrrr	�test_sorted_dictts��zQueryTestCase.test_sorted_dictcCs>t�d�}|�tj|dd�d�|�tj||gdd�d�dS)N�cbaFrgz!{'c': None, 'b': None, 'a': None}zF[{'c': None, 'b': None, 'a': None}, {'c': None, 'b': None, 'a': None}])r*�fromkeysr�rmr�r�rrr	�test_sort_dict�s

�zQueryTestCase.test_sort_dictcCspt��}|�tj|dd�d�t�g�}|�tj|dd�d�d��}t�t|t����}|�t�|�d�dS)Nr0rlz
OrderedDict()�*the quick brown fox jumped over a lazy dogz�OrderedDict([('the', 0),
             ('quick', 1),
             ('brown', 2),
             ('fox', 3),
             ('jumped', 4),
             ('over', 5),
             ('a', 6),
             ('lazy', 7),
             ('dog', 8)]))	�collections�OrderedDictr�rmr��splitr��	itertools�count�rrH�wordsrrr	�test_ordered_dict�s
�zQueryTestCase.test_ordered_dictcCsjd��}tt|t����}t�|�}|�t�	|�d�t
�t|t����}t�|�}|�t�	|�d�dS)Nr�z�mappingproxy({'a': 6,
              'brown': 2,
              'dog': 8,
              'fox': 3,
              'jumped': 4,
              'lazy': 7,
              'over': 5,
              'quick': 1,
              'the': 0})a^mappingproxy(OrderedDict([('the', 0),
                          ('quick', 1),
                          ('brown', 2),
                          ('fox', 3),
                          ('jumped', 4),
                          ('over', 5),
                          ('a', 6),
                          ('lazy', 7),
                          ('dog', 8)])))r�r*r�r�r��types�MappingProxyTyper�rmr�r�r�)rr�rH�mrrr	�test_mapping_proxy�s


z QueryTestCase.test_mapping_proxycCs"t��}t�|�}|�|d�dS)Nznamespace()�r��SimpleNamespacermr�r��r�ns�	formattedrrr	�test_empty_simple_namespace�s
z)QueryTestCase.test_empty_simple_namespacecCs(tjddd�}t�|�}|�|d�dS)Nr0rv)r;rAznamespace(a=1, b=2)r�r�rrr	�test_small_simple_namespace��
z)QueryTestCase.test_small_simple_namespacecCs<tjddddddddd	d
�	}tj|ddd�}|�|d
�dS)Nrr0rvrxr_rar�r�r��	�the�quick�brown�fox�jumped�overr;�lazy�dog�<r�z�namespace(the=0,
          quick=1,
          brown=2,
          fox=3,
          jumped=4,
          over=5,
          a=6,
          lazy=7,
          dog=8)r�r�rrr	�test_simple_namespace�s�z#QueryTestCase.test_simple_namespacecCsJGdd�dtj�}|ddddddd	d
dd�	}tj|d
d�}|�|d�dS)Nc@r)zGQueryTestCase.test_simple_namespace_subclass.<locals>.AdvancedNamespaceNrrrrr	�AdvancedNamespace�sr�rr0rvrxr_rar�r�r�r�r�rlz�AdvancedNamespace(the=0,
                  quick=1,
                  brown=2,
                  fox=3,
                  jumped=4,
                  over=5,
                  a=6,
                  lazy=7,
                  dog=8)r�)rr�r�r�rrr	�test_simple_namespace_subclass�s�z,QueryTestCase.test_simple_namespace_subclasscCs(t�dd��}t�|�}|�|d�dS)N�MyDataclassrz
MyDataclass())r8�make_dataclassrmr�r��r�dcr�rrr	�test_empty_dataclass�r�z"QueryTestCase.test_empty_dataclasscCs$tdd�}t�|�}|�|d�dS)N�text�{z3dataclass1(field1='text', field2=123, field3=False))r,rmr�r�r�rrr	�test_small_dataclass�s

z"QueryTestCase.test_small_dataclasscCs4tdtd�d�}tj||gddd�}|�|d�dS)Nzsome fairly long textg _�BTr�r_r�z�[   dataclass1(field1='some fairly long text',
               field2=10000000000,
               field3=True),
    dataclass1(field1='some fairly long text',
               field2=10000000000,
               field3=True)])r,r6rmr�r�r�rrr	�test_larger_dataclass�sz#QueryTestCase.test_larger_dataclasscC�$t�}tj|dd�}|�|d�dS)N�rlr=)r:rmr�r�r�rrr	�test_dataclass_with_repr
�z&QueryTestCase.test_dataclass_with_reprcCr�)Nr�rlz+<test.test_pprint.dataclass3 object at \w+>)r?rmr��assertRegexr�rrr	�test_dataclass_no_reprr�z$QueryTestCase.test_dataclass_no_reprcCs,td�}||_tj|dd�}|�|d�dS)Nr�rlz!dataclass4(a=...,
           b=1))r@r;rmr�r�r�rrr	�test_recursive_dataclasssz&QueryTestCase.test_recursive_dataclasscCs:td�}td�}||_||_tj|dd�}|�|d�dS)Nr�rlzLdataclass5(a=dataclass6(c=...,
                        d=1),
           b=1))rErFr;rGrmr�r�)r�dc5�dc6r�rrr	�test_cyclic_dataclasssz#QueryTestCase.test_cyclic_dataclasscCsbddd�}d}t�}|�|�|�|�dg}d}|�|�|�|�dg}d}|�|�|�|�dS)	Nz should be presented using repr()z	like.this)znames with spaceszothers.should.not.bez[{'names with spaces': 'should be presented using repr()',
 others.should.not.be: like.this}z
with spacez['with space']z
without.spacez[without.space])�DottedPrettyPrinterr�r�)rr�r��dotted_printerr��exp1r��exp2rrr	�test_subclassing's�zQueryTestCase.test_subclassingcCs|�t�t��d�|�t�ttd���d�|�tjttd��dd�d�|�tjttd��dd�d�|�tjttd��dd�d	�|�t�t��d
�|�t�ttd���d�|�tjttd��dd�d�|�tjttd��dd�d
�|�tjt	td��dd�d�dS)Nzset()rxz	{0, 1, 2}r�r�rlz{0,
 1,
 2,
 3,
 4,
 5,
 6}z?set2({0,
      1,
      2,
      3,
      4,
      5,
      6})zset3({0, 1, 2, 3, 4, 5, 6})zfrozenset()zfrozenset({0, 1, 2})zbfrozenset({0,
           1,
           2,
           3,
           4,
           5,
           6})zifrozenset2({0,
            1,
            2,
            3,
            4,
            5,
            6})z!frozenset3({0, 1, 2, 3, 4, 5, 6}))
r�rmr�r"r]r r!r&r$r%rrrr	�test_set_reprs:s ���zQueryTestCase.test_set_reprscCsHd}tj�d�}|�t�|�|�d}tj�|�}|�t�|�|�dS)NaE{frozenset(): frozenset({frozenset({2}), frozenset({0}), frozenset({1})}),
 frozenset({0}): frozenset({frozenset(),
                            frozenset({0, 2}),
                            frozenset({0, 1})}),
 frozenset({1}): frozenset({frozenset(),
                            frozenset({1, 2}),
                            frozenset({0, 1})}),
 frozenset({2}): frozenset({frozenset(),
                            frozenset({1, 2}),
                            frozenset({0, 2})}),
 frozenset({1, 2}): frozenset({frozenset({2}),
                               frozenset({1}),
                               frozenset({0, 1, 2})}),
 frozenset({0, 2}): frozenset({frozenset({2}),
                               frozenset({0}),
                               frozenset({0, 1, 2})}),
 frozenset({0, 1}): frozenset({frozenset({0}),
                               frozenset({1}),
                               frozenset({0, 1, 2})}),
 frozenset({0, 1, 2}): frozenset({frozenset({1, 2}),
                                  frozenset({0, 2}),
                                  frozenset({0, 1})})}rxaK5{frozenset({frozenset({0, 2}), frozenset({0})}): frozenset({frozenset({frozenset({0,
                                                                                  2}),
                                                                       frozenset({0,
                                                                                  1,
                                                                                  2})}),
                                                            frozenset({frozenset({0}),
                                                                       frozenset({0,
                                                                                  1})}),
                                                            frozenset({frozenset(),
                                                                       frozenset({0})}),
                                                            frozenset({frozenset({2}),
                                                                       frozenset({0,
                                                                                  2})})}),
 frozenset({frozenset({0, 1}), frozenset({1})}): frozenset({frozenset({frozenset({0,
                                                                                  1}),
                                                                       frozenset({0,
                                                                                  1,
                                                                                  2})}),
                                                            frozenset({frozenset({0}),
                                                                       frozenset({0,
                                                                                  1})}),
                                                            frozenset({frozenset({1}),
                                                                       frozenset({1,
                                                                                  2})}),
                                                            frozenset({frozenset(),
                                                                       frozenset({1})})}),
 frozenset({frozenset({1, 2}), frozenset({1})}): frozenset({frozenset({frozenset({1,
                                                                                  2}),
                                                                       frozenset({0,
                                                                                  1,
                                                                                  2})}),
                                                            frozenset({frozenset({2}),
                                                                       frozenset({1,
                                                                                  2})}),
                                                            frozenset({frozenset(),
                                                                       frozenset({1})}),
                                                            frozenset({frozenset({1}),
                                                                       frozenset({0,
                                                                                  1})})}),
 frozenset({frozenset({1, 2}), frozenset({2})}): frozenset({frozenset({frozenset({1,
                                                                                  2}),
                                                                       frozenset({0,
                                                                                  1,
                                                                                  2})}),
                                                            frozenset({frozenset({1}),
                                                                       frozenset({1,
                                                                                  2})}),
                                                            frozenset({frozenset({2}),
                                                                       frozenset({0,
                                                                                  2})}),
                                                            frozenset({frozenset(),
                                                                       frozenset({2})})}),
 frozenset({frozenset(), frozenset({0})}): frozenset({frozenset({frozenset({0}),
                                                                 frozenset({0,
                                                                            1})}),
                                                      frozenset({frozenset({0}),
                                                                 frozenset({0,
                                                                            2})}),
                                                      frozenset({frozenset(),
                                                                 frozenset({1})}),
                                                      frozenset({frozenset(),
                                                                 frozenset({2})})}),
 frozenset({frozenset(), frozenset({1})}): frozenset({frozenset({frozenset(),
                                                                 frozenset({0})}),
                                                      frozenset({frozenset({1}),
                                                                 frozenset({1,
                                                                            2})}),
                                                      frozenset({frozenset(),
                                                                 frozenset({2})}),
                                                      frozenset({frozenset({1}),
                                                                 frozenset({0,
                                                                            1})})}),
 frozenset({frozenset({2}), frozenset()}): frozenset({frozenset({frozenset({2}),
                                                                 frozenset({1,
                                                                            2})}),
                                                      frozenset({frozenset(),
                                                                 frozenset({0})}),
                                                      frozenset({frozenset(),
                                                                 frozenset({1})}),
                                                      frozenset({frozenset({2}),
                                                                 frozenset({0,
                                                                            2})})}),
 frozenset({frozenset({0, 1, 2}), frozenset({0, 1})}): frozenset({frozenset({frozenset({1,
                                                                                        2}),
                                                                             frozenset({0,
                                                                                        1,
                                                                                        2})}),
                                                                  frozenset({frozenset({0,
                                                                                        2}),
                                                                             frozenset({0,
                                                                                        1,
                                                                                        2})}),
                                                                  frozenset({frozenset({0}),
                                                                             frozenset({0,
                                                                                        1})}),
                                                                  frozenset({frozenset({1}),
                                                                             frozenset({0,
                                                                                        1})})}),
 frozenset({frozenset({0}), frozenset({0, 1})}): frozenset({frozenset({frozenset(),
                                                                       frozenset({0})}),
                                                            frozenset({frozenset({0,
                                                                                  1}),
                                                                       frozenset({0,
                                                                                  1,
                                                                                  2})}),
                                                            frozenset({frozenset({0}),
                                                                       frozenset({0,
                                                                                  2})}),
                                                            frozenset({frozenset({1}),
                                                                       frozenset({0,
                                                                                  1})})}),
 frozenset({frozenset({2}), frozenset({0, 2})}): frozenset({frozenset({frozenset({0,
                                                                                  2}),
                                                                       frozenset({0,
                                                                                  1,
                                                                                  2})}),
                                                            frozenset({frozenset({2}),
                                                                       frozenset({1,
                                                                                  2})}),
                                                            frozenset({frozenset({0}),
                                                                       frozenset({0,
                                                                                  2})}),
                                                            frozenset({frozenset(),
                                                                       frozenset({2})})}),
 frozenset({frozenset({0, 1, 2}), frozenset({0, 2})}): frozenset({frozenset({frozenset({1,
                                                                                        2}),
                                                                             frozenset({0,
                                                                                        1,
                                                                                        2})}),
                                                                  frozenset({frozenset({0,
                                                                                        1}),
                                                                             frozenset({0,
                                                                                        1,
                                                                                        2})}),
                                                                  frozenset({frozenset({0}),
                                                                             frozenset({0,
                                                                                        2})}),
                                                                  frozenset({frozenset({2}),
                                                                             frozenset({0,
                                                                                        2})})}),
 frozenset({frozenset({1, 2}), frozenset({0, 1, 2})}): frozenset({frozenset({frozenset({0,
                                                                                        2}),
                                                                             frozenset({0,
                                                                                        1,
                                                                                        2})}),
                                                                  frozenset({frozenset({0,
                                                                                        1}),
                                                                             frozenset({0,
                                                                                        1,
                                                                                        2})}),
                                                                  frozenset({frozenset({2}),
                                                                             frozenset({1,
                                                                                        2})}),
                                                                  frozenset({frozenset({1}),
                                                                             frozenset({1,
                                                                                        2})})})})�test�test_set�cuber�rmr��	linegraph)r�
cube_repr_tgtr
�
cubo_repr_tgt�cuborrr	�test_set_of_sets_reprsfsz$QueryTestCase.test_set_of_sets_reprscCs�d}dddddddiiiiii}ddddddggggggg}|�t�|�t|��|�t�|�t|��|�t�|�t|��d}d	}d
}|�tj|dd�|�|�tj|dd�|�|�tj|dd�|�dS)N)r0)rv)rx)r_)rar�r0rvrxr_rar�z
(1, (...))z
{1: {...}}z
[1, [...]]rk)r�rmr�r2)r�nested_tuple�nested_dict�nested_list�	lv1_tuple�lv1_dict�lv1_listrrr	�
test_depth:szQueryTestCase.test_depthc	Cs d}dd�t|�D�}t�|�t|td�}dd�}|�|t�t|���dd�	t
t|��d	�|�|t�t|���d
d�	t
t|��d�|�|t�t
�|���dd�	dd
�|D��d	�|�t�tdddi�dtt�d�ddg}|�t�t
�|d��dtt|td���dS)Nr�cSsg|]}t��qSr)rI��.0�irrr	�
<listcomp>Lsz>QueryTestCase.test_sort_unorderable_values.<locals>.<listcomp>)�keycSs|�dd��dd�S)Nr�r�r�)r�)�srrr	�<lambda>Osz<QueryTestCase.test_sort_unorderable_values.<locals>.<lambda>�{�,�}zfrozenset({z})css�|]}d|VqdS)z%r:NoneNr)r�krrr	�	<genexpr>Vs�z=QueryTestCase.test_sort_unorderable_values.<locals>.<genexpr>rr0z{1: 0, z: 0})r0rz{%r: 0, %r: 0})r]�random�shuffle�sortedrJr�rmr�r"r�r�r2r&r*r�rIr)r�n�keys�skeys�cleanrrr	�test_sort_unorderable_valuesIs*
�����z*QueryTestCase.test_sort_unorderable_valuescCs
t�}tt|��}|�||�|�tt|��tt|���|�t||g�||g�|�t||g�||g�|�tj	t
||g�dd�d||f�|�tj	t
||g�dd�d||f�|�tj	t�||g�dd�d||f�|�tj	t�||g�dd�d||f�dS)Nr0rlz	{%r,
 %r}z{%r: None,
 %r: None})
rIrKrN�
assertLessr4r�r�r(rmr�r"r*r�)rr;rArrr	�*test_sort_orderable_and_unorderable_valuesas$
�
�
�
�z8QueryTestCase.test_sort_orderable_and_unorderable_valuescCsvd}|�tj|dd�d�|�tjd|dd�dd�d	�d
}|�tj|dd�t|��|�tj|dd�d
�|�tj|dd�d�|�tj|gggggdd�d�|�tj|gggggdd�d�|�tj|gggggdd�d�d}|�tj|dd�t|��|�t�d�d�|d9}tdd�D]&}tj||d�}|�t|�|�tj|gd|d�}|�t|�|gd�q�dS)Nr��rl�6('the quick brown '
 'fox jumped over '
 'a lazy dog')r0rvr�r�zW{'a': 1,
 'b': 'the quick brown '
      'fox jumped over '
      'a lazy dog',
 'c': 2}u@Portons dix bons "whiskys"
à l'avocat goujat	 qui fumait au zoo�D�uN('Portons dix bons "whiskys"\n'
 "à l'avocat goujat\t qui "
 'fumait au zoo')r�uV('Portons dix bons '
 '"whiskys"\n'
 "à l'avocat "
 'goujat\t qui '
 'fumait au zoo')�#u^[[[[['Portons dix bons "whiskys"\n'
     "à l'avocat goujat\t qui "
     'fumait au zoo']]]]]un[[[[['Portons dix bons '
     '"whiskys"\n'
     "à l'avocat "
     'goujat\t qui '
     'fumait au zoo']]]]]�uv[[[[['Portons dix '
     'bons "whiskys"\n'
     "à l'avocat "
     'goujat\t qui '
     'fumait au '
     'zoo']]]]]�dxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx�Pr��''r�rxr`)r�rmr�r2r]r�)rr��special�unwrappablercr�rrr	�
test_str_wrapus0��   �zQueryTestCase.test_str_wrapcCsDdd�td�D�dd�td�D�}d}|�tj|ddd	�|�dS)
NcSsg|]
}tt||���qSr�rr]rrrr	r�sz.QueryTestCase.test_compact.<locals>.<listcomp>racSsg|]}tt|���qSrr<rrrr	r�sr�z�[[], [0], [0, 1, 2, 3],
 [0, 1, 2, 3, 4, 5, 6, 7, 8],
 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
  14, 15],
 [], [0], [0, 1], [0, 1, 2], [0, 1, 2, 3],
 [0, 1, 2, 3, 4]]�/T�rcrf)r]r�rmr�)rr�r�rrr	�test_compact�s
�zQueryTestCase.test_compactcCs�d}d}dg|}t|d�D]}|g}qt|dd|d|d�D]!}tj||dd���}ttt|��}|�||�|�||d�q$dS)	Nr�r�rr0rvrxTr>)	r]rmr��
splitlines�maxr�r�assertLessEqual�
assertGreater)r�levels�numberr�r�w�lines�maxwidthrrr	�test_compact_width�s
"�z QueryTestCase.test_compact_widthcCs�|�tjddd�d�|�tjddd�d�d}|�tj|dd�t|��|�tj|d	d�d
�|�tj|dd�d�|�tj|d
d�d�ttd
��}|�tj|dd�t|��|�tj|dd�d�|�tj|dd�d�|�tj|dd�d�|�tjd|dd�dd�d�|�tjd|dd�dd�d�|�tj|ggggggdd�d�|�tj|ggggggdd�d�tdd�D]&}tj||d�}|�t|�|�tj|gd|d�}|�t|�|gd�q�dS)Nr�r0rlzb''sabcdzb'abcd'�abcdefghijklmnopqrstuvwxyz�r0z$(b'abcdefghijkl'
 b'mnopqrstuvwxyz')�z)(b'abcdefghijkl'
 b'mnopqrstuvwx'
 b'yz')r��=�0zD(b'\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b'
 b'\x0c\r\x0e\x0f')� zI(b'\x00\x01\x02\x03'
 b'\x04\x05\x06\x07\x08\t\n\x0b'
 b'\x0c\r\x0e\x0f')zN(b'\x00\x01\x02\x03'
 b'\x04\x05\x06\x07'
 b'\x08\t\n\x0b'
 b'\x0c\r\x0e\x0f')rvr��zJ{'a': 1,
 'b': b'abcdefghijkl'
      b'mnopqrstuvwx'
      b'yz',
 'c': 2}r�zJ{'a': 1,
 'b': b'abcdefgh'
      b'ijklmnop'
      b'qrstuvwxyz',
 'c': 2}r�z3[[[[[[b'abcdefghijklmnop'
      b'qrstuvwxyz']]]]]]r�zS[[[[[[b'\x00\x01\x02\x03\x04\x05\x06\x07'
      b'\x08\t\n\x0b\x0c\r\x0e\x0f']]]]]]�@)r�rmr�r2�bytesr]r�)r�lettersr9rcr�rrr	�test_bytes_wrap�s<����""�zQueryTestCase.test_bytes_wrapcCsF|�tjt�dd�d�td�}|�tj|dd�t|��|�tj|dd�d�|�tj|dd�d	�|�tj|d
d�d	�ttd��}|�tj|dd�t|��|�tj|d
d�d�|�tj|dd�d�|�tj|dd�d�|�tjd|dd�dd�d�|�tj|gggggdd�d�|�tj|gggggdd�d�dS)Nr0rlzbytearray(b'')rJr`�z6bytearray(b'abcdefghijkl'
          b'mnopqrstuvwxyz')�zDbytearray(b'abcdefghijkl'
          b'mnopqrstuvwx'
          b'yz')r�r��H�9zVbytearray(b'\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b'
          b'\x0c\r\x0e\x0f')r�zdbytearray(b'\x00\x01\x02\x03'
          b'\x04\x05\x06\x07\x08\t\n\x0b'
          b'\x0c\r\x0e\x0f')zrbytearray(b'\x00\x01\x02\x03'
          b'\x04\x05\x06\x07'
          b'\x08\t\n\x0b'
          b'\x0c\r\x0e\x0f')rvr�r3zi{'a': 1,
 'b': bytearray(b'abcdefghijkl'
                b'mnopqrstuvwx'
                b'yz'),
 'c': 2}�%zE[[[[[bytearray(b'abcdefghijklmnop'
               b'qrstuvwxyz')]]]]]�2ze[[[[[bytearray(b'\x00\x01\x02\x03\x04\x05\x06\x07'
               b'\x08\t\n\x0b\x0c\r\x0e\x0f')]]]]])r�rmr�r{r2r])rrSr9rrr	�test_bytearray_wraps$�� $z!QueryTestCase.test_bytearray_wrapcCsTt�t�}|�tj|dd�d�d��}t�tt|t�	���}|�t�|�d�dS)Nr0rlzdefaultdict(<class 'int'>, {})r�z�defaultdict(<class 'int'>,
            {'a': 6,
             'brown': 2,
             'dog': 8,
             'fox': 3,
             'jumped': 4,
             'lazy': 7,
             'over': 5,
             'quick': 1,
             'the': 0}))
r��defaultdictr6r�rmr�r�r�r�r�r�rrr	�test_default_dict-s
�zQueryTestCase.test_default_dictcCsBt��}|�tj|dd�d�t�d�}|�tj|dd�d�dS)Nr0rlz	Counter()�
senselessnessr`zDCounter({'s': 6,
         'e': 4,
         'n': 2,
         'l': 1}))r��Counterr�rmr�r�rrr	�test_counter?s
�zQueryTestCase.test_countercCs�t��}|�tj|dd�d�d��}tt|t�	���}t�t
|��}|�t�|�d�t�t
|�t�|��}|�t�|�d�dS)Nr0rlzChainMap({})r�z�ChainMap({'a': 6,
          'brown': 2,
          'dog': 8,
          'fox': 3,
          'jumped': 4,
          'lazy': 7,
          'over': 5,
          'quick': 1,
          'the': 0})a�ChainMap({'a': 6,
          'brown': 2,
          'dog': 8,
          'fox': 3,
          'jumped': 4,
          'lazy': 7,
          'over': 5,
          'quick': 1,
          'the': 0},
         OrderedDict([('the', 0),
                      ('quick', 1),
                      ('brown', 2),
                      ('fox', 3),
                      ('jumped', 4),
                      ('over', 5),
                      ('a', 6),
                      ('lazy', 7),
                      ('dog', 8)])))r��ChainMapr�rmr�r�rr�r�r�r*r�)rrHr��itemsrrr	�
test_chainmapJs��zQueryTestCase.test_chainmapcCs�t��}|�tj|dd�d�tjdd�}|�tj|dd�d�d��}t�t|t����}|�t�|�d�tjt|t���dd�}|�t�|�d	�dS)
Nr0rlz	deque([])r�)�maxlenzdeque([], maxlen=7)r�z�deque([('the', 0),
       ('quick', 1),
       ('brown', 2),
       ('fox', 3),
       ('jumped', 4),
       ('over', 5),
       ('a', 6),
       ('lazy', 7),
       ('dog', 8)])z�deque([('brown', 2),
       ('fox', 3),
       ('jumped', 4),
       ('over', 5),
       ('a', 6),
       ('lazy', 7),
       ('dog', 8)],
      maxlen=7))	r��dequer�rmr�r�r�r�r�r�rrr	�
test_dequeqs��zQueryTestCase.test_dequecC�Pt��}|�tj|dd�d�d��}t�t|t����}|�t�|�d�dS)Nr0rlz{}r�zi{'a': 6,
 'brown': 2,
 'dog': 8,
 'fox': 3,
 'jumped': 4,
 'lazy': 7,
 'over': 5,
 'quick': 1,
 'the': 0})	r��UserDictr�rmr�r�r�r�r�r�rrr	�test_user_dict���zQueryTestCase.test_user_dictcCrg)Nr0rlz[]r�z{[('the', 0),
 ('quick', 1),
 ('brown', 2),
 ('fox', 3),
 ('jumped', 4),
 ('over', 5),
 ('a', 6),
 ('lazy', 7),
 ('dog', 8)])	r��UserListr�rmr�r�r�r�r�r�rrr	�test_user_list�rjzQueryTestCase.test_user_listcCs^t�d�}|�tj|dd�d�t�d�}|�tj|dd�d�|�tjd|idd�d�dS)	Nr�r0rlr8r�r�r1zF{1: 'the quick '
    'brown fox '
    'jumped over a '
    'lazy dog'})r��
UserStringr�rmr�r�rrr	�test_user_string�s

��zQueryTestCase.test_user_stringN)4rrrr^rur�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�rrrr	r
�unittest�expectedFailurer�support�cpython_onlyrrr-r/r;r?rIrTr[r]r`rcrfrirlrnrrrr	rZ}s`
!#$&,R<9+'rZc@r)rcCs>t|t�rd|vrt|�ddfS|ddfStj�|||||�S)Nr�r0r)�
isinstancer4r2rmrn�format)r�object�context�	maxlevels�levelrrr	rt�s


�zDottedPrettyPrinter.formatN)rrrrtrrrr	r�sr�__main__).r�r8ror�rmr&�test.supportr�
test.test_setr�rorrrrrrrrr"r r!r#r&r$r%r'r*r(r)r+�	dataclassr,r:r?r@rErFrIrK�TestCaserZrnrr�mainrrrr	�<module>sh
M

�

Youez - 2016 - github.com/yon3zu
LinuXploit