Sindbad~EG File Manager

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

�

'ΜgX����ddlZddlZddlZddlZddlZddlZddlZddlZddl	Zddl
Z
ddlZGd�de�Z
Gd�de�ZGd�de�ZGd�d	e�ZGd
�de�ZGd�d
e�ZGd�de�ZGd�de�ZGd�de�ZGd�de�ZGd�de�ZGd�de�ZGd�de�ZGd�de�ZGd�de�Zej@Gd �d!��Z!ej@Gd"�d#��Z"ej@d$�%�Gd&�d'��Z#ej@Gd(�d)��Z$ej@Gd*�d+��Z%ej@Gd,�d-��Z&Gd.�d/�Z'Gd0�d1�Z(Gd2�d3ejR�Z*Gd4�d5ejV�Z,e-d6k(rej\�yy)7�Nc��eZdZy)�list2N��__name__�
__module__�__qualname__���-/usr/local/lib/python3.12/test/test_pprint.pyrr���r
rc��eZdZd�Zy)�list3c�,�tj|�S�N)�list�__repr__��selfs rrzlist3.__repr__����}�}�T�"�"r
N�rrrrr	r
rrr���#r
rc��eZdZd�Zy)�list_custom_reprc�D�dttj|��zS�N�*)�lenrrrs rrzlist_custom_repr.__repr__����3�t�}�}�T�*�+�+�+r
Nrr	r
rrr���,r
rc��eZdZy)�tuple2Nrr	r
rr!r!rr
r!c��eZdZd�Zy)�tuple3c�,�tj|�Sr)�tuplerrs rrztuple3.__repr__s���~�~�d�#�#r
Nrr	r
rr#r#s��$r
r#c��eZdZd�Zy)�tuple_custom_reprc�D�dttj|��zSr)rr%rrs rrztuple_custom_repr.__repr__#s���3�u�~�~�d�+�,�,�,r
Nrr	r
rr'r'"s��-r
r'c��eZdZy)�set2Nrr	r
rr*r*&rr
r*c��eZdZd�Zy)�set3c�,�tj|�Sr)�setrrs rrz
set3.__repr__*s���|�|�D�!�!r
Nrr	r
rr,r,)s��"r
r,c��eZdZd�Zy)�set_custom_reprc�D�dttj|��zSr)rr.rrs rrzset_custom_repr.__repr__.s���3�s�|�|�D�)�*�*�*r
Nrr	r
rr0r0-s��+r
r0c��eZdZy)�
frozenset2Nrr	r
rr3r31rr
r3c��eZdZd�Zy)�
frozenset3c�,�tj|�Sr)�	frozensetrrs rrzfrozenset3.__repr__5s���!�!�$�'�'r
Nrr	r
rr5r54s��(r
r5c��eZdZd�Zy)�frozenset_custom_reprc�D�dttj|��zSr)rr7rrs rrzfrozenset_custom_repr.__repr__9s���3�y�)�)�$�/�0�0�0r
Nrr	r
rr9r98s��1r
r9c��eZdZy)�dict2Nrr	r
rr<r<<rr
r<c��eZdZd�Zy)�dict3c�,�tj|�Sr)�dictrrs rrzdict3.__repr__@rr
Nrr	r
rr>r>?rr
r>c��eZdZd�Zy)�dict_custom_reprc�D�dttj|��zSr)rr@rrs rrzdict_custom_repr.__repr__Drr
Nrr	r
rrBrBCrr
rBc�b�eZdZUeed<eed<dZeed<ejdd��Z
eed<y)	�
dataclass1�field1�field2F�field3�)�default�repr�field4N)rrr�str�__annotations__�intrH�bool�dataclasses�fieldrLr	r
rrErEGs/���K��K��F�D��#�+�#�#�A�E�:�F�C�:r
rEc�"�eZdZUdZeed<d�Zy)�
dataclass2rI�ac��y)N�0custom repr that doesn't fit within pprint widthr	rs rrzdataclass2.__repr__Qs��Ar
N)rrrrUrOrNrr	r
rrTrTNs��
�A�s�J�Br
rTF)rKc��eZdZUdZeed<y)�
dataclass3rIrUN)rrrrUrOrNr	r
rrYrYTs��
�A�s�Jr
rYc�&�eZdZUded<dZeed<y)�
dataclass4rUrI�bN�rrrrNr\rOr	r
rr[r[X����O�
�A�s�Jr
r[c�&�eZdZUded<dZeed<y)�
dataclass5�
dataclass6rUrIr\Nr]r	r
rr`r`]r^r
r`c�&�eZdZUded<dZeed<y)rar`�crI�dN)rrrrNrdrOr	r
rrarabr^r
rac��eZdZd�Zy)�Unorderablec�*�tt|��Sr)rM�idrs rrzUnorderable.__repr__hs���2�d�8�}�r
Nrr	r
rrfrfgs��r
rfc�<�eZdZd�Zd�Zd�Zd�Zd�Zd�Zd�Z	d�Z
y	)
�	Orderablec��||_yr��_hash)r�hashs  r�__init__zOrderable.__init__ms	����
r
c��y)NFr	�r�others  r�__lt__zOrderable.__lt__os��r
c��||k7Srr	rqs  r�__gt__zOrderable.__gt__q����u�}�r
c��||k(Srr	rqs  r�__le__zOrderable.__le__srvr
c��y)NTr	rqs  r�__ge__zOrderable.__ge__us��r
c�
�||uSrr	rqs  r�__eq__zOrderable.__eq__ws���u�}�r
c�
�||uSrr	rqs  r�__ne__zOrderable.__ne__ys
���5� � r
c��|jSrrlrs r�__hash__zOrderable.__hash__{s���z�z�r
N)rrrrorsrurxrzr|r~r�r	r
rrjrjls*��������!�r
rjc�j�eZdZd�Zd�Zd�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�Ze jBe"jFjHd���Z%d�Z&d �Z'd!�Z(d"�Z)d#�Z*d$�Z+d%�Z,d&�Z-d'�Z.d(�Z/d)�Z0d*�Z1d+�Z2d,�Z3d-�Z4y.)/�
QueryTestCasec��ttd��|_ttd��|_|j|jd<y)N�d��i�)r�rangerUr\rs r�setUpzQueryTestCase.setUp�s3���e�C�j�!����e�C�j�!����f�f����s�r
c���tj�}tjdddtj�d��}tjdddtj��}tjd��}|j	t
�5tjdddtj�d�}ddd�|j	ttjd�	�|j	ttjd
��|j	ttjd��|j	ttjd
��y#1swY��xYw)
N��(�T)�indent�width�depth�stream�compactF��
sort_dicts����r�r�r��r�)�pprint�
PrettyPrinter�io�StringIO�assertRaises�	TypeError�
ValueError)r�pps  r�	test_initzQueryTestCase.test_init�s��
�
!�
!�
#��
�
!�
!��"�A�)+�����F��
�
!�
!�!�R��B�K�K�M�
:��
�
!�
!�U�
3��
�
�
�y�
)��%�%�a��Q����
�t�D�B�*����*�f�&:�&:�2��F����*�f�&:�&:�!��D����*�f�&:�&:�"��E����*�f�&:�&:�!��D�*�
)�s�,E#�#E,c���tj�}dddddgdddidtd�d	d
dd|j|jfD]�}|jtj|�d|���|jtj|�d
|���|j|j
|�d|���|j|j|�d
|�����y)N�g@y@�abc�)r�r�sdefsghiTF.�expected not isrecursive for �expected isreadable for )	r�r��	bytearrayrUr\�assertFalse�isrecursive�
assertTrue�
isreadable)rr��safes   r�
test_basiczQueryTestCase.test_basic�s���
�
!�
!�
#����R����U�Q��F�F��v�&��e�T�3��V�V�T�V�V�%�D�
���V�/�/��5�BF�H�
J��O�O�F�-�-�d�3�<@�B�
D�
���R�^�^�D�1�BF�H�
J��O�O�B�M�M�$�/�<@�B�
D�%r
c���tjd�5d}tj|�tj�j|�ddd�y#1swYyxYw)Nzthis should not fail)�
contextlib�redirect_stdoutr�r�)r�values  r�test_stdout_is_Nonez!QueryTestCase.test_stdout_is_None�sD��
�
'�
'��
-�*�E��M�M�%� �� � �"�)�)�%�0�	.�
-�
-�s�;A�A#c��|j|jd<i|_|jx|jd<x|jd<|jd<tj�}|j|j|j|j|jffD]�}|jtj|�d�|jtj|�d�|j|j
|�d�|j|j|�d���|jj�|jdd�=|jdd�=|j|j|j|j|jffD]�}|jtj|�d|���|jtj|�d|���|j|j
|�d|���|j|j|�d|�����y)	N�CrrIr�zexpected isrecursivezexpected not isreadabler�r�)
rUr\rdr�r�r�r�r�r��clear)rr��ickyr�s    r�test_knottedzQueryTestCase.test_knotted�s����V�V����r�
����,0�F�F�2����q�	�2�D�F�F�1�I����q�	�
�
!�
!�
#���F�F�D�F�F�D�F�F�T�V�V�T�V�V�,<�<�D��O�O�F�.�.�t�4�6L�M����V�.�.�t�4�6O�P��O�O�B�N�N�4�0�2H�I����R�]�]�4�0�2K�L�	=�	
�������F�F�1�I��F�F�1�I��F�F�D�F�F�D�F�F�T�V�V�T�V�V�,<�<�D����V�/�/��5�BF�H�
J��O�O�F�-�-�d�3�<@�B�
D�
���R�^�^�D�1�BF�H�
J��O�O�B�M�M�$�/�<@�B�
D�=r
c��tj�}t�tttjfD]�}|jtj|�d|���|jtj|�d|���|j|j	|�d|���|j|j
|�d|�����y)Nr�zexpected not isreadable for )r�r��objectrOr�r�r�)rr��
unreadables   r�test_unreadablezQueryTestCase.test_unreadable�s���
�
!�
!�
#�� �(�C���1C�1C�C�J����V�/�/�
�;�BL�N�
P����V�.�.�z�:�AK�M�
O�
���R�^�^�J�7�BL�N�
P����R�]�]�:�6�AK�M�
O�Dr
c���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��t	d
dg��t	td���tdh��t
dh��tdh��tdh��tdh��tdh��tddi��tddi��tddd��d�d�d�d��D]�}t!|�}|j#tj$|�|�|j#tj$|dd��j'dd�|�|j#tj$|d��|�|j#tj(|�|���y) Nryg�r
r	i����y��g���x�x�r�r��)rIr�r�r�r����
i����r�TF.rI�r�r��
� ��underscore_numbers)r�r!r#rrr.r*r,r7r3r5r<r>r�r�r�rK�assertEqual�pformat�replace�saferepr)r�simple�natives   r�test_same_as_reprzQueryTestCase.test_same_as_repr�sH���q��!��T��3����C�������!�8��%+�X���� �7��$)�G���u��#�f��'+�f��!�{�	�%/�L�	�3=�,�	�
��
!�7��
%*�G�����
�)/�
����� %��'+��-0��26��8A������ �S��$%�a�&���� !��e��'(��V���e�}��'-�U�m��6<�E�#�J�5G���!�u��$�Q�q�E�l��-2�1�Q�%�L��;@��c�
�:K���A�3�x��"&�q�c���-1�!��I��!�!��~��(2�1�#���9C�A�3����a��V�}��',�Q��F�m���R��b�)�� �!� #�!� %)�!� +.�!�F�$�&�\�F����V�^�^�F�3�V�<����V�^�^�F�!�A�F�%�g�d�C�0�&�
:����V�^�^�F�t�L�f�U����V�_�_�V�4�f�=�/r
c���d}t�tgd��tt|��t�tgd��tt|��t�tgd��tt|��t	�t	gd��t	t|��t�tddi�tt
t|�t|���fD]�}t|�}dt|�z}|jtj|�|�|jtj|dd��|�|jtj|�|���y)	N��)rIr�r�r�r�rrIrr�)
rr�r'r0r9rB�ziprKrr�r�r�r�)r�N�contr��expecteds     r�#test_container_repr_override_calledz1QueryTestCase.test_container_repr_override_called�s����&�'�%�g�.�%�e�A�h�/�&�(�&�w�/�&�u�Q�x�0�$�&�$�W�-�$�U�1�X�.�*�,�*�7�3�*�5��8�4�%�'�%�q�!�f�-�%�c�%��(�5��8�&<�=��D� �$�Z�F��S��[�(�H����V�^�^�D�1�8�<����V�^�^�D��!�D�h�O����V�_�_�T�2�H�=�)r
c� �dddddddd�}d}ttfD]-}|jtj||��|��/td�}ddj
tt|��z}ttfD]-}|jtj||��|��/ttd��}d	dj
tt|��z}ttfD]-}|jtj||��|��/td�}d
dj
tt|��z}ttfD]/}|jtj||�d�
�|��1y)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(%s)z[   %s]z,
    r�r�)
r@r<r�r�r�r��join�maprMrrr%r!)r�o�exp�types    r�test_basic_line_wrapz"QueryTestCase.test_basic_line_wrapsF�����'(�%&�#$�$)�

+��"���5�M�D����V�^�^�D��G�4�c�:�"�
�#�J���v�{�{�3�s�A�;�/�/���5�M�D����V�^�^�D��G�4�c�:�"�
�%��*����v�{�{�3�s�A�;�/�/���F�O�D����V�^�^�D��G�4�c�:�$�
�#�J���)�.�.��S�!��5�5���5�M�D����V�^�^�D��G�A�>��D�"r
c��ttd��}tddd��}||g}d}|jt	j
|dd�	�|�d
}|jt	j
|dd�	�|�y)Nr�rIr�r�)�first�second�thirdzN[   [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
    {'first': 1, 'second': 2, 'third': 3}]r��*)r�r�za[   [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
    {   'first': 1,
        'second': 2,
        'third': 3}]�))rr�r@r�r�r�)r�o1�o2r�r�s     r�test_nested_indentationsz&QueryTestCase.test_nested_indentations;sr��
�%��)�_��
��!�1�
-��
��H��.��	
�������!�2�>��I���
	
�������!�2�>��Ir
c�V�d}t|�}|jtj|d��|�|jtj|d��|�|jtj|d��|�|jtj|d��d�y)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']]]]]�r����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�r�r�)rr�r�s   r�
test_widthzQueryTestCase.test_widthJs���	��
��N����������4�h�?���������4�h�?���������4�h�?���������4�7�	r
c���|jtjd�d�|jtjdd��d�G�fd�dt��|jtj�d��d	�y)
Ni���1234567Tr��	1_234_567c�(���eZdZ��fd�Zd�Z�xZS)�/QueryTestCase.test_integer.<locals>.Temperaturec�$��t�|��|�Sr)�super�__new__)�cls�celsius_degrees�Temperature�	__class__s  ��rr�z7QueryTestCase.test_integer.<locals>.Temperature.__new__us����w��{�O�D�Dr
c��|dz}|�d�S)Ngfffffq@u°Kr	)r�kelvin_degreess  rrz8QueryTestCase.test_integer.<locals>.Temperature.__repr__ws��!%����(�)��-�-r
)rrrr�r�
__classcell__)rrs@�rrr�ts���
E�
.r
rr�u
1273.15°K)r�r�r�rO)rrs @r�test_integerzQueryTestCase.test_integerpsc����������0�)�<��������D�I�;�W�	.�#�	.�	
�������D�(9�:�L�Ir
c��dddd�}|jtj|�d�|jtj||g�d�|jtjdggid��d�y)NrI�rUr\rcz{'a': 1, 'b': 1, 'c': 1}z4[{'a': 1, 'b': 1, 'c': 1}, {'a': 1, 'b': 1, 'c': 1}]r�)zxy	ab
r�r	z#{5: [[]], 'xy\tab\n': (3,), (): {}})r�r�r��rrds  r�test_sorted_dictzQueryTestCase.test_sorted_dict|sr��
�!�!�$���������*�,F�G��������A��/�B�	D�	
������T�r�d��(K�L�2�	4r
c���tjd�}|jtj|d��d�|jtj||gd��d�y)N�cbaFr�z!{'c': None, 'b': None, 'a': None}zF[{'c': None, 'b': None, 'a': None}, {'c': None, 'b': None, 'a': None}])r@�fromkeysr�r�r�rs  r�test_sort_dictzQueryTestCase.test_sort_dict�sO���M�M�%� ���������e�<�>a�b��������A��5�A�T�	Vr
c��tj�}|jtj|d��d�tjg�}|jtj|d��d�dj�}tjt
|tj���}|jtj|�d�y)NrIr�z
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�r�r��splitr��	itertools�count�rrd�wordss   r�test_ordered_dictzQueryTestCase.test_ordered_dict�s����#�#�%����������3�_�E��#�#�B�'����������3�_�E�<�B�B�D���#�#�C��y���/@�$A�B���������*�	�
	r
c��dj�}tt|tj���}tj|�}|jtj|�d�tjt|tj���}tj|�}|jtj|�d�y)Nrz�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)])))rr@r�rr�types�MappingProxyTyper�r�r�rr)rrrd�ms    r�test_mapping_proxyz QueryTestCase.test_mapping_proxy�s���<�B�B�D����U�I�O�O�-�.�/���"�"�1�%���������*�	-�		�
�#�#�C��y���/@�$A�B���"�"�1�%���������*�	-+�		,r
c�z�tj�}tj|�}|j	|d�y)Nznamespace()�r�SimpleNamespacer�r�r��r�ns�	formatteds   r�test_empty_simple_namespacez)QueryTestCase.test_empty_simple_namespace�s.��
�
"�
"�
$���N�N�2�&�	�����M�2r
c��tjdd��}tj|�}|j	|d�y)NrIr�)rUr\znamespace(a=1, b=2)rr s   r�test_small_simple_namespacez)QueryTestCase.test_small_simple_namespace�s3��
�
"�
"�Q�!�
,���N�N�2�&�	�����$9�:r
c��tjddddddddd	�
�	}tj|dd��}|j	|d
�y)NrrIr�r�r�r�r�r�r��	�the�quick�brown�fox�jumped�overrU�lazy�dog�<r�z�namespace(the=0,
          quick=1,
          brown=2,
          fox=3,
          jumped=4,
          over=5,
          a=6,
          lazy=7,
          dog=8)rr s   r�test_simple_namespacez#QueryTestCase.test_simple_namespace�sV��
�
"�
"����������

���N�N�2�R��:�	�����	%�		r
c��Gd�dtj�}|ddddddd	d
d��	}tj|d
��}|j	|d�y)Nc��eZdZy)�GQueryTestCase.test_simple_namespace_subclass.<locals>.AdvancedNamespaceNrr	r
r�AdvancedNamespacer4�s�r
r5rrIr�r�r�r�r�r�r�r'r0r�z�AdvancedNamespace(the=0,
                  quick=1,
                  brown=2,
                  fox=3,
                  jumped=4,
                  over=5,
                  a=6,
                  lazy=7,
                  dog=8)r)rr5r!r"s    r�test_simple_namespace_subclassz,QueryTestCase.test_simple_namespace_subclass�s\��<�� 5� 5�<�
����������

���N�N�2�R�0�	�����	%�		r
c��tjdd��}tj|�}|j	|d�y)N�MyDataclassr	z
MyDataclass())rQ�make_dataclassr�r�r��r�dcr"s   r�test_empty_dataclassz"QueryTestCase.test_empty_dataclass�s7��
:�[�
'�
'�
�r�
:�
<���N�N�2�&�	�����O�4r
c�j�tdd�}tj|�}|j|d�y)N�text�{z3dataclass1(field1='text', field2=123, field3=False))rEr�r�r�r:s   r�test_small_dataclassz"QueryTestCase.test_small_dataclasss-��
���
$���N�N�2�&�	�����$Y�Zr
c��tdtd�d�}tj||gdd��}|j	|d�y)Nzsome fairly long textg _�BTr0r�r�z�[   dataclass1(field1='some fairly long text',
               field2=10000000000,
               field3=True),
    dataclass1(field1='some fairly long text',
               field2=10000000000,
               field3=True)])rErOr�r�r�r:s   r�test_larger_dataclassz#QueryTestCase.test_larger_dataclasss@��
�/��T��D�
A���N�N�B��8�2�a�@�	�����% �	!r
c�j�t�}tj|d��}|j|d�y)N�r�rW)rTr�r�r�r:s   r�test_dataclass_with_reprz&QueryTestCase.test_dataclass_with_reprs*��
�\���N�N�2�R�0�	�����$V�Wr
c�j�t�}tj|d��}|j|d�y)Nr�r�z+<test.test_pprint.dataclass3 object at \w+>)rYr�r��assertRegexr:s   r�test_dataclass_no_reprz$QueryTestCase.test_dataclass_no_reprs*��
�\���N�N�2�R�0�	�����$R�Sr
c�z�td�}||_tj|d��}|j	|d�y)Nr�r�z!dataclass4(a=...,
           b=1))r[rUr�r�r�r:s   r�test_recursive_dataclassz&QueryTestCase.test_recursive_dataclasss8��
��
������N�N�2�R�0�	�����%�	r
c��td�}td�}||_||_t	j
|d��}|j
|d�y)Nr�r�zLdataclass5(a=dataclass6(c=...,
                        d=1),
           b=1))r`rarUrcr�r�r�)r�dc5�dc6r"s    r�test_cyclic_dataclassz#QueryTestCase.test_cyclic_dataclass$sI�����������������N�N�3�b�1�	�����%�	r
c��ddd�}d}t�}|j|j|�|�dg}d}|j|j|�|�dg}d}|j|j|�|�y)	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��exp2s        r�test_subclassingzQueryTestCase.test_subclassing/s���"D�%0�
2��%��-�.������/�/��2�C�8��^��������/�/��3�T�:��
�� ������/�/��3�T�:r
c	�@�|jtjt��d�|jtjtt	d���d�|jtjtt	d��d��d�|jtjtt	d��d��d�|jtjt
t	d��d��d	�|jtjt��d
�|jtjtt	d���d�|jtjtt	d��d��d�|jtjtt	d��d��d
�|jtjtt	d��d��d�y)Nzset()r�z	{0, 1, 2}r�rDr�z{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�r�r�r.r�r*r,r7r3r5rs r�test_set_reprszQueryTestCase.test_set_reprsBs{����������.��8��������E�!�H�
�6��D��������E�!�H�
�R�@�C�	�	
�������U�1�X��b�A�D
�	�	
�������U�1�X��b�A�6�	8�	
������	��4�m�D�������	�%��(�(;�<�/�	1�������	�%��(�(;�2�F�I�	�	
������
�5��8�(<�B�G�J�	�	
������
�5��8�(<�B�G�<�	>r
c��d}tjjd�}|jt	j
|�|�d}tjj
|�}|jt	j
|�|�y)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})})}r�aK5{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�r�r��	linegraph)r�
cube_repr_tgtrZ�
cubo_repr_tgt�cubos     r�test_set_of_sets_reprsz$QueryTestCase.test_set_of_sets_reprsnsq��4:�
�.�}�}�!�!�!�$���������-�}�=�\d�
�|�}�}�&�&�t�,���������-�}�=r
c�J�d}dddddddiiiiii}ddddddggggggg}|jtj|�t|��|jtj|�t|��|jtj|�t|��d}d	}d
}|jtj|d��|�|jtj|d��|�|jtj|d��|�y)N)rI)r�)r�)r�)r�r�rIr�r�r�r�r�z
(1, (...))z
{1: {...}}z
[1, [...]]r�)r�r�r�rK)r�nested_tuple�nested_dict�nested_list�	lv1_tuple�lv1_dict�lv1_lists       r�
test_depthzQueryTestCase.test_depthBs��1���1�q�1�q�1�a�&�k�"2�3�4�5���1�q�1�q�1�b�'�l�"3�4�5�6���������5�t�L�7I�J��������4�d�;�6G�H��������4�d�;�6G�H� �	������������A�>�	�J��������1�=�x�H��������1�=�x�Hr
c
���d}t|�D�cgc]}t���}}tj|�t	|t
��}d�}|j
|tjt|���ddjtt|��zdz�|j
|tjt|���ddjtt|��zdz�|j
|tjtj|���ddjd	�|D��zdz�|j
tjtd
dd
i�dtt�zd
z�ddg}|j
tjtj|d
��dt!t	|t
���z�ycc}w)NrD)�keyc�F�|jdd�jdd�S)Nr�r�r�)r�)�ss r�<lambda>z<QueryTestCase.test_sort_unorderable_values.<locals>.<lambda>Ws��!�)�)�C��,�4�4�T�"�=r
�{�,�}zfrozenset({z})c3�&K�|]	}d|z���y�w)z%r:NoneNr	)�.0�ks  r�	<genexpr>z=QueryTestCase.test_sort_unorderable_values.<locals>.<genexpr>^s����8�%�Q�9�q�=�%�s�rrIz{1: 0, z: 0})rIrz{%r: 0, %r: 0})r�rf�random�shuffle�sortedrhr�r�r�r.r�r�rKr7r@rr%)r�n�i�keys�skeys�cleans      r�test_sort_unorderable_valuesz*QueryTestCase.test_sort_unorderable_valuesQs�����',�Q�x�0�x�!��
�x��0����t���t��$��=������v�~�~�c�$�i�8�9��#�(�(�3�t�U�+�,�,�s�2�	4�����v�~�~�i��o�>�?��C�H�H�S��u�%5�6�6��=�	?�����v�~�~�d�m�m�D�.A�B�C��#�(�(�8�%�8�8�8�3�>�	@�	
�������a��A�(>�?�"�T�+�%6�6��>�	@��g����������
�
�d�A�(>�?�)�E�&��2�2F�,G�G�	I��%1s�G-c�<�t�}tt|��}|j||�|jt	t|��t	t|���|j
t||g�||g�|j
t||g�||g�|j
tjt||g�d��d|�d|�d��|j
tjt||g�d��d|�d|�d��|j
tjtj||g�d��d|�d|�d��|j
tjtj||g�d��d|�d|�d��y)NrIr�rmr�roz	: None,
 z: None})
rfrjrn�
assertLessrMr�r�rvr�r�r.r@r)rrUr\s   r�*test_sort_orderable_and_unorderable_valuesz8QueryTestCase.test_sort_orderable_and_unorderable_valuesis3���M���d�1�g�������1������D��G��c�$�q�'�l�3������A���!�Q��0������A���!�Q��0��������Q��F��1�=�)*�A�.�	0��������Q��F��1�=�)*�A�.�	0�	
�������
�
�q�!�f�(=�Q�G�56��:�	<��������
�
�q�!�f�(=�Q�G�56��:�	<r
c�f�d}|jtj|d��d�|jtjd|dd�d��d	�d
}|jtj|d��t|��|jtj|d��d
�|jtj|d��d�|jtj|gggggd��d�|jtj|gggggd��d�|jtj|gggggd��d�d}|jtj|d��t|��|jtjd�d�|dz}t	dd�D]n}tj||��}|jt|�|�tj|gdz|��}|jt|�|gdz��py)Nr�r��6('the quick brown '
 'fox jumped over '
 'a lazy dog')rIr�rr�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')rDuV('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�r�r�)r�r�r�rKr�r�)rr+�special�unwrappabler�r"s      r�
test_str_wrapzQueryTestCase.test_str_wrap}s���:���������2�6�9�	�	
������a�c��(B�.0�2�4�	
�Y���������r�:�D��M�J��������r�:�=�	�	
�������r�:�=�	�	
������W�I�;�-��(9��D�G�	�	
������W�I�;�-��(9��D�G�	�	
������W�I�;�-��(9��D�G�	� ���������2�>��[�@Q�R��������+�T�2��2�
���1�b�\�E����w�e�<�I����T�)�_�g�6�����y�1�}�E�B�I����T�)�_�w�i�!�m�<�	"r
c	� �td�D�cgc]}tt||z����c}td�D�cgc]}tt|����c}z}d}|jtj|dd��|�ycc}wcc}w)Nr�r�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�r�r�)r�rr�r�r�)rrxr�r�s    r�test_compactzQueryTestCase.test_compact�sx��*/��(�
3�(�Q�d�5��Q��<� �(�
3�&+�A�h�
/�h��d�5��8�n�h�
/�0����	
��������T�B�H�M��4��
/s
�B�Bc�P�d}d}dg|z}t|dz
�D]}|g}�t|dzdz|d|zzdz
�D]h}tj||d��j�}t	tt|��}|j||�|j||dz
��jy)	NrDr�rrIr�r�Tr�)	r�r�r��
splitlines�maxr�r�assertLessEqual�
assertGreater)r�levels�numberr�rx�w�lines�maxwidths        r�test_compact_widthz QueryTestCase.test_compact_width�s�������
�C�&�L���v��z�"�A���A�#��v��z�A�~�v��F�
�':�Q�'>�?�A��N�N�1�A�t�<�G�G�I�E��3�s�E�?�+�H�� � ��1�-����x��Q��/�	@r
c��|jtjdd��d�|jtjdd��d�d}|jtj|d��t|��|jtj|d	��d
�|jtj|d��d�|jtj|d
��d�t	td
��}|jtj|d��t|��|jtj|d��d�|jtj|d��d�|jtj|d��d�|jtjd|dd�d��d�|jtjd|dd�d��d�|jtj|ggggggd��d�|jtj|ggggggd��d�tdd�D]n}tj||��}|jt
|�|�tj|gdz|��}|jt
|�|gdz��py)Nr
rIr�zb''sabcdzb'abcd'�abcdefghijklmnopqrstuvwxyz�r�z$(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')r�r�zJ{'a': 1,
 'b': b'abcdefghijkl'
      b'mnopqrstuvwx'
      b'yz',
 'c': 2}rDzJ{'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�r�r�rK�bytesr�r�)r�lettersr�r�r"s     r�test_bytes_wrapzQueryTestCase.test_bytes_wrap�ss���������1�5�u�=��������q�9�9�E�/���������r�:�D��M�J��������r�:�=�	�	
�������r�:�=�	�	
�������r�:�=�	���b�	�"���������r�:�D��M�J��������r�:�=�	�	
�������r�:�=�	�	
�������q�9�<�	�
	
������a�g�A�(F�.0�2�4�	
�	
������a�g�A�(F�.0�2�4�	
�	
������g�Y�K�=�/�):�(;�2�F�I�	�	
������g�Y�K�=�/�):�(;�2�F�I5�	6��1�b�\�E����w�e�<�I����T�)�_�g�6�����y�1�}�E�B�I����T�)�_�w�i�!�m�<�	"r
c�:�|jtjt�d��d�td�}|jtj|d��t	|��|jtj|d��d�|jtj|d��d	�|jtj|d
��d	�ttd��}|jtj|d��t	|��|jtj|d
��d�|jtj|d��d�|jtj|d��d�|jtjd|dd�d��d�|jtj|gggggd��d�|jtj|gggggd��d�y)NrIr�zbytearray(b'')r�r��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')r�rr�zi{'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�r�r�r�rKr�)rr�r�s   r�test_bytearray_wrapz!QueryTestCase.test_bytearray_wrap
s���������	��1�=�?O�P��9�:���������r�:�D��M�J��������r�:�= �	!�	
�������r�:�=�	�	
�������r�:�=�	��E�"�I�&���������r�:�D��M�J��������r�:�=$�	%�	
�������r�:�=$�	%�	
�������q�9�<$�	%�
	
������a�g�A�(F�.0�2�4�	
�	
������W�I�;�-��(9��D�G&�	'�	
������W�I�;�-��(9��D�G>�	?r
c�Z�tjt�}|jt	j
|d��d�dj
�}tjtt|tj���}|jt	j
|�d�y)NrIr�zdefaultdict(<class 'int'>, {})rz�defaultdict(<class 'int'>,
            {'a': 6,
             'brown': 2,
             'dog': 8,
             'fox': 3,
             'jumped': 4,
             'lazy': 7,
             'over': 5,
             'quick': 1,
             'the': 0}))
r�defaultdictrOr�r�r�rr�rrrs   r�test_default_dictzQueryTestCase.test_default_dict5sz���#�#�C�(����������3�5U�V�<�B�B�D���#�#�C��U�I�O�O�4E�)F�G���������*�
�	r
c���tj�}|jtj|d��d�tjd�}|jtj|d��d�y)NrIr�z	Counter()�
senselessnessr�zDCounter({'s': 6,
         'e': 4,
         'n': 2,
         'l': 1}))r�Counterr�r�r�rs  r�test_counterzQueryTestCase.test_counterGs[�����!����������3�[�A�����0����������4��	r
c��tj�}|jtj|d��d�dj�}t
t|tj���}tjt|��}|jtj|�d�tjt|�tj|��}|jtj|�d�y)NrIr�zChainMap({})rz�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�r�r�rrr�rrr@r)rrdr�itemss    r�
test_chainmapzQueryTestCase.test_chainmapRs���� � �"����������3�^�D�<�B�B�D���S��	��� 1�2�3��� � ��e��-���������*�	�
	�
� � ��e��k�.E�.E�e�.L�M���������*�'�	(r
c�p�tj�}|jtj|d��d�tjd��}|jtj|d��d�dj�}tjt
|tj���}|jtj|�d�tjt
|tj��d��}|jtj|�d	�y)
NrIr�z	deque([])r�)�maxlenzdeque([], maxlen=7)rz�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�r�r�rr�rrrs   r�
test_dequezQueryTestCase.test_dequeys����������������3�[�A����Q�'����������3�5J�K�<�B�B�D�����c�%����):�;�<���������*�	�
	�
���c�%����):�;�A�F���������*��		r
c�F�tj�}|jtj|d��d�dj�}tjt
|tj���}|jtj|�d�y)NrIr�z{}rzi{'a': 6,
 'brown': 2,
 'dog': 8,
 'fox': 3,
 'jumped': 4,
 'lazy': 7,
 'over': 5,
 'quick': 1,
 'the': 0})	r�UserDictr�r�r�rr�rrrs   r�test_user_dictzQueryTestCase.test_user_dict�su��� � �"����������3�T�:�<�B�B�D��� � ��U�I�O�O�,=�!>�?���������*�	�
	r
c�F�tj�}|jtj|d��d�dj�}tjt
|tj���}|jtj|�d�y)NrIr�z[]rz{[('the', 0),
 ('quick', 1),
 ('brown', 2),
 ('fox', 3),
 ('jumped', 4),
 ('over', 5),
 ('a', 6),
 ('lazy', 7),
 ('dog', 8)])	r�UserListr�r�r�rr�rrrs   r�test_user_listzQueryTestCase.test_user_list�su��� � �"����������3�T�:�<�B�B�D��� � ��U�I�O�O�,=�!>�?���������*�	�
	r
c�F�tjd�}|jtj|d��d�tjd�}|jtj|d��d�|jtjd|id��d�y)	Nr�rIr�r�rrDr�zF{1: 'the quick '
    'brown fox '
    'jumped over a '
    'lazy dog'})r�
UserStringr�r�r�rs  r�test_user_stringzQueryTestCase.test_user_string�s����"�"�2�&����������3�T�:��"�"�#O�P����������4��	�
	
�������A��b�9��	r
N)5rrrr�r�r�r�r�r�r�r�r�r�r�rr	r
rrr#r%r1r6r<r@rBrErHrJrNrTrV�unittest�expectedFailurerX�support�cpython_onlyr_rgr|rr�r�r�r�r�r�r�r�r�r�r�r�r	r
rr�r�~s$���
E�D�"1�D�B
O�!>�F>�4"E�H
J�$�L
J�4�$V��&,�63�
;�
�0�25�
[�
	!�X�
T�
�	�;�&*>�X���	�\�\���O>���O>�b
I�I�0<�(:=�x
N�
0�7=�r)?�V�$	�%(�N�<�"�"r
r�c��eZdZd�Zy)rPc��t|t�rd|vrt|�ddfS|ddfStjj|||||�S)Nr�rIr)�
isinstancerMrKr�r��format)rr��context�	maxlevels�levels     rr�zDottedPrettyPrinter.format�sT���f�c�"��f�}��F�|�Q��)�)��q�!�|�#��'�'�.�.��f�g�y�%�9�
9r
N)rrrr�r	r
rrPrP�s��9r
rP�__main__)/rr�rQr�rr�rt�test.supportrX�
test.test_setrr�rrrrr%r!r#r'r.r*r,r0r7r3r5r9r@r<r>rB�	dataclassrErTrYr[r`rarfrj�TestCaser�r�rPr�mainr	r
r�<module>r�s������	��
�
�����	�D�	�#�D�#�,�t�,�	�U�	�$�U�$�-��-�	�3�	�"�3�"�+�c�+�	��	�(��(�1�I�1�	�D�	�#�D�#�,�t�,�
���;�;��;�
���B�B��B�
����E�"���#��
�������
�������
���������
��$I�H�%�%�I�X"
9�&�.�.�
9��z���H�M�M�O�r

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