✘✘ GRAYBYTE WORDPRESS FILE MANAGER ✘✘

a

XC?h�;�@s.dZd
dl
Z
d
dlZd
dlZd
dlmZmZmZmZm	Z	m
Z

d
dlTd
dlm
Z

d
dlmZ
d
dlmZmZ
d
dlmZmZ
d
d	lmZ
d
d
lmZmZmZ
d
dlmZmZ
zd
dlZWne y�


dZYn0d
dl!m"Z"
d
d
l#m$Z$
d
dl%m&Z&
d
dl'm(Z(
d
dl)m*Z*
d
dl+m,Z,
d
dl-m.Z.
zd
dl/m0Z0
Wne �
yL


dZ0Yn0d
dl1m2Z3
d
dl4m5Z5
d
dl6m7Z7m8Z8
d
dl9m:Z:m;Z;m<Z<
d
dl=m>Z>m?Z?
d
dl@mAZAmBZB
d
dlCmDZD
d
dlEmFZFm2Z2
d
dlGmHZHmIZImJZJ
d
dlKZKd
dlKmLZL
eLd�
ZMeLd�
ZNeLd �
ZOGd!d"�d"e
jP�ZQeRd#k�r*e
�S�
dS)$z%Tests for C-implemented GenericAlias.�N)�defaultdict�deque�OrderedDict�Counter�UserDict�UserList)
�
*)
�Future)
�	_WorkItem)�AbstractContextManager�AbstractAsyncContextManager)�
ContextVar�Token)
�Field)�partial�
partialmethod�cached_property)�Mailbox�_PartialFile)
�SequenceMatcher)
�dircmp)
�	FileInput)
�chain)
�Morsel)
�
ValueProxy)
�ApplyResult)
�
ShareableList)
�SimpleQueue)
�DirEntry)�Pattern�Match)�GenericAlias�MappingProxyType�AsyncGeneratorType)�TemporaryDirectory�SpooledTemporaryFile)�SplitResult�ParseResult)
�_AssertRaisesContext)�Queuer)�WeakSet�
ReferenceType�ref)
�TypeVar�
T�
K�
VcF@s�
eZ
dZd
Zeeeeee	e
eee
eeeeeeeeeeeeeeeeeee e!e"e#e$e%e&e'e(e)e*e+e,e-e.e/e0e1e2e3e4e5e6e7e8e9e:e;e<e=e>e?e@eAeBeCeDeEeFeGeHeIgFZJeKdu
r�eJ�LeKjMeKjNf�

dd�ZOdd�ZPdd�ZQd	d
�ZRdd�ZSd
d�ZTdd�ZUdd�ZVdd�ZWdd�ZXdd�ZYdd�ZZdd�Z[dd�Z\dd �Z]d!d"�Z^d#d$�Z_d%d&�Z`d'd(�Zad)d*�Zbd+d,�Zcd-d.�Zdd/d0�Zed1d2�Zfd3d4�Zgd5d6�ZhdS)7�BaseTestzTest basics.Nc
	Cs�|jD]x}
|
durq|
j
}|�d
|���
�D
|
t}|�|j|
�
|�|jtf
�
|�|jd�
Wd�
q1st0


Y
qdS)N�Testing �)	�
generic_types�__name__�subTest�int�assertIs�
__origin__�assertEqual�__args__�__parameters__��self�
t�tname�aliasr3r3�;/opt/alt/python39/lib64/python3.9/test/test_genericalias.py�test_subscriptableXs









zBaseTest.test_subscriptablec

Cs�tt
tttfD]l}
|
j}|�d
|���
�B
|�t�
�
|
t
Wd�
n1sR0


Y
Wd�
q1sp0


Y
qdS�Nr2)	r7�str�float�Sized�Hashabler5r6�assertRaises�	TypeError)r>r?r@r3r3rB�test_unsubscriptablecs





zBaseTest.test_unsubscriptablec
	Cs�tt
tttttfD]�}
|
j}|�d
|���
��
|
t	}|�
|�|
��
|
tur�|�
|tddg�
�
tddd��
|�
|ddd�tddd��
nN|
tur�dd�}||�
}t|�
}|�
|d	|d	�
n|�
|td
�
�
|
d
�
�
Wd�
q1s�0


Y
qdS)Nr2)�
a�
)�
b�rMrO)rLrNc
Ssd
S)N�valuer3r3r3r3rB�defaultts
z*BaseTest.test_instantiate.<locals>.default�test)rMrO�)�tuple�list�dict�set�	frozensetrrr5r6r7r:�iter)r>r?r@rArQrL�
dr3r3rB�test_instantiatejs






 




zBaseTest.test_instantiatec
CsVtt
}
|
�}|
�|d
�
|�|d
g
�
|
�|d�}|�|d
�
|�|
�|�
d�
dS)NZfoor
rM)rUr7�appendr:�__getitem__�__len__)r>r?rL�
xr3r3rB�test_unbound_methods|s






zBaseTest.test_unbound_methodsc
Cs6Gd
d�dtt
�}
|�|
jtf
�
|�|
jt�
dS)Nc
@seZ
dZd
S)z$BaseTest.test_subclassing.<locals>.CN�r5�
__module__�__qualname__r3r3r3rB�
C�s
rd)rUr7r:�	__bases__�	__class__�type)r>rdr3r3rB�test_subclassing�s

zBaseTest.test_subclassingc
CsHtt
df}
|�t�td
�
�
ddd��
|�|
�td
�
�
ddd��
dS)NrO)r
rM)rVr7r:�fromkeys�range�r>r?r3r3rB�test_class_methods�s


zBaseTest.test_class_methodsc
Cs>tt
}
|�t�
�
|
t

Wd�
n1s00


Y
dS�
N)rUr7rIrJrkr3r3rB�test_no_chaining�s


zBaseTest.test_no_chainingc
CsHGd
d�dt�}
|
t
}|�|j|
�
|�|jt
f
�
|�|jd�
dS)Nc
@seZ
dZd
S)z.BaseTest.test_generic_subclass.<locals>.MyListNrar3r3r3rB�MyList�s
ror3)rUr7r8r9r:r;r<)r>ror?r3r3rB�test_generic_subclass�s




zBaseTest.test_generic_subclassc
Cs�Gd
d�dt�}
|�
ttt�
d�
|�
ttd�
d�
|�
tttdf�
d�
|�t|
t�
�d�
�

|�
ttt��
d	�
dS)
Nc
@seZ
dZd
S)z"BaseTest.test_repr.<locals>.MyListNrar3r3r3rBro�s
roz	list[str]r3zlist[()].ztuple[int, ...]z(.BaseTest.test_repr.<locals>.MyList[int]z[])rUr:�reprrErTr7�
assertTrue�endswith)r>ror3r3rB�	test_repr�s




zBaseTest.test_reprc
CsTd
dl}
|
�
tt�}|�t|�
d�
|�|jt�
|�|jtf
�
|�|j	d�
dS)Nr
z	list[int]r3)
�typesr!rUr7r:rEr8r9r;r<)r>rurLr3r3rB�test_exposed_type�s





zBaseTest.test_exposed_typec
Cs`d
dlm
}
m}m}
tttf}|�|jttf�
|�|j	d�
ttt
f}|�|jtt
f�
|�|j	t
f
�
tttf}|�|jttf�
|�|j	tf
�
ttt
f}|�|jtt
f�
|�|j	tt
f�
tttf}|�|jttf�
|�|j	tf
�
t
t}	|�|	jtf
�
|�|	j	d�
t
t}
|�|
jtf
�
|�|
j	tf
�
t
t
t}|�|jt
tf
�
|�|j	tf
�
t
|
t}|�|j|
tf
�
|�|j	tf
�
t
|tt
f}
|�|
j|tt
ff
�
|�|
j	tt
f�
t
|ttf}|�|j|ttff
�
|�|j	tf
�
t
|tt
gtf}|�|j|tt
gtff
�
|�|j	tt
f�
dS)Nr
)�List�Dict�Callabler3)�typingrwrxryrVrEr7r:r;r<r0r/r.rU)r>rwrxryZD0ZD1aZD1bZD2aZD2bZL0ZL1ZL2ZL3ZL4aZL4bZL5r3r3rB�test_parameters�sJ




































zBaseTest.test_parametersc
Cs�d
dlm
}
m}m}m}
|�ttttt�
|�t	t
tftt	t
tf�
|�t	ttft
t	t
tf�
|�t	ttft
tft	t
tf�
|�t	ttftt	ttf�
|�ttttttt�
|�tt	ttft
tt	t
tf�
|�tt	t
tfttt	t
tf�
|�tt	ttft
tftt	t
tf�
|�t	tttft
t	t
ttf�
|�t|
ttt|
t�
|�t|ttft
tft|t
tf�
|�t|ttft
tft|t
tf�
|�t|ttgtft
tft|t
tgt
f�
|�t	t|
tft
t	t
|
tf�
|�
t�
�X
ttt
t	ttft
tf
t	t
tft
tf
t	ttft
tf
Wd�
n1�s�0


Y
dS)Nr
)rwrx�Unionry)rzrwrxr|ryr:rUr.r7rVrEr/r0rIrJ)r>rwrxr|ryr3r3rB�test_parameter_chaining�s.


 
 
$
  
(
(
,
( 
,
,

�(



z BaseTest.test_parameter_chainingc

Csp|�t
tt
t�
|�tttftttf�
|�tttftttf�
|�t
t
t�
|�t
tt
�
dSrm)r:rUr7rVrEZassertNotEqual�
r>r3r3rB�
test_equality�s





zBaseTest.test_equalityc

CsL|�t
gt��

|�t�
�
t
gtt�
Wd�
n1s>0


Y
dSrm)rr�
isinstancerUrIrJrEr~r3r3rB�test_isinstance�s


zBaseTest.test_isinstancec
Cs\Gd
d�dt�}
|�
t|
t��

|�t�
�
t|
tt�
Wd�
n1sN0


Y
dS)Nc
@seZ
dZd
S)z#BaseTest.test_issubclass.<locals>.LNrar3r3r3rB�
L��r�)rUrr�
issubclassrIrJrE)r>r�r3r3rB�test_issubclass�s



zBaseTest.test_issubclassc
CsNtt
}
|
d
di�}|�t|t��

|�}|�|
|�
|�
|�|
d�
t
�
dS)N�Testr3r
)rgr7rrr�r:)r>r?r�rRr3r3rB�test_type_generic
s





zBaseTest.test_type_genericc
CsFGd
d�dt�}
|�
t�
�
|
t
Wd�
n1s80


Y
dS)Nc
@seZ
dZd
S)z3BaseTest.test_type_subclass_generic.<locals>.MyTypeNrar3r3r3rB�MyType
s
r�)rgrIrJr7)r>r�r3r3rB�test_type_subclass_generic

s

z#BaseTest.test_type_subclass_genericc
Cshtt
t�}
ttjd
�
D]J}t�|
|�}t�|�
}|�|j	|
j	�
|�|j
|
j
�
|�|j|
j�
qdS)NrM)r!rUr.rj�pickleZHIGHEST_PROTOCOL�dumps�loadsr:r9r;r<)r>rA�proto�
s�loadedr3r3rB�test_pickle
s








zBaseTest.test_picklec
Cs�Gd
d�dt�}
tt
|
fD]�}t|t�}t�|�
}|�|j|j�
|�|j|j�
|�|j|j�
t�	|�
}|�|j|j�
|�|j|j�
|�|j|j�
qdS)Nc@seZ
dZd
d�Zdd�ZdS)zBaseTest.test_copy.<locals>.Xc


Ss|Srmr3r~r3r3rB�__copy__
s
z&BaseTest.test_copy.<locals>.X.__copy__c
Ss|Srmr3)r>�memor3r3rB�__deepcopy__
s
z*BaseTest.test_copy.<locals>.X.__deepcopy__N)r5rbrcr�r�r3r3r3rB�
X
s
r�)
rUrr!r.�copyr:r9r;r<Zdeepcopy)r>r��originrAZcopiedr3r3rB�	test_copy
s












zBaseTest.test_copyc
CsBtj
ttttf}
|�|
jttttf�
|�|
jd
�
dS)Nr3)rzr|rUr7rEr:r;r<�r>rLr3r3rB�
test_union+
s


zBaseTest.test_unionc
CsLtj
ttttd
ff}
|�|
jttttd
ff�
|�|
jtf
�
dS)N.)rzr|rUr.rTr:r;r<r�r3r3rB�test_union_generic0
s


zBaseTest.test_union_genericc
Cs>tt
tt�
�
}
|�|
�t
t�
�
�

d
D]}|�||
�
q(dS)N)r9r;r<)rW�dirrUr7rr�
issupersetZassertIn)r>Zdir_of_gen_aliasZgeneric_alias_propertyr3r3rB�test_dir5
s



zBaseTest.test_dirc
	Csj|jD]^}
|
durq|
j
}|�d
|���
�*
|
t}|�t|�
�|�
Wd�
q1sZ0


Y
qdSrD)r4r5r6r7r:r,r=r3r3rB�test_weakref;
s







zBaseTest.test_weakrefc

Cs8|�t
�
�
ttd
�

Wd�
n1s*0


Y
dS)N�
Zbad)rIrJr!rFr~r3r3rB�test_no_kwargsD
s
zBaseTest.test_no_kwargsc
CsvGd
d�dt�}
|
t
t�}Gdd�dt�}|�|t
t�
|�t�
�
|t
ttd�
Wd�
n1sh0


Y
dS)Nc
@seZ
dZd
S)z>BaseTest.test_subclassing_types_genericalias.<locals>.SubClassNrar3r3r3rB�SubClassJ
r�r�cseZ
dZ�f
d
d�Z�ZS)z9BaseTest.test_subclassing_types_genericalias.<locals>.Badc
st�j
|g
|
�
Ri|�
�

dSrm)�super�__new__)�cls�args�kwargs�
rfr3rBr�M
s
zABaseTest.test_subclassing_types_genericalias.<locals>.Bad.__new__)r5rbrcr��
__classcell__r3r3r�rB�BadL
s
r�r�)r!rUr7r:rIrJ)r>r�rAr�r3r3rB�#test_subclassing_types_genericaliasI
s





z,BaseTest.test_subclassing_types_genericaliasc
CsJtt
tgtf}
|�d
�
�@
|�|
jt�
|�|
jt
ttf�
|�|
j	d�
Wd�
n1s`0


Y
|�d�
�
|�
|
t�
Wd�
n1s�0


Y
|�d�
�"
|�t|
�
�|
�
Wd�
n1s�0


Y
|�d�
�T
t
�|
�
}t
�|�
}|�|
j|j�
|�|
j|j�
|�|
j	|j	�
Wd�
n1�
sB0


Y
|�d�
��
tt
tgtf}tttgtf}tdtf}|�|ttt
tgtf�
|�|t
ttftt
tgtf�
|�|t
tdt
f�
|t
ttf}|�t|�
�d�
d	d
�
|�t|t�
�d�
d	d�
|�|ttt
tgtf�
Wd�
n1�sR0


Y
|�d�
�X
Gd
d�dt�}|t
g
tf}|�|�j|�
|�|�j|t
g
tf�
Wd�
n1�s�0


Y
|�d�
�Z
tjt
tgtf}	tt
tgtf}
|�|	j|
j�
|�t|	j�
t|
j�
�
Wd�
n1�s<0


Y
dS)NzTesting subscriptionr3zTesting instance checkszTesting weakrefzTesting picklingzTesting TypeVar substitution.�
.���zCallable[[int, ~V], str]zCallable[[int, dict], str]zTesting type erasurec@seZ
dZd
d�ZdS)z&BaseTest.test_abc_callable.<locals>.C1c


SsdSrmr3r~r3r3rB�__call__z
s
z/BaseTest.test_abc_callable.<locals>.C1.__call__N)r5rbrcr�r3r3r3rB�C1y
s
r�zCTesting collections.abc.Callable's consistency with typing.Callable)ryr7rErFr6r8r9r:r;r<ZassertIsInstancer!r,r�r�r�r.r/r0rq�splitrVrf�__orig_class__rz�hash)r>rAr�r�r�ZC2ZC3ZC4rLZc1Zc2r3r3rB�test_abc_callableT
sH



,
*
0






0




"



<


:


zBaseTest.test_abc_callable)ir5rbrc�__doc__rgrTrUrVrWrX�	enumeraterrrrrrrrrrr rrrrr�	Awaitable�	Coroutine�
AsyncIterable�
AsyncIterator�AsyncGenerator�	Generator�Iterable�Iterator�
Reversible�	Container�
Collectionrrr
rr�Set�
MutableSet�Mapping�MutableMapping�MappingView�KeysView�	ItemsView�
ValuesView�Sequence�MutableSequencer"r#rrr$r%r)rr(r&r'rrr*r+r,r�
MPSimpleQueuer	r
rr4�ctypes�extendZArrayZ
LibraryLoaderrCrKr[r`rhrlrnrprtrvr{r}rr�r�r�r�r�r�r�r�r�r�r�r�r�r3r3r3rBr11s�


































�"
		'		r1�__main__)Tr�Zunittestr�r��collectionsrrrrrr�collections.abcZconcurrent.futuresr	Zconcurrent.futures.threadr
�
contextlibrrZcontextvarsr
rZdataclassesr�	functoolsrrrZmailboxrrr��ImportErrorZdifflibrZfilecmprZ	fileinputr�	itertoolsrZhttp.cookiesrZmultiprocessing.managersrZmultiprocessing.poolrZmultiprocessing.shared_memoryrZmultiprocessing.queuesrr��osr�rerr rur!r"r#Ztempfiler$r%Zurllib.parser&r'Z
unittest.caser(Zqueuer)�weakrefr*r+r,rzr-r.r/r0ZTestCaser1r5�mainr3r3r3rB�<module>
s\


 



































Z