ó
    Ö›‘hHˆ  ã                   óF  • S r SSKrSSKrSSKrSSKrSSKrSSKJrJ	r	J
r
Jr  SSKJr   SSKrSSKr\r\rSSKJr  SSKJr  SSKJr  SSKJr  SS	KJr  SS
KJr  SSKJ r   SSK!J"r"  SSK#J$r$J%r%  SSK&J'r(  \ " \RR                  5      RU                  5       r+ " S S\%5      r, " S S\%5      r- " S S\%5      r.\" \/" \SS5      (       + S5       " S S\%5      5       r0 " S S\%5      r1 " S S\%5      r2 " S S\%5      r3 " S S \5      r4\" \Rj                  " \5      (       + S!5       " S" S#\%5      5       r6 " S$ S%\%5      r7 " S& S'\%5      r8 " S( S)\Rr                  5      r: " S* S+\Rr                  5      r; " S, S-\:5      r< " S. S/5      r= " S0 S15      r> " S2 S3\%5      r?\" \/" \S4S5      (       + S55       " S6 S7\%5      5       r@\" \R‚                  (       + S85       " S9 S:\%5      5       rB " S; S<\%5      rC " S= S>\%5      rD " S? S@\%5      rE " SA SB\%5      rFg! \ a    SrSr GNéf = f)Cz#
Tests for L{twisted.python.util}.
é    N)ÚIterableÚMappingÚMutableMappingÚSequence)ÚskipIf)Úreactor)ÚDeferred)ÚProcessDone)ÚIReactorProcess)ÚProcessProtocol)Úutil)ÚFilePath)ÚMockOS)ÚFailTestÚTestCase)Úsuppressc                   óp   • \ rS rSrS rS rS r\" \SL S5      S 5       r	S r
\" \SL S	5      S
 5       rSrg)Ú	UtilTestsé*   c                 ó\   • / SQnU R                  [        R                  " U5      / SQ5        g )N)Úaé   Úabr   é   é   r   é   r   r   é   )r   r   r   r   r   r   r   )ÚassertEqualr   Úuniquify)ÚselfÚlistWithDupess     ÚaC:\Users\psant\Downloads\Noiseback\school\venv\Lib\site-packages\twisted/python/test/test_util.pyÚtestUniqÚUtilTests.testUniq+   s!   € Ú@ˆØ×ÑœŸš }Ó5Ò7QÕRó    c                 ó<  • U R                  [        R                  " [        [        SS5      5        U R                  [        R                  " [        [        SS5      5         [        R                  " [        [        SS5        [        S5      e! [         a     g f = f)Nr   r   z,util.raises didn't raise when it should have)Ú
assertTruer   ÚraisesÚZeroDivisionErrorÚdivmodÚassertFalseÚ	TypeErrorr   ©r    s    r"   Ú
testRaisesÚUtilTests.testRaises/   sv   € Ø�‰œŸšÔ$5´v¸qÀ!ÓDÔEØ×ÑœŸšÔ%6¼ÀÀ1ÓEÔFð	KÜ�KŠKœ	¤6¨1¨aÔ0ô ÐIÓJÐJøô !ó 	Ùð	ús   Á"!B Â
BÂBc                 óP   • U R                  [        R                  " S5      S5        g)ún
When L{uidFromString} is called with a base-ten string representation
of an integer, it returns the integer.
Ú100éd   N)r   r   ÚuidFromStringr-   s    r"   Útest_uidFromNumericStringÚ#UtilTests.test_uidFromNumericString:   ó   € ð
 	×Ñœ×+Ò+¨EÓ2°CÕ8r%   Nz0Username/UID conversion requires the pwd module.c                 óÈ   • [         R                  [        R                  " 5       5      nU R	                  [
        R                  " UR                  5      UR                  5        g)r1   N)	ÚpwdÚgetpwuidÚosÚgetuidr   r   r4   Úpw_nameÚpw_uid)r    Úpwents     r"   Útest_uidFromUsernameStringÚ$UtilTests.test_uidFromUsernameStringA   ó;   € ô —‘œRŸYšY›[Ó)ˆØ×Ñœ×+Ò+¨E¯M©MÓ:¸E¿L¹LÕIr%   c                 óP   • U R                  [        R                  " S5      S5        g)ún
When L{gidFromString} is called with a base-ten string representation
of an integer, it returns the integer.
r2   r3   N)r   r   ÚgidFromStringr-   s    r"   Útest_gidFromNumericStringÚ#UtilTests.test_gidFromNumericStringJ   r7   r%   z2Group Name/GID conversion requires the grp module.c                 óÈ   • [         R                  [        R                  " 5       5      nU R	                  [
        R                  " UR                  5      UR                  5        g)rD   N)	ÚgrpÚgetgrgidr;   Úgetgidr   r   rE   Úgr_nameÚgr_gid)r    Úgrents     r"   Útest_gidFromGroupnameStringÚ%UtilTests.test_gidFromGroupnameStringQ   rB   r%   © )Ú__name__Ú
__module__Ú__qualname__Ú__firstlineno__r#   r.   r5   r   r9   r@   rF   rI   rO   Ú__static_attributes__rQ   r%   r"   r   r   *   s^   † òSò	Kò9ñ ˆC�4ˆKÐKÓLñJó MðJò9ñ ˆC�4ˆKÐMÓNñJó OóJr%   r   c                   ó   • \ rS rSrSrS rSrg)ÚNameToLabelTestsé[   z
Tests for L{nameToLabel}.
c                 óŠ   • / SQnU H9  u  p#[         R                  " U5      nU R                  XCSU< SU< SU< 35        M;     g)z;
Test the various kinds of inputs L{nameToLabel} supports.
))ÚfÚF)ÚfoÚFo)ÚfooÚFoo)ÚfooBarzFoo Bar)Ú	fooBarBazzFoo Bar BazznameToLabel(z) == z != N)r   ÚnameToLabelr   )r    ÚnameDataÚinpÚoutÚgots        r"   Útest_nameToLabelÚ!NameToLabelTests.test_nameToLabel`   sJ   € ò
ˆó !‰HˆCÜ×"Ò" 3Ó'ˆCØ×Ñ˜S¨°c±W¸EÀ#ÁÈÈSÉGÐ'TÖUò !r%   rQ   N)rR   rS   rT   rU   Ú__doc__rh   rV   rQ   r%   r"   rX   rX   [   s   † ñõVr%   rX   c                   ó   • \ rS rSrSrS rSrg)ÚUntilConcludesTestsép   z2
Tests for L{untilConcludes}, an C{EINTR} helper.
c                 ór  ^ • U 4S jnS/T l         ST l        T R                  [        R                  " USS5      S5        T R                  T R                  S5        S[
        [        /T l         ST l        T R                  [        R                  " USS5      S5        T R                  T R                  S5        g)zÛ
L{untilConcludes} calls the function passed to it until the function
does not raise either L{OSError} or L{IOError} with C{errno} of
C{EINTR}.  It otherwise completes with the same result as the function
passed to it.
c                 óž   >• T=R                   S-  sl         TR                  R                  5       nUb  U" [        R                  S5      eX-   $ )Nr   zInterrupted system call!)ÚcallsÚ
exceptionsÚpopÚerrnoÚEINTR)r   ÚbÚexcr    s      €r"   r[   Ú3UntilConcludesTests.test_uninterruptably.<locals>.f}   s@   ø€ Ø�JŠJ˜!‰O�JØ—/‘/×%Ñ%Ó'ˆCØ‰Ùœ%Ÿ+™+Ð'AÓBÐBØ‘5ˆLr%   Nr   r   r   r   é   )rq   rp   r   r   ÚuntilConcludesÚOSErrorÚIOError)r    r[   s   ` r"   Útest_uninterruptablyÚ(UntilConcludesTests.test_uninterruptablyu   s•   ø€ õ	ð  ˜&ˆŒØˆŒ
Ø×Ñœ×,Ò,¨Q°°1Ó5°qÔ9Ø×Ñ˜Ÿ™ QÔ'à¤¬'Ð2ˆŒØˆŒ
Ø×Ñœ×,Ò,¨Q°°1Ó5°qÔ9Ø×Ñ˜Ÿ™ QÕ'r%   )rp   rq   N)rR   rS   rT   rU   rj   r|   rV   rQ   r%   r"   rl   rl   p   s   † ñõ(r%   rl   r<   zgetuid/setuid not availablec                   ó<   • \ rS rSrSrS rS rS rS rS r	S r
S	rg
)ÚSwitchUIDTestsé�   z
Tests for L{util.switchUID}.
c                 ó´   • [        5       U l        U R                  [        SU R                  5        U R                  [        SU R                  5        / U l        g )Nr;   Ú
initgroups)r   ÚmockosÚpatchr   r‚   ÚinitgroupsCallsr-   s    r"   ÚsetUpÚSwitchUIDTests.setUp•   s;   € Ü“hˆŒØ�
‰
”4˜˜tŸ{™{Ô+Ø�
‰
”4˜ t§¡Ô7Ø!ˆÕr%   c                 ó<   • U R                   R                  X45        g)z;
Save L{util.initgroups} calls in C{self.initgroupsCalls}.
N)r…   Úappend)r    ÚuidÚgids      r"   r‚   ÚSwitchUIDTests.initgroups›   s   € ð 	×Ñ×#Ñ# S JÕ/r%   c                 óº   • [         R                  " SS5        U R                  U R                  S/5        U R                  U R                  R
                  S/5        g)zV
L{util.switchUID} calls L{util.initgroups} and then C{os.setuid} with
the given uid.
éà.  N©rŽ   N)ÚsetuidrŽ   )r   Ú	switchUIDr   r…   rƒ   Úactionsr-   s    r"   Útest_uidÚSwitchUIDTests.test_uid¡   sH   € ô
 	�Š�u˜dÔ#Ø×Ñ˜×-Ñ-°¨Ô?Ø×Ñ˜Ÿ™×,Ñ,Ð/@Ð.AÕBr%   c                 ó¼   • [         R                  " SSS5        U R                  U R                  S/5        U R                  U R                  R
                  S/5        g)z‚
L{util.switchUID} calls L{util.initgroups} and then C{os.seteuid} with
the given uid if the C{euid} parameter is set to C{True}.
rŽ   NTr�   )r   r‘   r   r…   rƒ   ÚseteuidCallsr-   s    r"   Ú	test_euidÚSwitchUIDTests.test_euidª   sH   € ô
 	�Š�u˜d DÔ)Ø×Ñ˜×-Ñ-°¨Ô?Ø×Ñ˜Ÿ™×1Ñ1°E°7Õ;r%   c                 óÌ  • U R                   R                  5       n[        R                  " US5        U R	                  U R
                  / 5        U R	                  U R                   R                  / 5        U R                  [        R                  /5      nU R	                  [        U5      S5        U R                  SU-  US   S   5        U R                  SU-  US   S   5        g)z†
If the current uid is the same as the uid passed to L{util.switchUID},
then initgroups does not get called, but a warning is issued.
Nr   z&tried to drop privileges and setuid %ir   Úmessagezbut uid is already %i)
rƒ   r<   r   r‘   r   r…   r’   ÚflushWarningsÚlenÚassertIn)r    rŠ   ÚcurrentWarningss      r"   Útest_currentUIDÚSwitchUIDTests.test_currentUID³   sÁ   € ð
 �k‰k× Ñ Ó"ˆÜ�Š�s˜DÔ!Ø×Ñ˜×-Ñ-¨rÔ2Ø×Ñ˜Ÿ™×,Ñ,¨bÔ1Ø×,Ñ,¬d¯n©nÐ-=Ó>ˆØ×Ñœ˜_Ó-¨qÔ1Ø�‰Ø4°sÑ:Ø˜AÑ˜yÑ)ô	
ð 	�‰Ð-°Ñ3°_ÀQÑ5GÈ	Ñ5RÕSr%   c                 óÎ  • U R                   R                  5       n[        R                  " USS5        U R	                  U R
                  / 5        U R	                  U R                   R                  / 5        U R                  [        R                  /5      nU R	                  [        U5      S5        U R                  SU-  US   S   5        U R                  SU-  US   S   5        g)zˆ
If the current euid is the same as the euid passed to L{util.switchUID},
then initgroups does not get called, but a warning is issued.
NTr   z'tried to drop privileges and seteuid %ir   rš   zbut euid is already %i)
rƒ   Úgeteuidr   r‘   r   r…   r–   r›   rœ   r�   )r    Úeuidrž   s      r"   Útest_currentEUIDÚSwitchUIDTests.test_currentEUIDÄ   sÃ   € ð
 �{‰{×"Ñ"Ó$ˆÜ�Š�t˜T 4Ô(Ø×Ñ˜×-Ñ-¨rÔ2Ø×Ñ˜Ÿ™×1Ñ1°2Ô6Ø×,Ñ,¬d¯n©nÐ-=Ó>ˆØ×Ñœ˜_Ó-¨qÔ1Ø�‰Ø5¸Ñ<Ø˜AÑ˜yÑ)ô	
ð 	�‰Ð.°Ñ5°ÀqÑ7IÈ)Ñ7TÕUr%   )r…   rƒ   N)rR   rS   rT   rU   rj   r†   r‚   r“   r—   rŸ   r¤   rV   rQ   r%   r"   r   r   �   s(   † ñò"ò0òCò<òTõ"Vr%   r   c                   ó6   • \ rS rSrSrS rS rS rS rS r	Sr
g	)
ÚMergeFunctionMetadataTestséÖ   z%
Tests for L{mergeFunctionMetadata}.
c           	      óª   ^^• [        5       m[        5       mU4S jnS	U4S jjn[        R                  " X5      nU R                  U" SSSSS9T5        g)
z\
After merging C{foo}'s data into C{bar}, the returned function behaves
as if it is C{bar}.
c                  ó   >• T $ ©NrQ   )Ú
foo_objects   €r"   r_   ÚQMergeFunctionMetadataTests.test_mergedFunctionBehavesLikeMergeTarget.<locals>.fooã   s	   ø€ ØÐr%   é
   c                 ó   >• Uu  pgT$ r«   rQ   )	ÚxÚyr   ÚcÚdÚer   ru   Ú
bar_objects	           €r"   ÚbarÚQMergeFunctionMetadataTests.test_mergedFunctionBehavesLikeMergeTarget.<locals>.baræ   s   ø€ Ø‰FˆQØÐr%   r   r   )r   r   )ÚquuxN)r®   )Úobjectr   ÚmergeFunctionMetadataÚassertIs)r    r_   r¶   Úbazrµ   r¬   s       @@r"   Ú)test_mergedFunctionBehavesLikeMergeTargetÚDMergeFunctionMetadataTests.test_mergedFunctionBehavesLikeMergeTargetÛ   sH   ù€ ô
 “Xˆ
Ü“Xˆ
õ	÷	ô ×(Ò(¨Ó2ˆØ�‰‘c˜!˜Q ¨RÑ0°*Õ=r%   c                 ó–   • S nS nSUl         [        R                  " X5      nU R                  UR                   UR                   5        g)zL
Merging C{foo} into C{bar} returns a function with C{foo}'s
C{__module__}.
c                  ó   • g r«   rQ   rQ   r%   r"   r_   Ú;MergeFunctionMetadataTests.test_moduleIsMerged.<locals>.fooó   ó   € Ør%   c                  ó   • g r«   rQ   rQ   r%   r"   r¶   Ú;MergeFunctionMetadataTests.test_moduleIsMerged.<locals>.barö   rÂ   r%   zsomewhere.elseN)rS   r   rº   r   ©r    r_   r¶   r¼   s       r"   Útest_moduleIsMergedÚ.MergeFunctionMetadataTests.test_moduleIsMergedí   s=   € ò	ò	ð *ˆŒä×(Ò(¨Ó2ˆØ×Ñ˜Ÿ™¨¯©Õ8r%   c                 óˆ   • S nS n[         R                  " X5      nU R                  UR                  UR                  5        g)zH
Merging C{foo} into C{bar} returns a function with C{foo}'s docstring.
c                  ó   • g)z
This is foo.
NrQ   rQ   r%   r"   r_   Ú>MergeFunctionMetadataTests.test_docstringIsMerged.<locals>.foo  ó   � r%   c                  ó   • g)z
This is bar.
NrQ   rQ   r%   r"   r¶   Ú>MergeFunctionMetadataTests.test_docstringIsMerged.<locals>.bar  rË   r%   N)r   rº   r   rj   rÅ   s       r"   Útest_docstringIsMergedÚ1MergeFunctionMetadataTests.test_docstringIsMergedþ   s6   € ò
	ò
	ô
 ×(Ò(¨Ó2ˆØ×Ñ˜Ÿ™ c§k¡kÕ2r%   c                 óˆ   • S nS n[         R                  " X5      nU R                  UR                  UR                  5        g)zC
Merging C{foo} into C{bar} returns a function with C{foo}'s name.
c                  ó   • g r«   rQ   rQ   r%   r"   r_   Ú9MergeFunctionMetadataTests.test_nameIsMerged.<locals>.foo  rÂ   r%   c                  ó   • g r«   rQ   rQ   r%   r"   r¶   Ú9MergeFunctionMetadataTests.test_nameIsMerged.<locals>.bar  rÂ   r%   N)r   rº   r   rR   rÅ   s       r"   Útest_nameIsMergedÚ,MergeFunctionMetadataTests.test_nameIsMerged  s6   € ò
	ò	ô ×(Ò(¨Ó2ˆØ×Ñ˜Ÿ™ s§|¡|Õ4r%   c                 óX  • S nSUl         SUl        S nSUl        SUl        [        R                  " X5      nU R                  UR                   UR                   5        U R                  UR                  UR                  5        U R                  UR                  UR                  5        g)z^
Merging C{foo} into C{bar} returns a function with C{bar}'s
dictionary, updated by C{foo}'s.
c                  ó   • g r«   rQ   rQ   r%   r"   r_   ÚGMergeFunctionMetadataTests.test_instanceDictionaryIsMerged.<locals>.foo$  rÂ   r%   r   r   c                  ó   • g r«   rQ   rQ   r%   r"   r¶   ÚGMergeFunctionMetadataTests.test_instanceDictionaryIsMerged.<locals>.bar*  rÂ   r%   r   r   N)r   ru   r²   r   rº   r   rÅ   s       r"   Útest_instanceDictionaryIsMergedÚ:MergeFunctionMetadataTests.test_instanceDictionaryIsMerged  s„   € ò	ð ˆŒØˆŒò	ð ˆŒØˆŒä×(Ò(¨Ó2ˆØ×Ñ˜Ÿ™ §¡Ô&Ø×Ñ˜Ÿ™ §¡Ô&Ø×Ñ˜Ÿ™ §¡Õ&r%   rQ   N)rR   rS   rT   rU   rj   r½   rÆ   rÎ   rÕ   rÜ   rV   rQ   r%   r"   r§   r§   Ö   s    † ñò>ò$9ò"3ò$5õ'r%   r§   c                   ó   • \ rS rSrSrS rSrg)ÚOrderedDictTestsi6  z 
Tests for L{util.OrderedDict}.
c                 óæ   • SSK Jn  U  U R                  U R                  /S9nU R	                  US   S   S5        U R	                  US   S   [
        5        U R	                  [        U5      S5        g)	z$
L{util.OrderedDict} is deprecated.
r   )ÚOrderedDict©ÚoffendingFunctionsrš   zftwisted.python.util.OrderedDict was deprecated in Twisted 15.5.0: Use collections.OrderedDict instead.Úcategoryr   N)Útwisted.python.utilrá   r›   Útest_deprecatedr   ÚDeprecationWarningrœ   )r    rá   rž   s      r"   ræ   Ú OrderedDictTests.test_deprecated;  sx   € õ 	4áà×,Ñ,À×AUÑAUÐ@VÐ,ÐWˆØ×ÑØ˜AÑ˜yÑ)ð;ô	
ð
 	×Ñ˜¨Ñ+¨JÑ7Ô9KÔLØ×Ñœ˜_Ó-¨qÕ1r%   rQ   N)rR   rS   rT   rU   rj   ræ   rV   rQ   r%   r"   rß   rß   6  s   † ñõ2r%   rß   c                   ó6   • \ rS rSrSrS rS rS rS rS r	Sr
g	)
ÚInsensitiveDictTestsiM  z$
Tests for L{util.InsensitiveDict}.
c                 ó&  • [         R                  " 5       nU R                  [        U[        5      5        U R                  [        U[
        5      5        U R                  [        U[        5      5        U R                  [        U[        5      5        g)z>
L{util.InsensitiveDict} implements L{typing.MutableMapping}.
N)	r   ÚInsensitiveDictr'   Ú
isinstancer   r   r   r+   r   )r    Údcts     r"   Útest_abcÚInsensitiveDictTests.test_abcR  s`   € ô ×"Ò"Ó$ˆØ�‰œ
 3¬Ó1Ô2Ø�‰œ
 3¬Ó0Ô1Ø�‰œ
 3¬Ó7Ô8Ø×Ñœ C¬Ó2Õ3r%   c                 ó  • [         R                  " SSSS0S.SS9nU R                  US   SS05        U R                  US   S5        U R                  UR                  5       U5        U R                  US   UR	                  S5      5        U R                  SU5        U R                  SU5        [        [        U5      U[         R                  S	.5      nU R                  X!5        / S
QnU HF  nU R                  XAR                  5       5        U R                  XAU   4UR                  5       5        MH     U R                  [        U5      [        U5      5        US	 US	 U R                  UR                  5       S/5        g)zZ
L{util.InsensitiveDict} preserves the case of keys if constructed with
C{preserve=True}.
r¶   r   r   ©r`   r   Úfnz©Úpreserveró   r_   r`   )rî   rì   )r`   ró   r   N)r   rì   r   ÚcopyÚgetr�   ÚevalÚreprÚkeysÚitemsrœ   )r    rî   Úresultrú   r°   s        r"   Útest_preserveÚ"InsensitiveDictTests.test_preserve\  sI  € ô
 ×"Ò"¨5°QÀÀ1¸vÑ#FÐQRÑSˆØ×Ñ˜˜U™ a¨ VÔ,Ø×Ñ˜˜U™ UÔ+Ø×Ñ˜Ÿ™› SÔ)Ø×Ñ˜˜U™ S§W¡W¨U£^Ô4Ø�‰�a˜ÔØ�‰�e˜SÔ!äÜ�‹IàÜ#'×#7Ñ#7ñó
ˆð 	×Ñ˜Ô%â ˆÛˆAØ�M‰M˜!ŸX™X›ZÔ(Ø�M‰M˜1 !™f˜+ s§y¡y£{Ö3ñ ð 	×Ñœ˜T›¤C¨£HÔ-Ø�ˆFØ�ˆJØ×Ñ˜Ÿ™› e WÕ-r%   c                 óp  • [         R                  " SSSS0S.SS9n/ SQnU HF  nU R                  X1R                  5       5        U R                  X1U   4UR	                  5       5        MH     U R                  [        U5      [        U5      5        US	 US	 U R                  UR                  5       S	/5        g
)zd
L{util.InsensitiveDict} does not preserves the case of keys if
constructed with C{preserve=False}.
r¶   r   r   rò   r   rô   )r_   ró   r   r_   ró   N)r   rì   r�   rú   rû   r   rœ   )r    rî   rú   r°   s       r"   Útest_noPreserveÚ$InsensitiveDictTests.test_noPreserve{  s�   € ô
 ×"Ò"¨5°QÀÀ1¸vÑ#FÐQRÑSˆÚ ˆÛˆAØ�M‰M˜!ŸX™X›ZÔ(Ø�M‰M˜1 !™f˜+ s§y¡y£{Ö3ñ ð 	×Ñœ˜T›¤C¨£HÔ-Ø�ˆFØ�ˆJØ×Ñ˜Ÿ™› e WÕ-r%   c                 ó¢   • [         R                  " SS9nSUS'   U R                  US   S5        U R                  UR                  5       S/5        g)z$
Unicode keys are case insensitive.
Frô   r   r`   ÚFOOr_   N©r   rì   r   rú   ©r    r³   s     r"   Útest_unicodeÚ!InsensitiveDictTests.test_unicodeŠ  sI   € ô × Ò ¨%Ñ0ˆØˆˆ%‰Ø×Ñ˜˜5™ 1Ô%Ø×Ñ˜Ÿ™› E 7Õ+r%   c                 ó¢   • [         R                  " SS9nSUS'   U R                  US   S5        U R                  UR                  5       S/5        g)z"
Bytes keys are case insensitive.
Frô   r   s   Foos   FOOs   fooNr  r  s     r"   Ú
test_bytesÚInsensitiveDictTests.test_bytes“  sI   € ô × Ò ¨%Ñ0ˆØˆˆ&‰	Ø×Ñ˜˜6™ AÔ&Ø×Ñ˜Ÿ™› F 8Õ,r%   rQ   N)rR   rS   rT   rU   rj   rï   rý   r   r  r	  rV   rQ   r%   r"   rê   rê   M  s    † ñò4ò.ò>.ò,õ-r%   rê   c                   ó*   • \ rS rSrSrS rS rS rSrg)ÚPasswordTestingProcessProtocoli�  z†
Write the string C{"secret\n"} to a subprocess and then collect all of
its output and fire a Deferred with it when the process ends.
c                 óH   • / U l         U R                  R                  S5        g )Ns   secret
)ÚoutputÚ	transportÚwriter-   s    r"   ÚconnectionMadeÚ-PasswordTestingProcessProtocol.connectionMade£  s   € ØˆŒØ�‰×Ñ˜[Õ)r%   c                 ó<   • U R                   R                  X45        g r«   )r  r‰   )r    Úfdr  s      r"   ÚchildDataReceivedÚ0PasswordTestingProcessProtocol.childDataReceived§  s   € Ø�‰×Ñ˜B˜<Õ(r%   c                 óP   • U R                   R                  XR                  45        g r«   )ÚfinishedÚcallbackr  )r    Úreasons     r"   ÚprocessEndedÚ+PasswordTestingProcessProtocol.processEndedª  s   € Ø�‰×Ñ ¯©Ð4Õ5r%   )r  N)	rR   rS   rT   rU   rj   r  r  r  rV   rQ   r%   r"   r  r  �  s   † ñò
*ò)õ6r%   r  z,Process support required to test getPasswordc                   ó   • \ rS rSrS rSrg)ÚGetPasswordTestsi®  c           	      ó4  ^ • [        5       n[        5       Ul        [        R                  " U[
        [
        SS/S[        R                  R                  [        R                  5      R                  S5      0S9  U 4S jnUR                  R                  U5      $ )a  
Making sure getPassword accepts a password from standard input by
running a child process which uses getPassword to read in a string
which it then writes it out again.  Write a string to the child
process and then read one and make sure it is the right string.
s   -csj   import sys
from twisted.python.util import getPassword
sys.stdout.write(getPassword())
sys.stdout.flush()
s
   PYTHONPATHÚutf8)Úenvc                 ó\   >• U u  pUR                  [        5        TR                  SU5        g )N)r   s   secret)Útrapr
   r�   )rü   r  r  r    s      €r"   ÚprocessFinishedÚ4GetPasswordTests.test_stdin.<locals>.processFinishedÌ  s%   ø€ Ø%ÑˆVØ�K‰KœÔ$Ø�M‰M˜.¨&Õ1r%   )r  r	   r  r   ÚspawnProcessÚpyExer;   ÚpathsepÚjoinÚsysÚpathÚencodeÚaddCallback)r    Úpr$  s   `  r"   Ú
test_stdinÚGetPasswordTests.test_stdin³  s|   ø€ ô +Ó,ˆÜ“ZˆŒ
Ü×ÒØÜäØð,ð		ð ¤§
¡
§¡´·±Ó 9× @Ñ @ÀÓ HÐIò	
õ 	2ð
 �z‰z×%Ñ% oÓ6Ð6r%   rQ   N)rR   rS   rT   rU   r/  rV   rQ   r%   r"   r  r  ®  s   † õ
7r%   r  c                   ó   • \ rS rSrS rSrg)ÚSearchUpwardsTestsiÔ  c                 ó´  • [         R                  " S5        [        SS5      R                  5         [        SS5      R                  5         [        SS5      R                  5         [         R                  " S5        [         R                  " S5        [         R                  " S5        [         R                  " S	5        [
        R                  " SS
/SS/S9n[         R                  R                  S5      [         R                  -   nU R                  X5        [        R                  " S5        [
        R                  " SS
/SS/S9nS nU R                  X5        g )Nzsearchupwards/a/b/czsearchupwards/foo.txtÚwzsearchupwards/a/foo.txtzsearchupwards/a/b/c/foo.txtzsearchupwards/barzsearchupwards/bamzsearchupwards/a/barzsearchupwards/a/b/bamzfoo.txtr¶   Úbam)ÚfilesÚdirsÚsearchupwards)r;   ÚmakedirsÚopenÚcloseÚmkdirr   r8  r+  ÚabspathÚsepr   ÚshutilÚrmtree)r    ÚactualÚexpecteds      r"   ÚtestSearchupwardsÚ$SearchUpwardsTests.testSearchupwardsÕ  s  € Ü
�ŠÐ)Ô*ÜÐ$ cÓ*×0Ñ0Ô2ÜÐ&¨Ó,×2Ñ2Ô4ÜÐ*¨CÓ0×6Ñ6Ô8Ü
�ŠÐ$Ô%Ü
�ŠÐ$Ô%Ü
�ŠÐ&Ô'Ü
�ŠÐ(Ô)Ü×#Ò#Ø!¨)¨¸EÀ5¸>ñ
ˆô —7‘7—?‘? ?Ó3´b·f±fÑ<ˆØ×Ñ˜Ô*Ü�Š�oÔ&Ü×#Ò#Ø!¨)¨¸EÀ5¸>ñ
ˆð ˆØ×Ñ˜Õ*r%   rQ   N)rR   rS   rT   rU   rC  rV   rQ   r%   r"   r2  r2  Ô  s   † õ+r%   r2  c                   ó8   • \ rS rSrS rS rS rS rS rS r	Sr
g	)
ÚIntervalDifferentialTestsië  c                 óž   • [        [        R                  " / S5      5      n[        S5       H  nU R	                  [        U5      S5        M      g )Nr®   r3   ©r®   N©Úiterr   ÚIntervalDifferentialÚranger   Únext©r    r³   Úis      r"   ÚtestDefaultÚ%IntervalDifferentialTests.testDefaultì  s;   € Ü”×*Ò*¨2¨rÓ2Ó3ˆÜ�s–ˆAØ×ÑœT !›W jÖ1ò r%   c                 ó    • [        [        R                  " S/S5      5      n[        S5       H  nU R	                  [        U5      S5        M      g )Nrx   r®   r3   ©rx   r   rI  rN  s      r"   Ú
testSingleÚ$IntervalDifferentialTests.testSingleñ  s=   € Ü”×*Ò*¨A¨3°Ó3Ó4ˆÜ�s–ˆAØ×ÑœT !›W fÖ-ò r%   c                 óø  • [        [        R                  " SS/S5      5      n[        S5       GHH  nU R	                  [        U5      S5        U R	                  [        U5      S5        U R	                  [        U5      S5        U R	                  [        U5      S5        U R	                  [        U5      S	5        U R	                  [        U5      S5        U R	                  [        U5      S
5        U R	                  [        U5      S5        U R	                  [        U5      S5        U R	                  [        U5      S5        U R	                  [        U5      S5        U R	                  [        U5      S5        GMK     g )Nrx   é   r®   r3   rS  ©r   r   ©r   r   )r   r   ©r   r   ©r   r   ©r   r   )r   r   ©r   r   ©r   r   rI  rN  s      r"   ÚtestPairÚ"IntervalDifferentialTests.testPairö  s  € Ü”×*Ò*¨A¨q¨6°2Ó6Ó7ˆÜ�s—ˆAØ×ÑœT !›W fÔ-Ø×ÑœT !›W fÔ-Ø×ÑœT !›W fÔ-Ø×ÑœT !›W fÔ-Ø×ÑœT !›W fÔ-Ø×ÑœT !›W fÔ-Ø×ÑœT !›W fÔ-Ø×ÑœT !›W fÔ-Ø×ÑœT !›W fÔ-Ø×ÑœT !›W fÔ-Ø×ÑœT !›W fÔ-Ø×ÑœT !›W f×-ò r%   c                 ór  • [        [        R                  " / SQS5      5      n[        S5       GH  nU R	                  [        U5      S5        U R	                  [        U5      S5        U R	                  [        U5      S5        U R	                  [        U5      S5        U R	                  [        U5      S5        U R	                  [        U5      S5        U R	                  [        U5      S5        U R	                  [        U5      S5        U R	                  [        U5      S5        U R	                  [        U5      S5        U R	                  [        U5      S5        U R	                  [        U5      S5        U R	                  [        U5      S5        U R	                  [        U5      S5        U R	                  [        U5      S5        U R	                  [        U5      S5        U R	                  [        U5      S5        U R	                  [        U5      S5        U R	                  [        U5      S5        GM     g )	N)r   r   rx   r®   r3   r]  r^  )r   r   rZ  )r   r   rI  rN  s      r"   Ú
testTripleÚ$IntervalDifferentialTests.testTriple  s£  € Ü”×*Ò*ª9°bÓ9Ó:ˆÜ�s—ˆAØ×ÑœT !›W fÔ-Ø×ÑœT !›W fÔ-Ø×ÑœT !›W fÔ-Ø×ÑœT !›W fÔ-Ø×ÑœT !›W fÔ-Ø×ÑœT !›W fÔ-Ø×ÑœT !›W fÔ-Ø×ÑœT !›W fÔ-Ø×ÑœT !›W fÔ-Ø×ÑœT !›W fÔ-Ø×ÑœT !›W fÔ-Ø×ÑœT !›W fÔ-Ø×ÑœT !›W fÔ-Ø×ÑœT !›W fÔ-Ø×ÑœT !›W fÔ-Ø×ÑœT !›W fÔ-Ø×ÑœT !›W fÔ-Ø×ÑœT !›W fÔ-Ø×ÑœT !›W f×-ò' r%   c                 ón  • [        [        R                  " / S5      5      nU R                  [	        U5      S5        UR                  S5        U R                  [	        U5      S5        U R                  [	        U5      S5        UR                  S5        U R                  [	        U5      S5        U R                  [	        U5      S5        U R                  [	        U5      S5        U R                  [	        U5      S5        U R                  [	        U5      S5        U R                  [	        U5      S5        g )Nr®   rH  r   rY  r   r^  )rJ  r   rK  r   rM  ÚaddIntervalr  s     r"   Ú
testInsertÚ$IntervalDifferentialTests.testInsert  så   € Ü”×*Ò*¨2¨rÓ2Ó3ˆØ×Ñœ˜a› *Ô-Ø	�‰�aÔØ×Ñœ˜a› &Ô)Ø×Ñœ˜a› &Ô)Ø	�‰�aÔØ×Ñœ˜a› &Ô)Ø×Ñœ˜a› &Ô)Ø×Ñœ˜a› &Ô)Ø×Ñœ˜a› &Ô)Ø×Ñœ˜a› &Ô)Ø×Ñœ˜a› &Õ)r%   c                 ó  • [        [        R                  " SS/S5      5      nU R                  [	        U5      S5        U R                  [	        U5      S5        U R                  [	        U5      S5        UR                  S5        U R                  [	        U5      S5        U R                  [	        U5      S5        UR                  S5        U R                  [	        U5      S	5        U R                  [        UR
                  S5        g )
Nr   rx   r®   rY  rX  rZ  r\  rS  rH  )rJ  r   rK  r   rM  ÚremoveIntervalÚassertRaisesÚ
ValueErrorr  s     r"   Ú
testRemoveÚ$IntervalDifferentialTests.testRemove+  sÉ   € Ü”×*Ò*¨A¨q¨6°2Ó6Ó7ˆØ×Ñœ˜a› &Ô)Ø×Ñœ˜a› &Ô)Ø×Ñœ˜a› &Ô)Ø	×Ñ˜ÔØ×Ñœ˜a› &Ô)Ø×Ñœ˜a› &Ô)Ø	×Ñ˜ÔØ×Ñœ˜a› *Ô-Ø×Ñœ* a×&6Ñ&6¸Õ;r%   rQ   N)rR   rS   rT   rU   rP  rT  r_  rb  rf  rl  rV   rQ   r%   r"   rF  rF  ë  s    † ò2ò
.ò
.ò .ò.*õ
<r%   rF  c                   ó"   • \ rS rSrSrSrS rSrg)ÚRecordi8  z0
Trivial user of L{FancyEqMixin} used by tests.
©r   ru   c                 ó   • Xl         X l        g r«   rp  ©r    r   ru   s      r"   Ú__init__ÚRecord.__init__?  ó   € ØŒØ�r%   N©rR   rS   rT   rU   rj   ÚcompareAttributesrs  rV   rQ   r%   r"   ro  ro  8  ó   † ñð #Ðõr%   ro  c                   ó"   • \ rS rSrSrSrS rSrg)ÚDifferentRecordiD  zD
Trivial user of L{FancyEqMixin} which is not related to L{Record}.
rp  c                 ó   • Xl         X l        g r«   rp  rr  s      r"   rs  ÚDifferentRecord.__init__K  ru  r%   Nrv  rQ   r%   r"   rz  rz  D  rx  r%   rz  c                   ó   • \ rS rSrSrSrg)ÚDerivedRecordiP  z8
A class with an inheritance relationship to L{Record}.
rQ   N)rR   rS   rT   rU   rj   rV   rQ   r%   r"   r~  r~  P  s   † ôr%   r~  c                   ó*   • \ rS rSrSrS\S\4S jrSrg)ÚEqualToEverythingiV  zI
A class the instances of which consider themselves equal to everything.
ÚotherÚreturnc                 ó   • g)NTrQ   ©r    r�  s     r"   Ú__eq__ÚEqualToEverything.__eq__[  s   € Ør%   rQ   N©	rR   rS   rT   rU   rj   r¹   Úboolr…  rV   rQ   r%   r"   r€  r€  V  s   † ñð˜Fð  t÷ r%   r€  c                   ó*   • \ rS rSrSrS\S\4S jrSrg)ÚEqualToNothingi_  zF
A class the instances of which consider themselves equal to nothing.
r�  r‚  c                 ó   • g)NFrQ   r„  s     r"   r…  ÚEqualToNothing.__eq__d  s   € Ør%   rQ   Nr‡  rQ   r%   r"   rŠ  rŠ  _  s   † ñð˜Fð  t÷ r%   rŠ  c                   óN   • \ rS rSrSrS rS rS rS rS r	S r
S	 rS
 rS rSrg)ÚEqualityTestsih  z
Tests for L{FancyEqMixin}.
c                 ó  •  " S S[         R                  5      nU R                  U" 5       U" 5       :H  5        U R                  U" 5       U" 5       :g  5        U" 5       nU R                  X":H  5        U R                  X":g  5        g)zu
Instances of a class which mixes in L{FancyEqMixin} but which
defines no comparison attributes compare by identity.
c                   ó   • \ rS rSrSrg)Ú*EqualityTests.test_identity.<locals>.Emptyis  rQ   N)rR   rS   rT   rU   rV   rQ   r%   r"   ÚEmptyr‘  s  s   † Úr%   r’  N)r   ÚFancyEqMixinr+   r'   )r    r’  Úemptys      r"   Útest_identityÚEqualityTests.test_identitym  sg   € ô	”D×%Ñ%ô 	ð 	×Ñ™›¡E£GÑ+Ô,Ø�‰™›¡5£7Ñ*Ô+Ù“ˆØ�‰˜™Ô'Ø×Ñ˜™Õ(r%   c                 óD  • U R                  [        SS5      [        SS5      :H  5        U R                  [        SS5      [        SS5      :H  5        U R                  [        SS5      [        SS5      :H  5        U R                  [        SS5      [        SS5      :H  5        g)zÄ
Instances of a class which mixes in L{FancyEqMixin} should compare
equal if all of their attributes compare equal.  They should not
compare equal if any of their attributes do not compare equal.
r   r   r   r   N)r'   ro  r+   r-   s    r"   Útest_equalityÚEqualityTests.test_equality|  s~   € ð 	�‰œ˜q !›¬¨q°!«Ñ4Ô5Ø×Ñœ  1›¬°°1«Ñ5Ô6Ø×Ñœ  1›¬°°1«Ñ5Ô6Ø×Ñœ  1›¬°°1«Ñ5Õ6r%   c                 óD  • U R                  [        SS5      [        SS5      :g  5        U R                  [        SS5      [        SS5      :g  5        U R                  [        SS5      [        SS5      :g  5        U R                  [        SS5      [        SS5      :g  5        g)zg
Inequality between instances of a particular L{record} should be
defined as the negation of equality.
r   r   r   r   N)r+   ro  r'   r-   s    r"   Útest_unequalityÚEqualityTests.test_unequality‡  sz   € ð
 	×Ñœ  1›¬°°1«Ñ5Ô6Ø�‰œ˜q !›¬¨q°!«Ñ4Ô5Ø�‰œ˜q !›¬¨q°!«Ñ4Ô5Ø�‰œ˜q !›¬¨q°!«Ñ4Õ5r%   c                 óT   • U R                  [        SS5      [        SS5      :H  5        g)zW
Instances of different classes which mix in L{FancyEqMixin} should not
compare equal.
r   r   N)r+   ro  rz  r-   s    r"   Útest_differentClassesEqualityÚ+EqualityTests.test_differentClassesEquality‘  s$   € ð
 	×Ñœ  1›¬¸¸AÓ)>Ñ>Õ?r%   c                 óT   • U R                  [        SS5      [        SS5      :g  5        g)zU
Instances of different classes which mix in L{FancyEqMixin} should
compare unequal.
r   r   N)r'   ro  rz  r-   s    r"   Útest_differentClassesInequalityÚ-EqualityTests.test_differentClassesInequality˜  s"   € ð
 	�‰œ˜q !›¬¸¸1Ó(=Ñ=Õ>r%   c                 óD  • U R                  [        SS5      [        SS5      :H  5        U R                  [        SS5      [        SS5      :H  5        U R                  [        SS5      [        SS5      :H  5        U R                  [        SS5      [        SS5      :H  5        g)z¾
An instance of a class which derives from a class which mixes in
L{FancyEqMixin} should compare equal to an instance of the base class
if and only if all of their attributes compare equal.
r   r   r   r   N)r'   ro  r~  r+   r-   s    r"   Útest_inheritedClassesEqualityÚ+EqualityTests.test_inheritedClassesEqualityŸ  s‚   € ð 	�‰œ˜q !›¬°a¸Ó(;Ñ;Ô<Ø×Ñœ  1›¬°q¸!Ó)<Ñ<Ô=Ø×Ñœ  1›¬°q¸!Ó)<Ñ<Ô=Ø×Ñœ  1›¬°q¸!Ó)<Ñ<Õ=r%   c                 óD  • U R                  [        SS5      [        SS5      :g  5        U R                  [        SS5      [        SS5      :g  5        U R                  [        SS5      [        SS5      :g  5        U R                  [        SS5      [        SS5      :g  5        g)z¶
An instance of a class which derives from a class which mixes in
L{FancyEqMixin} should compare unequal to an instance of the base
class if any of their attributes compare unequal.
r   r   r   r   N)r+   ro  r~  r'   r-   s    r"   Útest_inheritedClassesInequalityÚ-EqualityTests.test_inheritedClassesInequalityª  s~   € ð 	×Ñœ  1›¬°q¸!Ó)<Ñ<Ô=Ø�‰œ˜q !›¬°a¸Ó(;Ñ;Ô<Ø�‰œ˜q !›¬°a¸Ó(;Ñ;Ô<Ø�‰œ˜q !›¬°a¸Ó(;Ñ;Õ<r%   c                 óœ   • U R                  [        SS5      [        5       :H  5        U R                  [        SS5      [	        5       :H  5        g)zÇ
The right-hand argument to the equality operator is given a chance
to determine the result of the operation if it is of a type
unrelated to the L{FancyEqMixin}-based instance on the left-hand
side.
r   r   N)r'   ro  r€  r+   rŠ  r-   s    r"   Ú(test_rightHandArgumentImplementsEqualityÚ6EqualityTests.test_rightHandArgumentImplementsEqualityµ  s;   € ð 	�‰œ˜q !›Ô(9Ó(;Ñ;Ô<Ø×Ñœ  1›¬Ó)9Ñ9Õ:r%   c                 óœ   • U R                  [        SS5      [        5       :g  5        U R                  [        SS5      [	        5       :g  5        g)zË
The right-hand argument to the non-equality operator is given a
chance to determine the result of the operation if it is of a type
unrelated to the L{FancyEqMixin}-based instance on the left-hand
side.
r   r   N)r+   ro  r€  r'   rŠ  r-   s    r"   Ú*test_rightHandArgumentImplementsUnequalityÚ8EqualityTests.test_rightHandArgumentImplementsUnequality¿  s;   € ð 	×Ñœ  1›Ô):Ó)<Ñ<Ô=Ø�‰œ˜q !›¬Ó(8Ñ8Õ9r%   rQ   N)rR   rS   rT   rU   rj   r•  r˜  r›  rž  r¡  r¤  r§  rª  r­  rV   rQ   r%   r"   rŽ  rŽ  h  s5   † ñò)ò	7ò6ò@ò?ò	>ò	=ò;õ:r%   rŽ  r¢   zgeteuid/seteuid not availablec                   óT   • \ rS rSrSrS rS rS rS rS r	S r
S	 rS
 rS rS rSrg)ÚRunAsEffectiveUserTestsiÊ  z3
Test for the L{util.runAsEffectiveUser} function.
c                 óz  • [        5       U l        U R                  [        SU R                  R                  5        U R                  [        SU R                  R
                  5        U R                  [        SU R                  R                  5        U R                  [        SU R                  R                  5        g )Nr¢   ÚgetegidÚseteuidÚsetegid)r   rƒ   r„   r;   r¢   r²  r³  r´  r-   s    r"   r†   ÚRunAsEffectiveUserTests.setUpÐ  ss   € Ü“hˆŒØ�
‰
”2�y $§+¡+×"5Ñ"5Ô6Ø�
‰
”2�y $§+¡+×"5Ñ"5Ô6Ø�
‰
”2�y $§+¡+×"5Ñ"5Ô6Ø�
‰
”2�y $§+¡+×"5Ñ"5Õ6r%   c                 óØ   • U R                  X1:H  =(       d    X0R                  R                  S   :H  5        U R                  XB:H  =(       d    X@R                  R                  S   :H  5        g)z6
Check if wanted UID/GID matched start or saved ones.
éÿÿÿÿN)r'   rƒ   r–   ÚsetegidCalls)r    ÚstartUIDÚstartGIDÚwantUIDÚwantGIDs        r"   Ú_securedFunctionÚ(RunAsEffectiveUserTests._securedFunction×  sR   € ð 	�‰˜Ñ+×V¨w¿+¹+×:RÑ:RÐSUÑ:VÑ/VÔWØ�‰˜Ñ+×V¨w¿+¹+×:RÑ:RÐSUÑ:VÑ/VÕWr%   c                 óZ   • [         R                  " SSS 5      nU R                  US5        g)zW
L{util.runAsEffectiveUser} forwards the result obtained by calling the
given function
r   c                  ó   • g)Nr   rQ   rQ   r%   r"   Ú<lambda>Ú<RunAsEffectiveUserTests.test_forwardResult.<locals>.<lambda>ã  s   € °qr%   r   N©r   ÚrunAsEffectiveUserr   ©r    rü   s     r"   Útest_forwardResultÚ*RunAsEffectiveUserTests.test_forwardResultÞ  s(   € ô
 ×(Ò(¨¨A©yÓ9ˆØ×Ñ˜ Õ#r%   c                 ó\   • [         R                  " SSS S5      nU R                  US5        g)zM
L{util.runAsEffectiveUser} pass the given parameters to the given
function.
r   c                 ó   • SU -  $ )Nr   rQ   )r°   s    r"   rÁ  Ú=RunAsEffectiveUserTests.test_takeParameters.<locals>.<lambda>ë  s   € ¸¸Qºr%   r   r   NrÃ  rÅ  s     r"   Útest_takeParametersÚ+RunAsEffectiveUserTests.test_takeParametersæ  s*   € ô
 ×(Ò(¨¨A©ÀÓBˆØ×Ñ˜ Õ#r%   c                 ó^   • [         R                  " SSSS jSSS9nU R                  US5        g)	zO
L{util.runAsEffectiveUser} pass the keyword parameters to the given
function.
r   c                 ó   • X-  U-  $ r«   rQ   )r°   r±   Úzs      r"   rÁ  ÚDRunAsEffectiveUserTests.test_takesKeyworkArguments.<locals>.<lambda>ó  s
   € À1Á5È1Â9r%   r   r   )rÏ  r   Nr[  rÃ  rÅ  s     r"   Útest_takesKeyworkArgumentsÚ2RunAsEffectiveUserTests.test_takesKeyworkArgumentsî  s.   € ô
 ×(Ò(¨¨AÓ/LÈaÐSTÑUˆØ×Ñ˜ Õ#r%   c           	      ól  • XR                   l        X R                   l        [        R                  " UUU R
                  UUUU5        U R                  U R                   R                  U5        U R                  U R                   R                  U5        / U R                   l        / U R                   l        g)z¯
Helper method checking the calls to C{os.seteuid} and C{os.setegid}
made by L{util.runAsEffectiveUser}, when switching from startUID to
wantUID and from startGID to wantGID.
N)	rƒ   r£   Úegidr   rÄ  r½  r   r–   r¸  )r    r¹  rº  r»  r¼  ÚexpectedUIDSwitchesÚexpectedGIDSwitchess          r"   Ú_testUIDGIDSwitchÚ)RunAsEffectiveUserTests._testUIDGIDSwitchö  s‘   € ð $�‰ÔØ#�‰ÔÜ×ÒØØØ×!Ñ!ØØØØô	
ð 	×Ñ˜Ÿ™×1Ñ1Ð3FÔGØ×Ñ˜Ÿ™×1Ñ1Ð3FÔGØ#%ˆ�‰Ô Ø#%ˆ�‰Õ r%   c           	      óÄ   • U R                  SSSS/ / 5        U R                  SSSSSS// 5        U R                  SSSS/ SS/5        U R                  SSSSSS/SS/5        g)z<
Check UID/GID switches when current effective UID is root.
r   r   N©r×  r-   s    r"   Ú	test_rootÚ!RunAsEffectiveUserTests.test_root  st   € ð 	×Ñ˜q ! Q¨¨2¨rÔ2Ø×Ñ˜q ! Q¨¨A¨q¨6°2Ô6Ø×Ñ˜q ! Q¨¨2°°1¨vÔ6Ø×Ñ˜q ! Q¨¨A¨q¨6°A°q°6Õ:r%   c           	      óÈ   • U R                  SSSSSS// 5        U R                  SSSS/ / 5        U R                  SSSS/ SQSS/5        U R                  SSSS/ SQSS/5        g)z@
Check UID/GID switches when current effective UID is non-root.
r   r   ©r   r   r   r   r   ©r   r   r   r   NrÚ  r-   s    r"   Útest_UIDÚ RunAsEffectiveUserTests.test_UID  sp   € ð 	×Ñ˜q ! Q¨¨A¨q¨6°2Ô6Ø×Ñ˜q ! Q¨¨2¨rÔ2Ø×Ñ˜q ! Q¨ª<¸!¸Q¸Ô@Ø×Ñ˜q ! Q¨ª<¸!¸Q¸Õ@r%   c           	      óÄ   • U R                  SSSS/ SS/5        U R                  SSSS/ / 5        U R                  SSSSSS// 5        U R                  SSSSSS/SS/5        g)z@
Check UID/GID switches when current effective GID is non-root.
r   r   r   NrÚ  r-   s    r"   Útest_GIDÚ RunAsEffectiveUserTests.test_GID&  st   € ð 	×Ñ˜q ! Q¨¨2°°1¨vÔ6Ø×Ñ˜q ! Q¨¨2¨rÔ2Ø×Ñ˜q ! Q¨¨A¨q¨6°2Ô6Ø×Ñ˜q ! Q¨¨A¨q¨6°A°q°6Õ:r%   c           	      ó`  • U R                  SSSSSS/SS/5        U R                  SSSSSS// 5        U R                  SSSS/ SQSS/5        U R                  SSSS/ / 5        U R                  SSSS/ SQ/ 5        U R                  SSSS/ SQSS/5        U R                  SSSS/ SQSS/5        g)zD
Check UID/GID switches when current effective UID/GID is non-root.
r   r   rÞ  r   rß  NrÚ  r-   s    r"   Útest_UIDGIDÚ#RunAsEffectiveUserTests.test_UIDGID/  sÄ   € ð 	×Ñ˜q ! Q¨¨A¨q¨6°A°q°6Ô:Ø×Ñ˜q ! Q¨¨A¨q¨6°2Ô6Ø×Ñ˜q ! Q¨ª<¸!¸Q¸Ô@Ø×Ñ˜q ! Q¨¨2¨rÔ2Ø×Ñ˜q ! Q¨ª<¸Ô<Ø×Ñ˜q ! Q¨ª<¸!¸Q¸Ô@Ø×Ñ˜q ! Q¨ª<¸!¸Q¸Õ@r%   )rƒ   N)rR   rS   rT   rU   rj   r†   r½  rÆ  rË  rÑ  r×  rÛ  rà  rã  ræ  rV   rQ   r%   r"   r°  r°  Ê  s<   † ñò7òXò$ò$ò$ò&ò<;òAò;õ
Ar%   r°  z.stdlib support for initgroups is not availablec                   ó$   • \ rS rSrSrS rS rSrg)ÚInitGroupsTestsi<  z
Tests for L{util.initgroups}.
c                 óŠ  ^• / mU4S jnU R                  [        SU5        / nU R                  [        SUR                  5        [        R                  " [        R
                  " 5       S5        U R                  T[        R                  [        R
                  " 5       5      R                  S4/5        U R                  U5        g)zK
Calling L{util.initgroups} will call the underlying stdlib
implmentation.
c                 ó*   >• TR                  X45        g r«   )r‰   )r°   r±   rp   s     €r"   ÚmockInitgroupsÚ?InitGroupsTests.test_initgroupsInStdlib.<locals>.mockInitgroupsI  s   ø€ Ø�L‰L˜!˜Õ r%   Ú_initgroupsÚ	setgroupsr   N)r„   r   r‰   r‚   r;   r<   r   r9   r:   r=   r+   )r    rì  ÚsetgroupsCallsrp   s      @r"   Útest_initgroupsInStdlibÚ'InitGroupsTests.test_initgroupsInStdlibB  s‹   ø€ ð
 ˆõ	!ð 	�
‰
”4˜¨Ô7ØˆØ�
‰
”4˜ n×&;Ñ&;Ô<ä�ŠœŸ	š	› QÔ'Ø×Ñ˜¤#§,¡,¬r¯yªy«{Ó";×"CÑ"CÀQÐ!GÐ HÔIØ×Ñ˜Õ(r%   c                 óv   • U R                  [        [        R                  [        R
                  " 5       S5        g)z>
Calling L{util.initgroups} with None for gid gives an error.
N)rj  r,   r   r‚   r;   r<   r-   s    r"   Útest_initgroupsNoneGidÚ&InitGroupsTests.test_initgroupsNoneGidT  s"   € ð 	×Ñœ)¤T§_¡_´b·i²i³kÀ4ÕHr%   rQ   N)rR   rS   rT   rU   rj   rñ  rô  rV   rQ   r%   r"   ré  ré  <  s   † ñò)õ$Ir%   ré  c                   ó>   • \ rS rSrSrS rS r\" \SS9/\l	        Sr
g)	ÚDeprecationTestsi[  z3
Tests for deprecations in C{twisted.python.util}.
c                 ó   • [         R                  " 5         U R                  U R                  /S9nU R	                  US   S   S5        U R	                  US   S   [
        5        U R	                  [        U5      S5        g)z&
L{util.getPluginDirs} is deprecated.
râ   r   rš   zCtwisted.python.util.getPluginDirs is deprecated since Twisted 12.2.rä   r   N)r   ÚgetPluginDirsr›   Útest_getPluginDirsr   rç   rœ   ©r    rž   s     r"   rú  Ú#DeprecationTests.test_getPluginDirs`  sƒ   € ô 	×ÒÔØ×,Ñ,Ø $× 7Ñ 7Ð8ð -ð 
ˆð 	×ÑØ˜AÑ˜yÑ)ØTô	
ð 	×Ñ˜¨Ñ+¨JÑ7Ô9KÔLØ×Ñœ˜_Ó-¨qÕ1r%   c                 ó   • [         R                  " 5         U R                  U R                  /S9nU R	                  US   S   S5        U R	                  US   S   [
        5        U R	                  [        U5      S5        g)z%
L{util.addPluginDir} is deprecated.
râ   r   rš   zBtwisted.python.util.addPluginDir is deprecated since Twisted 12.2.rä   r   N)r   ÚaddPluginDirr›   Útest_addPluginDirr   rç   rœ   rû  s     r"   rÿ  Ú"DeprecationTests.test_addPluginDiro  sƒ   € ô 	×ÒÔØ×,Ñ,Ø $× 6Ñ 6Ð7ð -ð 
ˆð 	×ÑØ˜AÑ˜yÑ)ØSô	
ð 	×Ñ˜¨Ñ+¨JÑ7Ô9KÔLØ×Ñœ˜_Ó-¨qÕ1r%   z/twisted.python.util.getPluginDirs is deprecated)rä   rš   rQ   N)rR   rS   rT   rU   rj   rú  rÿ  ÚSUPPRESSrç   r   rV   rQ   r%   r"   r÷  r÷  [  s,   † ñò2ò2ñ  	Ø'ØEñ	
ð"Ð×r%   r÷  c                   óT   • \ rS rSrSr\" \R                  5      rS rS r	S r
S rSrg)	ÚSuppressedWarningsTestsi†  z.
Tests for L{util.runWithWarningsSuppressed}.
c                 óØ   • S0 4S0 4/nU R                  U[        R                  S5        U R                  U[        R                  S5        U R                  / U R	                  5       5        g)zv
Warnings from the function called by C{runWithWarningsSuppressed} are
suppressed if they match the passed in filter.
©Úignorez.*foo.*©r  z.*bar.*ú
ignore fooz
ignore barN©ÚrunWithWarningsSuppressedÚwarningsÚwarnr   r›   )r    Úfilterss     r"   Ú&test_runWithWarningsSuppressedFilteredÚ>SuppressedWarningsTests.test_runWithWarningsSuppressedFiltered�  s^   € ð
 *¨2Ð.Ð1FÈÐ0KÐLˆØ×&Ñ& w´·±¸|ÔLØ×&Ñ& w´·±¸|ÔLØ×Ñ˜˜T×/Ñ/Ó1Õ2r%   c                 óÈ   • S0 4S0 4/nU R                  U[        R                  S5        U R                  S/U R	                  5        Vs/ s H  o"S   PM	     sn5        gs  snf )z�
Warnings from the function called by C{runWithWarningsSuppressed} are
not suppressed if they do not match the passed in filter.
r  r  zdon't ignorerš   Nr	  ©r    r  r4  s      r"   Ú(test_runWithWarningsSuppressedUnfilteredÚ@SuppressedWarningsTests.test_runWithWarningsSuppressedUnfiltered—  sa   € ð
 *¨2Ð.Ð1FÈÐ0KÐLˆØ×&Ñ& w´·±¸~ÔNØ×Ñ˜.Ð)À$×BTÑBTÔBVÓ+WÒBV¸Q¨i¬LÑBVÑ+WÕXùÒ+Ws   Á	A
c                 óJ   • U R                  U R                  / S 5      S5        g)zL
C{runWithWarningsSuppressed} returns the result of the function it
called.
c                  ó   • g)Nr   rQ   rQ   r%   r"   rÁ  Ú:SuppressedWarningsTests.test_passThrough.<locals>.<lambda>¥  s   € ÀAr%   r   N)r   r
  r-   s    r"   Útest_passThroughÚ(SuppressedWarningsTests.test_passThrough   s!   € ð
 	×Ñ˜×7Ñ7¸¹IÓFÈÕJr%   c                 óØ   • S0 4S0 4/nU R                  US 5        [        R                  " S5        U R                  S/U R	                  5        Vs/ s H  o"S   PM	     sn5        gs  snf )zS
Once C{runWithWarningsSuppressed} has returned, it no longer
suppresses warnings.
r  r  c                  ó   • g r«   rQ   rQ   r%   r"   rÁ  Ú<SuppressedWarningsTests.test_noSideEffects.<locals>.<lambda>­  s   € ¸r%   r  rš   Nr	  r  s      r"   Útest_noSideEffectsÚ*SuppressedWarningsTests.test_noSideEffects§  sf   € ð
 *¨2Ð.Ð1FÈÐ0KÐLˆØ×&Ñ& w±Ô=Ü�Š�lÔ#Ø×Ñ˜,˜À×@RÑ@RÔ@TÓ)UÒ@T¸1¨I¬,Ñ@TÑ)UÕVùÒ)Us   ÁA'
rQ   N)rR   rS   rT   rU   rj   Ústaticmethodr   r
  r  r  r  r  rV   rQ   r%   r"   r  r  †  s1   † ññ !-¨T×-KÑ-KÓ LÐò3òYòKõWr%   r  c                   ó6   • \ rS rSrSrS rS rS rS rS r	Sr
g	)
ÚFancyStrMixinTestsi²  z"
Tests for L{util.FancyStrMixin}.
c                 óv   •  " S S[         R                  5      nU R                  [        U" 5       5      S5        g)z†
If C{showAttributes} is set to a sequence of strings, C{__str__}
renders using those by looking them up as attributes on the object.
c                   ó    • \ rS rSrSrSrSrSrg)Ú6FancyStrMixinTests.test_sequenceOfStrings.<locals>.Fooi½  ©ÚfirstÚsecondr   ÚhellorQ   N©rR   rS   rT   rU   ÚshowAttributesr%  r&  rV   rQ   r%   r"   r`   r#  ½  ó   † Ø0ˆNØˆEØ‹Fr%   r`   z<Foo first=1 second='hello'>N©r   ÚFancyStrMixinr   Ústr©r    r`   s     r"   Útest_sequenceOfStringsÚ)FancyStrMixinTests.test_sequenceOfStrings·  s-   € ô	”$×$Ñ$ô 	ð
 	×Ñœ™S›U›Ð%CÕDr%   c                 óv   •  " S S[         R                  5      nU R                  S[        U" 5       5      5        g)zÝ
If C{showAttributes} has an item that is a 2-tuple, C{__str__} renders
the first item in the tuple as a key and the result of calling the
second item with the value of the attribute named by the first item as
the value.
c                   ó*   • \ rS rSrSSS 44rSrSrSrg)	Ú.FancyStrMixinTests.test_formatter.<locals>.FooiÌ  r%  r&  c                 ó$   • [        U S S S2   5      $ )Nr·  )rù   )Úvalues    r"   rÁ  Ú7FancyStrMixinTests.test_formatter.<locals>.Foo.<lambda>Í  s   € ÄÀUÉ4ÈRÈ4Á[Ô@Qr%   r'  ÚworldrQ   Nr(  rQ   r%   r"   r`   r3  Ì  s   † Ø%¨Ñ2QÐ'RÐSˆNØˆEØ‹Fr%   r`   z"<Foo first='hello' second='dlrow'>Nr+  r.  s     r"   Útest_formatterÚ!FancyStrMixinTests.test_formatterÄ  s-   € ô	”$×$Ñ$ô 	ð
 	×ÑÐ=¼sÁ3Ã5»zÕJr%   c                 óv   •  " S S[         R                  5      nU R                  [        U" 5       5      S5        g)zþ
If C{showAttributes} has an item that is a 3-tuple, C{__str__} renders
the second item in the tuple as a key, and the contents of the
attribute named in the first item are rendered as the value. The value
is formatted using the third item in the tuple.
c                   ó    • \ rS rSrSrSrSrSrg)Ú-FancyStrMixinTests.test_override.<locals>.FooiÛ  )r%  )r&  Ú2ndz%.1fr   gÙÎ÷Sã @rQ   Nr(  rQ   r%   r"   r`   r<  Û  s   † ØAˆNØˆEØ‹Fr%   r`   z<Foo first=1 2nd=2.1>Nr+  r.  s     r"   Útest_overrideÚ FancyStrMixinTests.test_overrideÓ  s-   € ô	”$×$Ñ$ô 	ð
 	×Ñœ™S›U›Ð%<Õ=r%   c                 óv   •  " S S[         R                  5      nU R                  [        U" 5       5      S5        g)zO
If C{fancybasename} is present, C{__str__} uses it instead of the class name.
c                   ó   • \ rS rSrSrSrg)Ú2FancyStrMixinTests.test_fancybasename.<locals>.Fooiç  ÚBarrQ   N)rR   rS   rT   rU   ÚfancybasenamerV   rQ   r%   r"   r`   rB  ç  s   † Ø!‹Mr%   r`   z<Bar>Nr+  r.  s     r"   Útest_fancybasenameÚ%FancyStrMixinTests.test_fancybasenameâ  s,   € ô
	"”$×$Ñ$ô 	"ð 	×Ñœ™S›U› WÕ-r%   c                 óŒ   •  " S S[         R                  5      nU" 5       nU R                  [        U5      [	        U5      5        g)z5
C{__repr__} outputs the same content as C{__str__}.
c                   ó    • \ rS rSrSrSrSrSrg)Ú)FancyStrMixinTests.test_repr.<locals>.Fooiñ  r$  r   r'  rQ   Nr(  rQ   r%   r"   r`   rI  ñ  r*  r%   r`   N)r   r,  r   r-  rù   )r    r`   Úobjs      r"   Ú	test_reprÚFancyStrMixinTests.test_reprì  s5   € ô
	”$×$Ñ$ô 	ñ
 ‹eˆØ×Ñœ˜S›¤4¨£9Õ-r%   rQ   N)rR   rS   rT   rU   rj   r/  r8  r>  rE  rK  rV   rQ   r%   r"   r   r   ²  s"   † ñòEòKò>ò.õ.r%   r   c                   óB   • \ rS rSrSrS rS rS rS rS r	S r
S	 rS
rg)Ú
PadToTestsiú  z
Tests for L{util.padTo}.
c                 ó^   • [         R                  " S/ 5      nU R                  S/S-  U5        g)zM
L{None} values can be added to a list to cause it to have a certain
length.
r   N©r   ÚpadTor   ©r    Úpaddeds     r"   Útest_defaultÚPadToTests.test_defaultÿ  s*   € ô
 —’˜A˜rÓ"ˆØ×Ñ˜$˜ !™ VÕ,r%   c                 ó`   • [         R                  " S/ S5      nU R                  S/S-  U5        g)zO
A specific value can be added to a list to cause it to have a certain
length.
r   r°   NrP  rR  s     r"   Útest_specificDefaultValueÚ$PadToTests.test_specificDefaultValue  s,   € ô
 —’˜A˜r 3Ó'ˆØ×Ñ˜#˜ ™ FÕ+r%   c                 ó`   • [         R                  " SSS/S5      nU R                  / SQU5        g)zT
A list which already has some items has the padding value added after
those items.
r   r   r   rÏ  )r   r   rÏ  NrP  rR  s     r"   Útest_padNonEmptyListÚPadToTests.test_padNonEmptyList  s*   € ô
 —’˜A  1˜v sÓ+ˆØ×Ñš fÕ-r%   c                 óT   • U R                  [        [        R                  SSS/5        g)zc
L{util.padTo} can't pad a list if the size requested is smaller than
the size of the list to pad.
r   r   N)rj  rk  r   rQ  r-   s    r"   Útest_padToSmallerSizeÚ PadToTests.test_padToSmallerSize  s    € ð
 	×Ñœ*¤d§j¡j°!°a¸°VÕ<r%   c                 ón   • SS/n[         R                  " [        U5      U5      nU R                  X5        g)zr
If the list is already the length indicated by the padding argument
then a list with the same value is returned.
r   r   N)r   rQ  rœ   r   ©r    rû   rS  s      r"   Útest_alreadyPaddedÚPadToTests.test_alreadyPadded  s/   € ð
 �A�ˆÜ—’œC ›J¨Ó.ˆØ×Ñ˜Õ'r%   c                 ón   • SS/n[         R                  " [        U5      U5      nU R                  X!5        g)zs
If the list is already the length indicated by the padding argument
then the return value is a copy of the input.
r   r   N)r   rQ  rœ   ÚassertIsNotr`  s      r"   Útest_alreadyPaddedCopiesÚ#PadToTests.test_alreadyPaddedCopies'  s/   € ð
 �A�ˆÜ—’œC ›J¨Ó.ˆØ×Ñ˜Õ'r%   c                 óZ   • / n[         R                  " SU5        U R                  / U5        g)z?
L{util.padTo} doesn't modify the input list but makes a copy.
r   NrP  )r    rû   s     r"   Útest_makeCopyÚPadToTests.test_makeCopy0  s'   € ð ˆÜ�
Š
�1�eÔØ×Ñ˜˜UÕ#r%   rQ   N)rR   rS   rT   rU   rj   rT  rW  rZ  r]  ra  re  rh  rV   rQ   r%   r"   rN  rN  ú  s*   † ñò-ò,ò.ò=ò(ò(õ$r%   rN  )Grj   rs   Úos.pathr;   r?  r*  r  Útypingr   r   r   r   Úunittestr   rI   Ú_grpr9   Ú_pwdÚImportErrorÚtwisted.internetr   Útwisted.internet.deferr	   Útwisted.internet.errorr
   Útwisted.internet.interfacesr   Útwisted.internet.protocolr   Útwisted.pythonr   Útwisted.python.filepathr   Útwisted.test.test_processr   Útwisted.trial.unittestr   r   Útwisted.trial.utilr   r  Ú
executableÚ_asBytesPathr'  r   rX   rl   Úgetattrr   r§   rß   rê   r  Ú
providedByr  r2  rF  r“  ro  rz  r~  r€  rŠ  rŽ  r°  rî  ré  r÷  r  r   rN  rQ   r%   r"   Ú<module>r~     sc  ðñ
ó
 Û Û Û 
Û ß >Ó >Ý ðÛÛð
 €CØ
€Cå $Ý +Ý .Ý 7Ý 5Ý Ý ,Ý ,ß 5Ý 3á�—‘Ó ×-Ñ-Ó/€ô.J�ô .JôbV�xô Vô*(˜(ô (ñ> ‰G�B˜ $Ó'Ô'Ð)FÓGôCV�Xó CVó HðCVôL]' ô ]'ô@2�xô 2ô.M-˜8ô M-ô`6 _ô 6ñ" Ø×"Ò" 7Ó+Ô+Ø2óô7�xó 7ó	ð7ôD+˜ô +ô.J< ô J<ôZ	ˆT×Ñô 	ô	�d×'Ñ'ô 	ô�Fô ÷ñ ÷ñ ô_:�Hô _:ñD ‰G�B˜	 4Ó(Ô(Ð*IÓJônA˜hó nAó KðnAñb ˆD×ÑÔÐNÓOôI�hó Ió PðIô<(�xô (ôV)W˜hô )WôXE.˜ô E.ôP<$�õ <$øðK ó Ø
€CØ
ƒCðús   ªH È
H ÈH 