✘✘ GRAYBYTE WORDPRESS FILE MANAGER ✘✘

�
f fhw�@s�
dd
lZdd
l
Zdd
lZdd
lZdd
lZdd
lZdd
lZGdd�de�Z	Gdd�de�Z
Gdd�de�ZGdd	�d	e�Z
Gd
d�de�ZGdd
�d
e�ZGdd�de�ZGdd�de�ZGdd�de�ZGdd�de�ZGdd�d�ZGdd�dej�ZGdd�dej�Zedkr�
ej�
nd
S)�Nc
@seZ
dZd
S)�list2N)�__name__�
__module__�__qualname__�rr�5/opt/alt/python34/lib64/python3.4/test/test_pprint.pyrs
rc@seZ
dZd
d�ZdS)�list3c

Cs
tj
|�
S)
N)�list�__repr__)
�selfrrrr
s
zlist3.__repr__N)rrrr
rrrrrs
rc
@seZ
dZd
S)�tuple2N)rrrrrrrrs
rc@seZ
dZd
d�ZdS)�tuple3c

Cs
tj
|�
S)
N)�tupler
)
rrrrr
s
ztuple3.__repr__N)rrrr
rrrrr
s
r
c
@seZ
dZd
S)�set2N)rrrrrrrrs
rc@seZ
dZd
d�ZdS)�set3c

Cs
tj
|�
S)
N)�setr
)
rrrrr
s
z
set3.__repr__N)rrrr
rrrrrs
rc
@seZ
dZd
S)�
frozenset2N)rrrrrrrr!s
rc@seZ
dZd
d�ZdS)�
frozenset3c

Cs
tj
|�
S)
N)�	frozensetr
)
rrrrr
%s
zfrozenset3.__repr__N)rrrr
rrrrr$s
rc
@seZ
dZd
S)�dict2N)rrrrrrrr(s
rc@seZ
dZd
d�ZdS)�dict3c

Cs
tj
|�
S)
N)�dictr
)
rrrrr
,s
zdict3.__repr__N)rrrr
rrrrr+s
rc@seZ
dZd
d�ZdS)�Unorderablec

Cstt
|�
�
S)
N)�str�id)
rrrrr
0s
zUnorderable.__repr__N)rrrr
rrrrr/s
rc@s�eZ
dZd
d�Zdd�Zdd�Zdd�Zd	d
�Zdd�Zd
d�Z	dd�Z
dd�Zdd�Zdd�Z
ejejjdd��
�
Zdd�Zdd�Zdd�Zdd �Zd!S)"�
QueryTestCasec

Cs>tt
d
�
�
|_tt
d�
�
|_|j|jd<dS)N�d���i�)r	�range�
a�
b)
rrrr�setUp5s


zQueryTestCase.setUpc
Cs�tj
�}
x�d
ddddg
d
i
dd6dtd�
dd	dd
|j|jfD]�}|jtj|�
d|f
�
|jtj|�
d|f
�
|j|
j|�
d|f
�
|j|
j|�
d|f
�
qVWdS)N�g@y@�abc�sdefsghiTF.zexpected not isrecursive for %rzexpected isreadable for %r)r#r#)	�pprint�
PrettyPrinter�	bytearrayr r!�assertFalse�isrecursive�
assertTrue�
isreadable)r�pp�saferrr�
test_basic:s
%







zQueryTestCase.test_basicc
Cs�
|j|j
d
<i|_|j|jd<|jd<|jd<tj�}
x�|j|j
|j|j|jffD]j}|jtj|�
d�
|jtj|�
d�
|j|
j|�
d�
|j|
j|�
d�
qsW|jj	�
|jdd�=|j
dd�=x�|j|j
|j|j|jffD]�}|jtj|�
d|f
�
|jtj|�
d|f
�
|j|
j|�
d|f
�
|j|
j|�
d|f
�
q6
WdS)	N�Cr
�
r#zexpected isrecursivezexpected not isreadablezexpected not isrecursive for %rzexpected isreadable for %r)
r r!�
dr&r'r+r*r)r,�clear)rr-Zickyr.rrr�test_knottedKs*	
&.






.





zQueryTestCase.test_knottedc
Cs�tj
�}
x�td
�
ttjfD]�}|jtj|�
d|f
�
|jtj|�
d|f
�
|j|
j|�
d|f
�
|j|
j|�
d|f
�
q%WdS)Nr%zexpected not isrecursive for %rzexpected not isreadable for %r)r&r'�typer*r)r,)rr-Z
unreadablerrr�test_unreadablels






zQueryTestCase.test_unreadablec
9Csx
d
d
ddddt�ft
�t�gt�t�t�t�t�t�t	�t
�it�t�|j
tddd d!d	d
td
�
d"dg
i
dd6d#ddgi
dd6t
d$�
td%�
ttd�
�
ddgtddg�
tddg�
ttd�
�
tdh
�
tdh
�
tdh
�
tdh
�
t	dh
�
t
dh
�
ti
dd6�
ti
dd6�
tdd&d'�ddddf9D]u}
t|
�
}|jtj|
�
|�
|jtj|
dddd
�
jdd�|�
|jtj|
�
|�
q�
WdS)(Nr
yg���y@g�?�
x�
xr%r1r#��r���
�TF.�width�indent�

�
 yi����i����i����y��g��)
r%)r1r#)r1r#)r1r#i�������)r(rr
rrrrrrrrrrr+r&r�repr�assertEqual�pformat�replaceZsaferepr)rZsimpleZnativerrr�test_same_as_repr{s,	





	



!
6
$
$
 



!

zQueryTestCase.test_same_as_reprc
Cs�
id
d6dd6d
d6d
d6d
d6d
d6d	d
6}
d}x3tt
gD]%}|jtj||
�
�
|�
qJWtd�
}
d
djtt|
��
}x3t	t
gD]%}|jtj||
�
�
|�
q�Wttd�
�
}
ddjtt|
��
}x3ttgD]%}|jtj||
�
�
|�
q
Wtd�
}
ddjtt|
��
}x9t	t
gD]+}|jtj||
�
dd�

|�
qj
WdS)Nr
ZRPM_cali��ZRPM_cal2Z	Speed_calZcontroldesk_runtime_usZmain_code_runtime_usZread_io_runtime_usi��Zwrite_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}rz[%s]z,
 z(%s)z[   %s]z,
    rCr<)
rrrHr&rIr�join�maprr	rrr)r�
o�expr5rrr�test_basic_line_wrap�s,









#


#


#


z"QueryTestCase.test_basic_line_wrapc
Cshtt
d
�
�
}
tdddddd�}|
|g}d}|jtj|d	d
dd�
|�
dS)
Nr@�firstr1�secondr#Zthirdr%za[   [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
    {   'first': 1,
        'second': 2,
        'third': 3}]rCr<rB�*)r	rrrHr&rI)rZo1Zo2rN�expectedrrr�test_nested_indentations�s




z&QueryTestCase.test_nested_indentationsc
Cs�id
d6d
d6d
d6}
|jt
j|
�
d�
|jt
j|
|
g�
d�
|jt
jidd6gg
d	6if6�
d
�
dS)Nr1r r!�
cz{'a': 1, 'b': 1, 'c': 1}z4[{'a': 1, 'b': 1, 'c': 1}, {'a': 1, 'b': 1, 'c': 1}]r%zxy	ab
r=z#{5: [[]], 'xy\tab\n': (3,), (): {}})
r%)rHr&rI)rr2rrr�test_sorted_dict�s


*
zQueryTestCase.test_sorted_dictc
CsGd
j�}
t
jt|
tj���
}|jtj|�
d�
dS)Nz*the quick brown fox jumped over a lazy dogzi{'the': 0,
 'quick': 1,
 'brown': 2,
 'fox': 3,
 'jumped': 4,
 'over': 5,
 'a': 6,
 'lazy': 7,
 'dog': 8})	�split�collections�OrderedDict�zip�	itertools�countrHr&rI)rZwordsr2rrr�test_ordered_dict�s



zQueryTestCase.test_ordered_dictc
Cs:id
d6dd6}
d}|jt
�j|
�
|�
dS)Nz should be presented using repr()znames with spacesz	like.thiszothers.should.not.bez[{'names with spaces': 'should be presented using repr()',
 others.should.not.be: like.this})rH�DottedPrettyPrinterrI)rrNrOrrr�test_subclassing�s




zQueryTestCase.test_subclassingc

Cs�
|jt
jt��
d
�
|jt
jttd�
�
�
d�
|jt
jttd�
�
dd�

d�
|jt
jttd�
�
dd�

d�
|jt
jttd�
�
dd�

d	�
|jt
jt��
d
�
|jt
jttd�
�
�
d�
|jt
jttd�
�
dd�

d�
|jt
jttd�
�
dd�

d
�
|jt
jt	td�
�
dd�

d�
dS)Nzset()r%z	{0, 1, 2}r>rB�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}))
rHr&rIrrrrrrr)
rrrr�test_set_reprs�s"

%
$
$
$



$
$
$
zQueryTestCase.test_set_reprsc
Csfd
}
tj
jd�
}|jtj|�
|
�
d}tj
j|�
}|jtj|�
|�
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})})}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})})})})�testZtest_set�cuberHr&rIZ	linegraph)rZ
cube_repr_tgtrdZ
cubo_repr_tgtZcuborrr�test_set_of_sets_reprs
s0

�
z$QueryTestCase.test_set_of_sets_reprsc
Cs0
d}
i
i
i
i
i
i
dd6d6d6d6d6d
6}d
dddddggggggg}|jt
j|
�
t|
�
�
|jt
j|�
t|�
�
|jt
j|�
t|�
�
d}d}d	}|jt
j|
d
d
�

|�
|jt
j|d
d
�

|�
|jt
j|d
d
�

|�
dS)Nr1r#r%r<r=r9z
(1, (...))z
{1: {...}}z
[1, [...]]Zdepth�r=r9�r<rf�r%rg�r#rh)r1ri)rHr&rIrG)rZnested_tupleZnested_dictZnested_listZ	lv1_tupleZlv1_dictZlv1_listrrr�
test_depth�
s

0
*







zQueryTestCase.test_depthc
Cs�
d
}
dd�t|
�
D�
}t
j|�

t|dt�

}dd�}|j|tjt|�
�
�
ddj	t
t|��
d	�
|j|tjt|�
�
�
d
dj	t
t|��
d�
|j|tjt
j|�
�
�
ddj	dd
�|D�
�
d	�
|jtjidt6dd6�
dtt�
d�
ddg}|jtjt
j|d��
dtt|dt�

�
�
dS)Nrac
Ssg|]}
t��qSr)
r)�.0�
irrr�
<listcomp>s	z>QueryTestCase.test_sort_unorderable_values.<locals>.<listcomp>�keyc

Ss|jd
d�jdd�S)NrEr7rD)
rJ)
�
srrr�<lambda>sz<QueryTestCase.test_sort_unorderable_values.<locals>.<lambda>�
{�
,�
}zfrozenset({z})c
ss|]}
d|
V
qd
S)z%r:NoneNr)rk�
krrr�	<genexpr>sz=QueryTestCase.test_sort_unorderable_values.<locals>.<genexpr>r
r1z{1: 0, z: 0}z{%r: 0, %r: 0})
r1)
N)r�randomZshuffle�sortedrrHr&rIrrLrMrGrr�fromkeysrr)r�
n�keysZskeysZcleanrrr�test_sort_unorderable_valuess 





!

!
!
% 


z*QueryTestCase.test_sort_unorderable_valuesc
CsR
d
}
|jt
j|
dd�

d�
|jt
jidd6|
d6dd	6dd
�

d�
d}|jt
j|dd
�

d�
dd}|jt
j|dd�

t|�
�
|jt
jd�
d�
|d9}x{tdd�D]j}t
j|d|�

}|jt|�
|�
t
j|g
dd|�

}|jt|�
|g
d�
q�WdS)Nz*the quick brown fox jumped over a lazy dogrBraz:('the quick '
 'brown fox '
 'jumped over a '
 'lazy dog')r1r r!r#rV�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�uV('Portons dix '
 'bons "whiskys"\n'
 "à l'avocat "
 'goujat\t qui '
 'fumait au zoo')r:r�Pr7z''r@r%�()rHr&rIrGr�eval)rZfoxZspecialZunwrappablerBZ	formattedrrr�
test_str_wraps$

'



%






zQueryTestCase.test_str_wrapc
Cs_d
d�td�
D�
dd�td�
D�
}
d}|j
tj|
ddd	d
�
|�
dS)Nc
Ss&g|]}
tt
|
|
�
�
�qSr)r	r)rkrlrrrrmBs	z.QueryTestCase.test_compact.<locals>.<listcomp>r=c
Ss"g|]}
tt
|
�
�
�qSr)r	r)rkrlrrrrmCs	r9z�[[], [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]]rB�0ZcompactT)rrHr&rI)rrNrTrrr�test_compactAs


zQueryTestCase.test_compactN)rrrr"r/r4r6rKrPrUrWr^r`rb�unittestZexpectedFailurercZsupportZcpython_onlyrerjr{r�r�rrrrr3s"!!$,�'rc@seZ
dZd
d�ZdS)r_cCs^t|
t
�r>d
|
kr.t|
�
ddfS|
ddfSntjj||
|||�SdS)NrEr1r
)�
isinstancerrGr&r'�format)r�object�contextZ	maxlevels�levelrrrr�Ps


	
zDottedPrettyPrinter.formatN)rrrr�rrrrr_Nsr_�__main__)r&Ztest.supportrcr�Z
test.test_setrvrYr\r	rrrrr
rrrrrrrrrrZTestCaserr'r_r�mainrrrr�<module>s.





��