Ë
    ojHˆ  ã                   ó$  — d Z ddlZddlZddlZddlZddlZddlmZm	Z	m
Z
mZ ddlmZ 	 ddlZddlZeZeZddlmZ ddlmZ ddlmZ ddlmZ dd	lmZ dd
lmZ ddlm Z  ddl!m"Z" ddl#m$Z$m%Z% ddl&m'Z(  e ejR                  «      jU                  «       Z+ G d„ de%«      Z, G d„ de%«      Z- G d„ de%«      Z. e e/edd«       d«       G d„ de%«      «       Z0 G d„ de%«      Z1 G d„ de%«      Z2 G d„ de%«      Z3 G d„ d e«      Z4 e ejj                  e«       d!«       G d"„ d#e%«      «       Z6 G d$„ d%e%«      Z7 G d&„ d'e%«      Z8 G d(„ d)ejr                  «      Z: G d*„ d+ejr                  «      Z; G d,„ d-e:«      Z< G d.„ d/«      Z= G d0„ d1«      Z> G d2„ d3e%«      Z? e e/ed4d«       d5«       G d6„ d7e%«      «       Z@ eej‚                   d8«       G d9„ d:e%«      «       ZB G d;„ d<e%«      ZC G d=„ d>e%«      ZD G d?„ d@e%«      ZE G dA„ dBe%«      ZFy# e$ r dZdZY �ŒØw xY w)Cz#
Tests for L{twisted.python.util}.
é    N)ÚIterableÚMappingÚMutableMappingÚSequence)ÚskipIf)Úreactor)ÚDeferred)ÚProcessDone)ÚIReactorProcess)ÚProcessProtocol)Úutil)ÚFilePath)ÚMockOS)ÚFailTestÚTestCase)Úsuppressc                   óh   — e Zd Zd„ Zd„ Zd„ Z eedu d«      d„ «       Zd„ Z	 ee
du d«      d	„ «       Zy)
Ú	UtilTestsc                 óZ   — g d¢}| j                  t        j                  |«      g d¢«       y )N)Úaé   Úabr   é   é   r   é   r   r   é   )r   r   r   r   r   r   r   )ÚassertEqualr   Úuniquify)ÚselfÚlistWithDupess     ú?/usr/lib/python3/dist-packages/twisted/python/test/test_util.pyÚtestUniqzUtilTests.testUniq+   s!   € Ú@ˆØ×ÑœŸ™ }Ó5Ò7QÕRó    c                 ó4  — | j                  t        j                  t        t        dd«      «       | j                  t        j                  t        t        dd«      «       	 t        j                  t        t        dd«       t        d«      ‚# t        $ r Y y w xY w)Nr   r   z,util.raises didn't raise when it should have)Ú
assertTruer   ÚraisesÚZeroDivisionErrorÚdivmodÚassertFalseÚ	TypeErrorr   ©r   s    r!   Ú
testRaisesz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                 óN   — | j                  t        j                  d«      d«       y)ú†
        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_uidFromNumericStringz#UtilTests.test_uidFromNumericString:   ó   € ð
 	×Ñœ×+Ñ+¨EÓ2°CÕ8r#   Nz0Username/UID conversion requires the pwd module.c                 óÄ   — t         j                  t        j                  «       «      }| j	                  t        j                  |j                  «      |j                  «       y)r.   N)	ÚpwdÚgetpwuidÚosÚgetuidr   r   r1   Úpw_nameÚpw_uid)r   Úpwents     r!   Útest_uidFromUsernameStringz$UtilTests.test_uidFromUsernameStringA   ó;   € ô —‘œRŸY™Y›[Ó)ˆØ×Ñœ×+Ñ+¨E¯M©MÓ:¸E¿L¹LÕIr#   c                 óN   — | j                  t        j                  d«      d«       y)ú†
        When L{gidFromString} is called with a base-ten string representation
        of an integer, it returns the integer.
        r/   r0   N)r   r   ÚgidFromStringr+   s    r!   Útest_gidFromNumericStringz#UtilTests.test_gidFromNumericStringJ   r3   r#   z2Group Name/GID conversion requires the grp module.c                 óÄ   — t         j                  t        j                  «       «      }| j	                  t        j                  |j                  «      |j                  «       y)r?   N)	ÚgrpÚgetgrgidr7   Úgetgidr   r   r@   Úgr_nameÚgr_gid)r   Úgrents     r!   Útest_gidFromGroupnameStringz%UtilTests.test_gidFromGroupnameStringQ   r=   r#   )Ú__name__Ú
__module__Ú__qualname__r"   r,   r2   r   r5   r<   rA   rC   rI   © 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                   ó   — e Zd ZdZd„ Zy)ÚNameToLabelTestsz#
    Tests for L{nameToLabel}.
    c                 ó‚   — g d¢}|D ]6  \  }}t        j                  |«      }| j                  ||d|›d|›d|›�«       Œ8 y)zK
        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_nameToLabelz!NameToLabelTests.test_nameToLabel`   sU   € ò
ˆð !ò 	V‰HˆC�Ü×"Ñ" 3Ó'ˆCØ×Ñ˜S #¨°c°W¸EÀ#ÀÈÈSÈGÐ'TÕUñ	Vr#   N)rJ   rK   rL   Ú__doc__r^   rM   r#   r!   rO   rO   [   s   „ ñóVr#   rO   c                   ó   — e Zd ZdZd„ Zy)ÚUntilConcludesTestsz:
    Tests for L{untilConcludes}, an C{EINTR} helper.
    c                 ól  ‡ — ˆ fd„}dg‰ _         d‰ _        ‰ j                  t        j                  |dd«      d«       ‰ j                  ‰ j                  d«       dt
        t        g‰ _         d‰ _        ‰ j                  t        j                  |dd«      d«       ‰ j                  ‰ j                  d«       y)a  
        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                 óž   •— ‰xj                   dz  c_         ‰j                  j                  «       }|� |t        j                  d«      ‚| |z   S )Nr   zInterrupted system call!)ÚcallsÚ
exceptionsÚpopÚerrnoÚEINTR)r   ÚbÚexcr   s      €r!   rQ   z3UntilConcludesTests.test_uninterruptably.<locals>.f}   sB   ø€ Ø�JŠJ˜!‰O�JØ—/‘/×%Ñ%Ó'ˆCØˆÙœ%Ÿ+™+Ð'AÓBÐBØ�q‘5ˆLr#   Nr   r   r   r   é   )re   rd   r   r   ÚuntilConcludesÚOSErrorÚIOError)r   rQ   s   ` r!   Útest_uninterruptablyz(UntilConcludesTests.test_uninterruptablyu   s•   ø€ ô	ð  ˜&ˆŒØˆŒ
Ø×Ñœ×,Ñ,¨Q°°1Ó5°qÔ9Ø×Ñ˜Ÿ™ QÔ'à¤¬'Ð2ˆŒØˆŒ
Ø×Ñœ×,Ñ,¨Q°°1Ó5°qÔ9Ø×Ñ˜Ÿ™ QÕ'r#   N)rJ   rK   rL   r_   ro   rM   r#   r!   ra   ra   p   s   „ ñó(r#   ra   r8   zgetuid/setuid not availablec                   ó4   — e Zd ZdZd„ Zd„ Zd„ Zd„ Zd„ Zd„ Z	y)	ÚSwitchUIDTestsz&
    Tests for L{util.switchUID}.
    c                 ó´   — t        «       | _        | j                  t        d| j                  «       | j                  t        d| j                  «       g | _        y )Nr7   Ú
initgroups)r   ÚmockosÚpatchr   rs   ÚinitgroupsCallsr+   s    r!   ÚsetUpzSwitchUIDTests.setUp•   s;   € Ü“hˆŒØ�
‰
”4˜˜tŸ{™{Ô+Ø�
‰
”4˜ t§¡Ô7Ø!ˆÕr#   c                 ó>   — | j                   j                  ||f«       y)zK
        Save L{util.initgroups} calls in C{self.initgroupsCalls}.
        N)rv   Úappend)r   ÚuidÚgids      r!   rs   zSwitchUIDTests.initgroups›   s   € ð 	×Ñ×#Ñ# S¨# JÕ/r#   c                 ó¸   — t        j                  dd«       | j                  | j                  dg«       | j                  | j                  j
                  dg«       y)zn
        L{util.switchUID} calls L{util.initgroups} and then C{os.setuid} with
        the given uid.
        éà.  N©r}   N)Úsetuidr}   )r   Ú	switchUIDr   rv   rt   Úactionsr+   s    r!   Útest_uidzSwitchUIDTests.test_uid¡   sH   € ô
 	�‰�u˜dÔ#Ø×Ñ˜×-Ñ-°¨Ô?Ø×Ñ˜Ÿ™×,Ñ,Ð/@Ð.AÕBr#   c                 óº   — t        j                  ddd«       | j                  | j                  dg«       | j                  | j                  j
                  dg«       y)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   rv   rt   ÚseteuidCallsr+   s    r!   Ú	test_euidzSwitchUIDTests.test_euidª   sH   € ô
 	�‰�u˜d DÔ)Ø×Ñ˜×-Ñ-°¨Ô?Ø×Ñ˜Ÿ™×1Ñ1°E°7Õ;r#   c                 óÊ  — | j                   j                  «       }t        j                  |d«       | j	                  | j
                  g «       | j	                  | j                   j                  g «       | j                  t        j                  g«      }| j	                  t        |«      d«       | j                  d|z  |d   d   «       | j                  d|z  |d   d   «       y)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)
rt   r8   r   r€   r   rv   r�   ÚflushWarningsÚlenÚassertIn)r   rz   ÚcurrentWarningss      r!   Útest_currentUIDz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                 óÌ  — | j                   j                  «       }t        j                  |dd«       | j	                  | j
                  g «       | j	                  | j                   j                  g «       | j                  t        j                  g«      }| j	                  t        |«      d«       | j                  d|z  |d   d   «       | j                  d|z  |d   d   «       y)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)
rt   Úgeteuidr   r€   r   rv   r„   rˆ   r‰   rŠ   )r   Úeuidr‹   s      r!   Útest_currentEUIDz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#   N)
rJ   rK   rL   r_   rw   rs   r‚   r…   rŒ   r�   rM   r#   r!   rq   rq   �   s(   „ ñò"ò0òCò<òTó"Vr#   rq   c                   ó.   — e Zd ZdZd„ Zd„ Zd„ Zd„ Zd„ Zy)ÚMergeFunctionMetadataTestsz-
    Tests for L{mergeFunctionMetadata}.
    c                 óª   ‡‡— t        «       Št        «       Šˆfd„}d	ˆfd„	}t        j                  ||«      }| j                   |dddd¬«      ‰«       y)
zt
        After merging C{foo}'s data into C{bar}, the returned function behaves
        as if it is C{bar}.
        c                  ó   •— ‰ S ©NrM   )Ú
foo_objects   €r!   rU   zQMergeFunctionMetadataTests.test_mergedFunctionBehavesLikeMergeTarget.<locals>.fooã   s	   ø€ ØÐr#   é
   c                 ó   •— |\  }}‰S r•   rM   )	ÚxÚyr   ÚcÚdÚer   ri   Ú
bar_objects	           €r!   ÚbarzQMergeFunctionMetadataTests.test_mergedFunctionBehavesLikeMergeTarget.<locals>.baræ   s   ø€ Ø‰FˆQ�ØÐr#   r   r   )r   r   )ÚquuxN)r—   )Úobjectr   ÚmergeFunctionMetadataÚassertIs)r   rU   rŸ   Úbazrž   r–   s       @@r!   Ú)test_mergedFunctionBehavesLikeMergeTargetzDMergeFunctionMetadataTests.test_mergedFunctionBehavesLikeMergeTargetÛ   sJ   ù€ ô
 “Xˆ
Ü“Xˆ
ô	õ	ô ×(Ñ(¨¨cÓ2ˆØ�‰‘c˜!˜Q ¨RÔ0°*Õ=r#   c                 ó–   — d„ }d„ }d|_         t        j                  ||«      }| j                  |j                   |j                   «       y)zd
        Merging C{foo} into C{bar} returns a function with C{foo}'s
        C{__module__}.
        c                   ó   — y r•   rM   rM   r#   r!   rU   z;MergeFunctionMetadataTests.test_moduleIsMerged.<locals>.fooó   ó   € Ør#   c                   ó   — y r•   rM   rM   r#   r!   rŸ   z;MergeFunctionMetadataTests.test_moduleIsMerged.<locals>.barö   r¨   r#   zsomewhere.elseN)rK   r   r¢   r   ©r   rU   rŸ   r¤   s       r!   Útest_moduleIsMergedz.MergeFunctionMetadataTests.test_moduleIsMergedí   s?   € ò	ò	ð *ˆŒä×(Ñ(¨¨cÓ2ˆØ×Ñ˜Ÿ™¨¯©Õ8r#   c                 óˆ   — d„ }d„ }t        j                  ||«      }| j                  |j                  |j                  «       y)zX
        Merging C{foo} into C{bar} returns a function with C{foo}'s docstring.
        c                   ó   — y)z&
            This is foo.
            NrM   rM   r#   r!   rU   z>MergeFunctionMetadataTests.test_docstringIsMerged.<locals>.foo  ó   � r#   c                   ó   — y)z&
            This is bar.
            NrM   rM   r#   r!   rŸ   z>MergeFunctionMetadataTests.test_docstringIsMerged.<locals>.bar  r®   r#   N)r   r¢   r   r_   rª   s       r!   Útest_docstringIsMergedz1MergeFunctionMetadataTests.test_docstringIsMergedþ   s8   € ò
	ò
	ô
 ×(Ñ(¨¨cÓ2ˆØ×Ñ˜Ÿ™ c§k¡kÕ2r#   c                 óˆ   — d„ }d„ }t        j                  ||«      }| j                  |j                  |j                  «       y)zS
        Merging C{foo} into C{bar} returns a function with C{foo}'s name.
        c                   ó   — y r•   rM   rM   r#   r!   rU   z9MergeFunctionMetadataTests.test_nameIsMerged.<locals>.foo  r¨   r#   c                   ó   — y r•   rM   rM   r#   r!   rŸ   z9MergeFunctionMetadataTests.test_nameIsMerged.<locals>.bar  r¨   r#   N)r   r¢   r   rJ   rª   s       r!   Útest_nameIsMergedz,MergeFunctionMetadataTests.test_nameIsMerged  s8   € ò
	ò	ô ×(Ñ(¨¨cÓ2ˆØ×Ñ˜Ÿ™ s§|¡|Õ4r#   c                 óX  — d„ }d|_         d|_        d„ }d|_        d|_        t        j                  ||«      }| j                  |j                   |j                   «       | j                  |j                  |j                  «       | j                  |j                  |j                  «       y)zv
        Merging C{foo} into C{bar} returns a function with C{bar}'s
        dictionary, updated by C{foo}'s.
        c                   ó   — y r•   rM   rM   r#   r!   rU   zGMergeFunctionMetadataTests.test_instanceDictionaryIsMerged.<locals>.foo$  r¨   r#   r   r   c                   ó   — y r•   rM   rM   r#   r!   rŸ   zGMergeFunctionMetadataTests.test_instanceDictionaryIsMerged.<locals>.bar*  r¨   r#   r   r   N)r   ri   r›   r   r¢   r   rª   s       r!   Útest_instanceDictionaryIsMergedz:MergeFunctionMetadataTests.test_instanceDictionaryIsMerged  s†   € ò	ð ˆŒØˆŒò	ð ˆŒØˆŒä×(Ñ(¨¨cÓ2ˆØ×Ñ˜Ÿ™ §¡Ô&Ø×Ñ˜Ÿ™ §¡Ô&Ø×Ñ˜Ÿ™ §¡Õ&r#   N)	rJ   rK   rL   r_   r¥   r«   r°   r´   r¸   rM   r#   r!   r’   r’   Ö   s    „ ñò>ò$9ò"3ò$5ó'r#   r’   c                   ó   — e Zd ZdZd„ Zy)ÚOrderedDictTestsz(
    Tests for L{util.OrderedDict}.
    c                 óì   — ddl m} | | j                  | j                  g¬«      }| j	                  |d   d   d«       | j	                  |d   d   t
        «       | j	                  t        |«      d«       y)	z4
        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Á   z OrderedDictTests.test_deprecated;  sx   € õ 	4áà×,Ñ,À×AUÑAUÐ@VÐ,ÓWˆØ×ÑØ˜AÑ˜yÑ)ð;ô	
ð
 	×Ñ˜¨Ñ+¨JÑ7Ô9KÔLØ×Ñœ˜_Ó-¨qÕ1r#   N)rJ   rK   rL   r_   rÁ   rM   r#   r!   rº   rº   6  s   „ ñó2r#   rº   c                   ó.   — e Zd ZdZd„ Zd„ Zd„ Zd„ Zd„ Zy)ÚInsensitiveDictTestsz,
    Tests for L{util.InsensitiveDict}.
    c                 ó$  — t        j                  «       }| j                  t        |t        «      «       | j                  t        |t
        «      «       | j                  t        |t        «      «       | j                  t        |t        «      «       y)zN
        L{util.InsensitiveDict} implements L{typing.MutableMapping}.
        N)	r   ÚInsensitiveDictr%   Ú
isinstancer   r   r   r)   r   )r   Údcts     r!   Útest_abczInsensitiveDictTests.test_abcR  s`   € ô ×"Ñ"Ó$ˆØ�‰œ
 3¬Ó1Ô2Ø�‰œ
 3¬Ó0Ô1Ø�‰œ
 3¬Ó7Ô8Ø×Ñœ C¬Ó2Õ3r#   c                 ó  — t        j                  ddddidœd¬«      }| j                  |d   ddi«       | j                  |d   d«       | j                  |j                  «       |«       | j                  |d   |j	                  d«      «       | j                  d|«       | j                  d|«       t        t        |«      |t         j                  d	œ«      }| j                  ||«       g d
¢}|D ]G  }| j                  ||j                  «       «       | j                  |||   f|j                  «       «       ŒI | j                  t        |«      t        |«      «       |d= |d= | j                  |j                  «       dg«       y)zr
        L{util.InsensitiveDict} preserves the case of keys if constructed with
        C{preserve=True}.
        rŸ   r   r   ©rV   r   Úfnz©ÚpreserverÌ   rU   rV   )rÈ   rÆ   )rV   rÌ   r   N)r   rÆ   r   ÚcopyÚgetrŠ   ÚevalÚreprÚkeysÚitemsr‰   )r   rÈ   ÚresultrÓ   r™   s        r!   Útest_preservez"InsensitiveDictTests.test_preserve\  sT  € ô
 ×"Ñ"¨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ñó
ˆð 	×Ñ˜ Ô%â ˆØò 	4ˆAØ�M‰M˜!˜SŸX™X›ZÔ(Ø�M‰M˜1˜c !™f˜+ s§y¡y£{Õ3ð	4ð 	×Ñœ˜T›¤C¨£HÔ-Ø�ˆFØ�ˆJØ×Ñ˜Ÿ™› e WÕ-r#   c                 ót  — t        j                  ddddidœd¬«      }g d¢}|D ]G  }| j                  ||j                  «       «       | j                  |||   f|j	                  «       «       ŒI | j                  t        |«      t        |«      «       |d= |d= | j                  |j                  «       d	g«       y
)z|
        L{util.InsensitiveDict} does not preserves the case of keys if
        constructed with C{preserve=False}.
        rŸ   r   r   rË   r   rÍ   )rU   rÌ   r   rU   rÌ   N)r   rÆ   rŠ   rÓ   rÔ   r   r‰   )r   rÈ   rÓ   r™   s       r!   Útest_noPreservez$InsensitiveDictTests.test_noPreserve{  s¦   € ô
 ×"Ñ"¨5°QÀÀ1¸vÑ#FÐQRÔSˆÚ ˆØò 	4ˆAØ�M‰M˜!˜SŸX™X›ZÔ(Ø�M‰M˜1˜c !™f˜+ s§y¡y£{Õ3ð	4ð 	×Ñœ˜T›¤C¨£HÔ-Ø�ˆFØ�ˆJØ×Ñ˜Ÿ™› e WÕ-r#   c                 ó¦   — t        j                  d¬«      }d|d<   | j                  |d   d«       | j                  |j                  «       dg«       y)z4
        Unicode keys are case insensitive.
        FrÍ   r   rV   ÚFOOrU   N©r   rÆ   r   rÓ   ©r   rœ   s     r!   Útest_unicodez!InsensitiveDictTests.test_unicodeŠ  sI   € ô × Ñ ¨%Ô0ˆØˆˆ%‰Ø×Ñ˜˜5™ 1Ô%Ø×Ñ˜Ÿ™› E 7Õ+r#   c                 ó¦   — t        j                  d¬«      }d|d<   | j                  |d   d«       | j                  |j                  «       dg«       y)z2
        Bytes keys are case insensitive.
        FrÍ   r   s   Foos   FOOs   fooNrÛ   rÜ   s     r!   Ú
test_byteszInsensitiveDictTests.test_bytes“  sI   € ô × Ñ ¨%Ô0ˆØˆˆ&‰	Ø×Ñ˜˜6™ AÔ&Ø×Ñ˜Ÿ™› F 8Õ,r#   N)	rJ   rK   rL   r_   rÉ   rÖ   rØ   rÝ   rß   rM   r#   r!   rÄ   rÄ   M  s    „ ñò4ò.ò>.ò,ó-r#   rÄ   c                   ó"   — e Zd ZdZd„ Zd„ Zd„ Zy)ÚPasswordTestingProcessProtocolz’
    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   — g | _         | j                  j                  d«       y )Ns   secret
)ÚoutputÚ	transportÚwriter+   s    r!   ÚconnectionMadez-PasswordTestingProcessProtocol.connectionMade£  s   € ØˆŒØ�‰×Ñ˜[Õ)r#   c                 ó>   — | j                   j                  ||f«       y r•   )rã   ry   )r   Úfdrã   s      r!   ÚchildDataReceivedz0PasswordTestingProcessProtocol.childDataReceived§  s   € Ø�‰×Ñ˜B ˜<Õ(r#   c                 óR   — | j                   j                  || j                  f«       y r•   )ÚfinishedÚcallbackrã   )r   Úreasons     r!   ÚprocessEndedz+PasswordTestingProcessProtocol.processEndedª  s   € Ø�‰×Ñ ¨¯©Ð4Õ5r#   N)rJ   rK   rL   r_   ræ   ré   rî   rM   r#   r!   rá   rá   �  s   „ ñò
*ò)ó6r#   rá   z,Process support required to test getPasswordc                   ó   — e Zd Zd„ Zy)ÚGetPasswordTestsc           	      ó6  ‡ — t        «       }t        «       |_        t        j                  |t
        t
        ddgdt        j                  j                  t        j                  «      j                  d«      i¬«       ˆ fd„}|j                  j                  |«      S )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                 ó^   •— | \  }}|j                  t        «       ‰j                  d|«       y )N)r   s   secret)Útrapr
   rŠ   )rÕ   rí   rã   r   s      €r!   ÚprocessFinishedz4GetPasswordTests.test_stdin.<locals>.processFinishedÌ  s'   ø€ Ø%ÑˆV�VØ�K‰KœÔ$Ø�M‰M˜.¨&Õ1r#   )rá   r	   rë   r   ÚspawnProcessÚpyExer7   ÚpathsepÚjoinÚsysÚpathÚencodeÚaddCallback)r   Úprö   s   `  r!   Ú
test_stdinzGetPasswordTests.test_stdin³  s|   ø€ ô +Ó,ˆÜ“ZˆŒ
Ü×ÑØÜäØð,ð		ð ¤§
¡
§¡´·±Ó 9× @Ñ @ÀÓ HÐIõ	
ô 	2ð
 �z‰z×%Ñ% oÓ6Ð6r#   N)rJ   rK   rL   r   rM   r#   r!   rð   rð   ®  s   „ ó
7r#   rð   c                   ó   — e Zd Zd„ Zy)ÚSearchUpwardsTestsc                 ó´  — t        j                  d«       t        dd«      j                  «        t        dd«      j                  «        t        dd«      j                  «        t        j                  d«       t        j                  d«       t        j                  d«       t        j                  d	«       t        j                  dd
gddg¬«      }t         j                  j                  d«      t         j                  z   }| j                  ||«       t        j                  d«       t        j                  dd
gddg¬«      }d }| j                  ||«       y )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)r7   ÚmakedirsÚopenÚcloseÚmkdirr   r  rü   ÚabspathÚsepr   ÚshutilÚrmtree)r   ÚactualÚexpecteds      r!   ÚtestSearchupwardsz$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#   N)rJ   rK   rL   r  rM   r#   r!   r  r  Ô  s   „ ó+r#   r  c                   ó0   — e Zd Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zy)ÚIntervalDifferentialTestsc                 ó˜   — t        t        j                  g d«      «      }t        d«      D ]  }| j	                  t        |«      d«       Œ y )Nr—   r0   ©r—   N©Úiterr   ÚIntervalDifferentialÚranger   Únext©r   rœ   Úis      r!   ÚtestDefaultz%IntervalDifferentialTests.testDefaultì  s@   € Ü”×*Ñ*¨2¨rÓ2Ó3ˆÜ�s“ò 	2ˆAØ×ÑœT !›W jÕ1ñ	2r#   c                 óš   — t        t        j                  dgd«      «      }t        d«      D ]  }| j	                  t        |«      d«       Œ y )Nrk   r—   r0   ©rk   r   r  r  s      r!   Ú
testSinglez$IntervalDifferentialTests.testSingleñ  sB   € Ü”×*Ñ*¨A¨3°Ó3Ó4ˆÜ�s“ò 	.ˆAØ×ÑœT !›W fÕ-ñ	.r#   c                 óò  — t        t        j                  ddgd«      «      }t        d«      D �]G  }| j	                  t        |«      d«       | j	                  t        |«      d«       | j	                  t        |«      d«       | j	                  t        |«      d«       | j	                  t        |«      d	«       | j	                  t        |«      d«       | j	                  t        |«      d
«       | j	                  t        |«      d«       | j	                  t        |«      d«       | j	                  t        |«      d«       | j	                  t        |«      d«       | j	                  t        |«      d«       �ŒJ y )Nrk   é   r—   r0   r!  ©r   r   ©r   r   )r   r   ©r   r   ©r   r   ©r   r   )r   r   ©r   r   ©r   r   r  r  s      r!   ÚtestPairz"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                 ól  — t        t        j                  g d¢d«      «      }t        d«      D �]  }| j	                  t        |«      d«       | j	                  t        |«      d«       | j	                  t        |«      d«       | j	                  t        |«      d«       | j	                  t        |«      d«       | j	                  t        |«      d«       | j	                  t        |«      d«       | j	                  t        |«      d«       | j	                  t        |«      d«       | j	                  t        |«      d«       | j	                  t        |«      d«       | j	                  t        |«      d«       | j	                  t        |«      d«       | j	                  t        |«      d«       | j	                  t        |«      d«       | j	                  t        |«      d«       | j	                  t        |«      d«       | j	                  t        |«      d«       | j	                  t        |«      d«       �Œ y )	N)r   r   rk   r—   r0   r*  r+  )r   r   r'  )r   r   r  r  s      r!   Ú
testTriplez$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                 ól  — t        t        j                  g d«      «      }| j                  t	        |«      d«       |j                  d«       | j                  t	        |«      d«       | j                  t	        |«      d«       |j                  d«       | j                  t	        |«      d«       | j                  t	        |«      d«       | j                  t	        |«      d«       | j                  t	        |«      d«       | j                  t	        |«      d«       | j                  t	        |«      d«       y )Nr—   r  r   r&  r   r+  )r  r   r  r   r  ÚaddIntervalrÜ   s     r!   Ú
testInsertz$IntervalDifferentialTests.testInsert  så   € Ü”×*Ñ*¨2¨rÓ2Ó3ˆØ×Ñœ˜a› *Ô-Ø	�‰�aÔØ×Ñœ˜a› &Ô)Ø×Ñœ˜a› &Ô)Ø	�‰�aÔØ×Ñœ˜a› &Ô)Ø×Ñœ˜a› &Ô)Ø×Ñœ˜a› &Ô)Ø×Ñœ˜a› &Ô)Ø×Ñœ˜a› &Ô)Ø×Ñœ˜a› &Õ)r#   c                 ó  — t        t        j                  ddgd«      «      }| j                  t	        |«      d«       | j                  t	        |«      d«       | j                  t	        |«      d«       |j                  d«       | j                  t	        |«      d«       | j                  t	        |«      d«       |j                  d«       | j                  t	        |«      d	«       | j                  t        |j
                  d«       y )
Nr   rk   r—   r&  r%  r'  r)  r!  r  )r  r   r  r   r  ÚremoveIntervalÚassertRaisesÚ
ValueErrorrÜ   s     r!   Ú
testRemovez$IntervalDifferentialTests.testRemove+  sÉ   € Ü”×*Ñ*¨A¨q¨6°2Ó6Ó7ˆØ×Ñœ˜a› &Ô)Ø×Ñœ˜a› &Ô)Ø×Ñœ˜a› &Ô)Ø	×Ñ˜ÔØ×Ñœ˜a› &Ô)Ø×Ñœ˜a› &Ô)Ø	×Ñ˜ÔØ×Ñœ˜a› *Ô-Ø×Ñœ* a×&6Ñ&6¸Õ;r#   N)	rJ   rK   rL   r  r"  r,  r.  r1  r6  rM   r#   r!   r  r  ë  s    „ ò2ò
.ò
.ò .ò.*ó
<r#   r  c                   ó   — e Zd ZdZdZd„ Zy)ÚRecordz8
    Trivial user of L{FancyEqMixin} used by tests.
    ©r   ri   c                 ó    — || _         || _        y r•   r9  ©r   r   ri   s      r!   Ú__init__zRecord.__init__?  ó   € ØˆŒØˆ�r#   N©rJ   rK   rL   r_   ÚcompareAttributesr<  rM   r#   r!   r8  r8  8  ó   „ ñð #Ðór#   r8  c                   ó   — e Zd ZdZdZd„ Zy)ÚDifferentRecordzL
    Trivial user of L{FancyEqMixin} which is not related to L{Record}.
    r9  c                 ó    — || _         || _        y r•   r9  r;  s      r!   r<  zDifferentRecord.__init__K  r=  r#   Nr>  rM   r#   r!   rB  rB  D  r@  r#   rB  c                   ó   — e Zd ZdZy)ÚDerivedRecordz@
    A class with an inheritance relationship to L{Record}.
    N)rJ   rK   rL   r_   rM   r#   r!   rE  rE  P  s   „ òr#   rE  c                   ó    — e Zd ZdZdedefd„Zy)ÚEqualToEverythingzQ
    A class the instances of which consider themselves equal to everything.
    ÚotherÚreturnc                  ó   — y)NTrM   ©r   rH  s     r!   Ú__eq__zEqualToEverything.__eq__[  s   € Ør#   N©rJ   rK   rL   r_   r¡   ÚboolrL  rM   r#   r!   rG  rG  V  s   „ ñð˜Fð  tô r#   rG  c                   ó    — e Zd ZdZdedefd„Zy)ÚEqualToNothingzN
    A class the instances of which consider themselves equal to nothing.
    rH  rI  c                  ó   — y)NFrM   rK  s     r!   rL  zEqualToNothing.__eq__d  s   € Ør#   NrM  rM   r#   r!   rP  rP  _  s   „ ñð˜Fð  tô r#   rP  c                   óF   — e Zd ZdZd„ Zd„ Zd„ Zd„ Zd„ Zd„ Z	d„ Z
d	„ Zd
„ Zy)ÚEqualityTestsz$
    Tests for L{FancyEqMixin}.
    c                 ó  —  G d„ dt         j                  «      }| j                   |«        |«       k(  «       | j                   |«        |«       k7  «        |«       }| j                  ||k(  «       | j                  ||k7  «       y)z�
        Instances of a class which mixes in L{FancyEqMixin} but which
        defines no comparison attributes compare by identity.
        c                   ó   — e Zd Zy)ú*EqualityTests.test_identity.<locals>.EmptyN)rJ   rK   rL   rM   r#   r!   ÚEmptyrV  s  s   „ Ør#   rW  N)r   ÚFancyEqMixinr)   r%   )r   rW  Úemptys      r!   Útest_identityzEqualityTests.test_identitym  sk   € ô	”D×%Ñ%ô 	ð 	×Ñ™›¡E£GÑ+Ô,Ø�‰™›¡5£7Ñ*Ô+Ù“ˆØ�‰˜ ™Ô'Ø×Ñ˜ %™Õ(r#   c                 óD  — | j                  t        dd«      t        dd«      k(  «       | j                  t        dd«      t        dd«      k(  «       | j                  t        dd«      t        dd«      k(  «       | j                  t        dd«      t        dd«      k(  «       y)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%   r8  r)   r+   s    r!   Útest_equalityzEqualityTests.test_equality|  s~   € ð 	�‰œ˜q !›¬¨q°!«Ñ4Ô5Ø×Ñœ  1›¬°°1«Ñ5Ô6Ø×Ñœ  1›¬°°1«Ñ5Ô6Ø×Ñœ  1›¬°°1«Ñ5Õ6r#   c                 óD  — | j                  t        dd«      t        dd«      k7  «       | j                  t        dd«      t        dd«      k7  «       | j                  t        dd«      t        dd«      k7  «       | j                  t        dd«      t        dd«      k7  «       y)z
        Inequality between instances of a particular L{record} should be
        defined as the negation of equality.
        r   r   r   r   N)r)   r8  r%   r+   s    r!   Útest_unequalityzEqualityTests.test_unequality‡  sz   € ð
 	×Ñœ  1›¬°°1«Ñ5Ô6Ø�‰œ˜q !›¬¨q°!«Ñ4Ô5Ø�‰œ˜q !›¬¨q°!«Ñ4Ô5Ø�‰œ˜q !›¬¨q°!«Ñ4Õ5r#   c                 óT   — | j                  t        dd«      t        dd«      k(  «       y)zo
        Instances of different classes which mix in L{FancyEqMixin} should not
        compare equal.
        r   r   N)r)   r8  rB  r+   s    r!   Útest_differentClassesEqualityz+EqualityTests.test_differentClassesEquality‘  s$   € ð
 	×Ñœ  1›¬¸¸AÓ)>Ñ>Õ?r#   c                 óT   — | j                  t        dd«      t        dd«      k7  «       y)zm
        Instances of different classes which mix in L{FancyEqMixin} should
        compare unequal.
        r   r   N)r%   r8  rB  r+   s    r!   Útest_differentClassesInequalityz-EqualityTests.test_differentClassesInequality˜  s"   € ð
 	�‰œ˜q !›¬¸¸1Ó(=Ñ=Õ>r#   c                 óD  — | j                  t        dd«      t        dd«      k(  «       | j                  t        dd«      t        dd«      k(  «       | j                  t        dd«      t        dd«      k(  «       | j                  t        dd«      t        dd«      k(  «       y)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%   r8  rE  r)   r+   s    r!   Útest_inheritedClassesEqualityz+EqualityTests.test_inheritedClassesEqualityŸ  s‚   € ð 	�‰œ˜q !›¬°a¸Ó(;Ñ;Ô<Ø×Ñœ  1›¬°q¸!Ó)<Ñ<Ô=Ø×Ñœ  1›¬°q¸!Ó)<Ñ<Ô=Ø×Ñœ  1›¬°q¸!Ó)<Ñ<Õ=r#   c                 óD  — | j                  t        dd«      t        dd«      k7  «       | j                  t        dd«      t        dd«      k7  «       | j                  t        dd«      t        dd«      k7  «       | j                  t        dd«      t        dd«      k7  «       y)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)   r8  rE  r%   r+   s    r!   Útest_inheritedClassesInequalityz-EqualityTests.test_inheritedClassesInequalityª  s~   € ð 	×Ñœ  1›¬°q¸!Ó)<Ñ<Ô=Ø�‰œ˜q !›¬°a¸Ó(;Ñ;Ô<Ø�‰œ˜q !›¬°a¸Ó(;Ñ;Ô<Ø�‰œ˜q !›¬°a¸Ó(;Ñ;Õ<r#   c                 óœ   — | j                  t        dd«      t        «       k(  «       | j                  t        dd«      t	        «       k(  «       y)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%   r8  rG  r)   rP  r+   s    r!   Ú(test_rightHandArgumentImplementsEqualityz6EqualityTests.test_rightHandArgumentImplementsEqualityµ  s;   € ð 	�‰œ˜q !›Ô(9Ó(;Ñ;Ô<Ø×Ñœ  1›¬Ó)9Ñ9Õ:r#   c                 óœ   — | j                  t        dd«      t        «       k7  «       | j                  t        dd«      t	        «       k7  «       y)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)   r8  rG  r%   rP  r+   s    r!   Ú*test_rightHandArgumentImplementsUnequalityz8EqualityTests.test_rightHandArgumentImplementsUnequality¿  s;   € ð 	×Ñœ  1›Ô):Ó)<Ñ<Ô=Ø�‰œ˜q !›¬Ó(8Ñ8Õ9r#   N)rJ   rK   rL   r_   rZ  r\  r^  r`  rb  rd  rf  rh  rj  rM   r#   r!   rS  rS  h  s5   „ ñò)ò	7ò6ò@ò?ò	>ò	=ò;ó:r#   rS  rŽ   zgeteuid/seteuid not availablec                   óL   — e Zd ZdZd„ Zd„ Zd„ Zd„ Zd„ Zd„ Z	d„ Z
d	„ Zd
„ Zd„ Zy)ÚRunAsEffectiveUserTestsz;
    Test for the L{util.runAsEffectiveUser} function.
    c                 óz  — t        «       | _        | j                  t        d| j                  j                  «       | j                  t        d| j                  j
                  «       | j                  t        d| j                  j                  «       | j                  t        d| j                  j                  «       y )NrŽ   ÚgetegidÚseteuidÚsetegid)r   rt   ru   r7   rŽ   rn  ro  rp  r+   s    r!   rw   z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                 óÌ   — | j                  ||k(  xs || j                  j                  d   k(  «       | j                  ||k(  xs || j                  j                  d   k(  «       y)zF
        Check if wanted UID/GID matched start or saved ones.
        éÿÿÿÿN)r%   rt   r„   ÚsetegidCalls)r   ÚstartUIDÚstartGIDÚwantUIDÚwantGIDs        r!   Ú_securedFunctionz(RunAsEffectiveUserTests._securedFunction×  sZ   € ð 	�‰˜ 8Ñ+ÒV¨w¸$¿+¹+×:RÑ:RÐSUÑ:VÑ/VÔWØ�‰˜ 8Ñ+ÒV¨w¸$¿+¹+×:RÑ:RÐSUÑ:VÑ/VÕWr#   c                 óX   — t        j                  ddd„ «      }| j                  |d«       y)zo
        L{util.runAsEffectiveUser} forwards the result obtained by calling the
        given function
        r   c                   ó   — y)Nr   rM   rM   r#   r!   ú<lambda>z<RunAsEffectiveUserTests.test_forwardResult.<locals>.<lambda>ã  r®   r#   r   N©r   ÚrunAsEffectiveUserr   ©r   rÕ   s     r!   Útest_forwardResultz*RunAsEffectiveUserTests.test_forwardResultÞ  s(   € ô
 ×(Ñ(¨¨A©yÓ9ˆØ×Ñ˜ Õ#r#   c                 óZ   — t        j                  ddd„ d«      }| j                  |d«       y)ze
        L{util.runAsEffectiveUser} pass the given parameters to the given
        function.
        r   c                 ó   — d| z  S )Nr   rM   )r™   s    r!   r{  z=RunAsEffectiveUserTests.test_takeParameters.<locals>.<lambda>ë  s
   € ¸¸Q¹€ r#   r   r   Nr|  r~  s     r!   Útest_takeParametersz+RunAsEffectiveUserTests.test_takeParametersæ  s*   € ô
 ×(Ñ(¨¨A©ÀÓBˆØ×Ñ˜ Õ#r#   c                 ó`   — t        j                  dddd„dd¬«      }| j                  |d«       y)	zg
        L{util.runAsEffectiveUser} pass the keyword parameters to the given
        function.
        r   c                 ó   — | |z  |z  S r•   rM   )r™   rš   Úzs      r!   r{  zDRunAsEffectiveUserTests.test_takesKeyworkArguments.<locals>.<lambda>ó  s   € À1ÀqÁ5È1Á9€ r#   r   r   )r…  r   Nr(  r|  r~  s     r!   Útest_takesKeyworkArgumentsz2RunAsEffectiveUserTests.test_takesKeyworkArgumentsî  s.   € ô
 ×(Ñ(¨¨AÒ/LÈaÐSTÔUˆØ×Ñ˜ Õ#r#   c           	      ón  — || j                   _        || j                   _        t        j                  ||| j
                  ||||«       | j                  | j                   j                  |«       | j                  | j                   j                  |«       g | j                   _        g | j                   _        y)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)	rt   r�   Úegidr   r}  rx  r   r„   rs  )r   rt  ru  rv  rw  ÚexpectedUIDSwitchesÚexpectedGIDSwitchess          r!   Ú_testUIDGIDSwitchz)RunAsEffectiveUserTests._testUIDGIDSwitchö  s•   € ð $ˆ�‰ÔØ#ˆ�‰ÔÜ×ÑØØØ×!Ñ!ØØØØô	
ð 	×Ñ˜Ÿ™×1Ñ1Ð3FÔGØ×Ñ˜Ÿ™×1Ñ1Ð3FÔGØ#%ˆ�‰Ô Ø#%ˆ�‰Õ r#   c           	      óÄ   — | j                  ddddg g «       | j                  ddddddgg «       | j                  ddddg ddg«       | j                  ddddddgddg«       y)zL
        Check UID/GID switches when current effective UID is root.
        r   r   N©r‹  r+   s    r!   Ú	test_rootz!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           	      óÈ   — | j                  ddddddgg «       | j                  ddddg g «       | j                  ddddg d¢ddg«       | j                  ddddg d¢ddg«       y)zP
        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_UIDz RunAsEffectiveUserTests.test_UID  sp   € ð 	×Ñ˜q ! Q¨¨A¨q¨6°2Ô6Ø×Ñ˜q ! Q¨¨2¨rÔ2Ø×Ñ˜q ! Q¨ª<¸!¸Q¸Ô@Ø×Ñ˜q ! Q¨ª<¸!¸Q¸Õ@r#   c           	      óÄ   — | j                  ddddg ddg«       | j                  ddddg g «       | j                  ddddddgg «       | j                  ddddddgddg«       y)zP
        Check UID/GID switches when current effective GID is non-root.
        r   r   r   Nr�  r+   s    r!   Útest_GIDz 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           	      ó`  — | j                  ddddddgddg«       | j                  ddddddgg «       | j                  ddddg d¢ddg«       | j                  ddddg g «       | j                  ddddg d¢g «       | j                  ddddg d¢ddg«       | j                  ddddg d¢ddg«       y)zT
        Check UID/GID switches when current effective UID/GID is non-root.
        r   r   r�  r   r‘  Nr�  r+   s    r!   Útest_UIDGIDz#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#   N)rJ   rK   rL   r_   rw   rx  r  r‚  r†  r‹  rŽ  r’  r”  r–  rM   r#   r!   rl  rl  Ê  s<   „ ñò7òXò$ò$ò$ò&ò<;òAò;ó
Ar#   rl  z.stdlib support for initgroups is not availablec                   ó   — e Zd ZdZd„ Zd„ Zy)ÚInitGroupsTestsz'
    Tests for L{util.initgroups}.
    c                 ó‚  ‡— g Šˆfd„}| j                  t        d|«       g }| j                  t        d|j                  «       t        j                  t	        j
                  «       d«       | j                  ‰t        j                  t	        j
                  «       «      j                  dfg«       | j                  |«       y)zc
        Calling L{util.initgroups} will call the underlying stdlib
        implmentation.
        c                 ó,   •— ‰j                  | |f«       y r•   )ry   )r™   rš   rd   s     €r!   ÚmockInitgroupsz?InitGroupsTests.test_initgroupsInStdlib.<locals>.mockInitgroupsI  s   ø€ Ø�L‰L˜!˜Q˜Õ r#   Ú_initgroupsÚ	setgroupsr   N)ru   r   ry   rs   r7   r8   r   r5   r6   r9   r)   )r   r›  ÚsetgroupsCallsrd   s      @r!   Útest_initgroupsInStdlibz'InitGroupsTests.test_initgroupsInStdlibB  s‹   ø€ ð
 ˆô	!ð 	�
‰
”4˜¨Ô7ØˆØ�
‰
”4˜ n×&;Ñ&;Ô<ä�‰œŸ	™	› QÔ'Ø×Ñ˜¤#§,¡,¬r¯y©y«{Ó";×"CÑ"CÀQÐ!GÐ HÔIØ×Ñ˜Õ(r#   c                 ót   — | j                  t        t        j                  t	        j
                  «       d«       y)zN
        Calling L{util.initgroups} with None for gid gives an error.
        N)r4  r*   r   rs   r7   r8   r+   s    r!   Útest_initgroupsNoneGidz&InitGroupsTests.test_initgroupsNoneGidT  s"   € ð 	×Ñœ)¤T§_¡_´b·i±i³kÀ4ÕHr#   N)rJ   rK   rL   r_   rŸ  r¡  rM   r#   r!   r˜  r˜  <  s   „ ñò)ó$Ir#   r˜  c                   ó<   — e Zd ZdZd„ Zd„ Z eed¬«      ge_        y)ÚDeprecationTestsz;
    Tests for deprecations in C{twisted.python.util}.
    c                 ó  — t        j                  «        | j                  | j                  g¬«      }| j	                  |d   d   d«       | j	                  |d   d   t
        «       | j	                  t        |«      d«       y)z6
        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¦  z#DeprecationTests.test_getPluginDirs`  sƒ   € ô 	×ÑÔØ×,Ñ,Ø $× 7Ñ 7Ð8ð -ó 
ˆð 	×ÑØ˜AÑ˜yÑ)ØTô	
ð 	×Ñ˜¨Ñ+¨JÑ7Ô9KÔLØ×Ñœ˜_Ó-¨qÕ1r#   c                 ó  — t        j                  «        | j                  | j                  g¬«      }| j	                  |d   d   d«       | j	                  |d   d   t
        «       | j	                  t        |«      d«       y)z5
        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ª  z"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‡   N)	rJ   rK   rL   r_   r¦  rª  ÚSUPPRESSrÂ   r   rM   r#   r!   r£  r£  [  s,   „ ñò2ò2ñ  	Ø'ØEô	
ð"ÐÕr#   r£  c                   óL   — e Zd ZdZ eej                  «      Zd„ Zd„ Zd„ Z	d„ Z
y)ÚSuppressedWarningsTestsz6
    Tests for L{util.runWithWarningsSuppressed}.
    c                 óØ   — di fdi fg}| j                  |t        j                  d«       | j                  |t        j                  d«       | j                  g | j	                  «       «       y)zŽ
        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_runWithWarningsSuppressedFilteredz>SuppressedWarningsTests.test_runWithWarningsSuppressedFiltered�  s^   € ð
 *¨2Ð.Ð1FÈÐ0KÐLˆØ×&Ñ& w´·±¸|ÔLØ×&Ñ& w´·±¸|ÔLØ×Ñ˜˜T×/Ñ/Ó1Õ2r#   c                 óÄ   — di fdi fg}| j                  |t        j                  d«       | j                  dg| j	                  «       D �cg c]  }|d   ‘Œ	 c}«       yc c}w )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·  r  s      r!   Ú(test_runWithWarningsSuppressedUnfilteredz@SuppressedWarningsTests.test_runWithWarningsSuppressedUnfiltered—  s]   € ð
 *¨2Ð.Ð1FÈÐ0KÐLˆØ×&Ñ& w´·±¸~ÔNØ×Ñ˜.Ð)À$×BTÑBTÓBVÖ+W¸Q¨A¨i«LÒ+WÕXùÒ+Ws   Á	A
c                 óJ   — | j                  | j                  g d„ «      d«       y)zd
        C{runWithWarningsSuppressed} returns the result of the function it
        called.
        c                   ó   — y)Nr   rM   rM   r#   r!   r{  z:SuppressedWarningsTests.test_passThrough.<locals>.<lambda>¥  r®   r#   r   N)r   r´  r+   s    r!   Útest_passThroughz(SuppressedWarningsTests.test_passThrough   s!   € ð
 	×Ñ˜×7Ñ7¸¹IÓFÈÕJr#   c                 óÒ   — di fdi fg}| j                  |d„ «       t        j                  d«       | j                  dg| j	                  «       D �cg c]  }|d   ‘Œ	 c}«       yc c}w )zk
        Once C{runWithWarningsSuppressed} has returned, it no longer
        suppresses warnings.
        r¯  r±  c                   ó   — y r•   rM   rM   r#   r!   r{  z<SuppressedWarningsTests.test_noSideEffects.<locals>.<lambda>­  r®   r#   r²  r‡   Nr³  rº  s      r!   Útest_noSideEffectsz*SuppressedWarningsTests.test_noSideEffects§  sb   € ð
 *¨2Ð.Ð1FÈÐ0KÐLˆØ×&Ñ& w±Ô=Ü�‰�lÔ#Ø×Ñ˜,˜À×@RÑ@RÓ@TÖ)U¸1¨!¨I«,Ò)UÕVùÒ)Us   ÁA$
N)rJ   rK   rL   r_   Ústaticmethodr   r´  r¸  r»  r¾  rÁ  rM   r#   r!   r­  r­  †  s1   „ ññ !-¨T×-KÑ-KÓ LÐò3òYòKóWr#   r­  c                   ó.   — e Zd ZdZd„ Zd„ Zd„ Zd„ Zd„ Zy)ÚFancyStrMixinTestsz*
    Tests for L{util.FancyStrMixin}.
    c                 óv   —  G d„ dt         j                  «      }| j                  t         |«       «      d«       y)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                   ó   — e Zd ZdZdZdZy)ú6FancyStrMixinTests.test_sequenceOfStrings.<locals>.Foo©ÚfirstÚsecondr   ÚhelloN©rJ   rK   rL   ÚshowAttributesrÉ  rÊ  rM   r#   r!   rV   rÇ  ½  ó   „ Ø0ˆNØˆEØ‰Fr#   rV   z<Foo first=1 second='hello'>N©r   ÚFancyStrMixinr   Ústr©r   rV   s     r!   Útest_sequenceOfStringsz)FancyStrMixinTests.test_sequenceOfStrings·  s-   € ô	”$×$Ñ$ô 	ð
 	×Ñœ™S›U›Ð%CÕDr#   c                 óv   —  G d„ dt         j                  «      }| j                  dt         |«       «      «       y)a  
        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                   ó"   — e Zd Zddd„ ffZdZdZy)ú.FancyStrMixinTests.test_formatter.<locals>.FoorÉ  rÊ  c                 ó$   — t        | d d d…   «      S )Nrr  )rÒ   )Úvalues    r!   r{  z7FancyStrMixinTests.test_formatter.<locals>.Foo.<lambda>Í  s   € ÄÀUÉ4ÈRÈ4Á[Ó@Q€ r#   rË  ÚworldNrÌ  rM   r#   r!   rV   rÖ  Ì  s   „ Ø%¨Ñ2QÐ'RÐSˆNØˆEØ‰Fr#   rV   z"<Foo first='hello' second='dlrow'>NrÏ  rÒ  s     r!   Útest_formatterz!FancyStrMixinTests.test_formatterÄ  s-   € ô	”$×$Ñ$ô 	ð
 	×ÑÐ=¼sÁ3Ã5»zÕJr#   c                 óv   —  G d„ dt         j                  «      }| j                  t         |«       «      d«       y)a&  
        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                   ó   — e Zd ZdZdZdZy)ú-FancyStrMixinTests.test_override.<locals>.Foo)rÉ  )rÊ  Ú2ndz%.1fr   gÙÎ÷Sã @NrÌ  rM   r#   r!   rV   rÝ  Û  s   „ ØAˆNØˆEØ‰Fr#   rV   z<Foo first=1 2nd=2.1>NrÏ  rÒ  s     r!   Útest_overridez FancyStrMixinTests.test_overrideÓ  s-   € ô	”$×$Ñ$ô 	ð
 	×Ñœ™S›U›Ð%<Õ=r#   c                 óv   —  G d„ dt         j                  «      }| j                  t         |«       «      d«       y)z_
        If C{fancybasename} is present, C{__str__} uses it instead of the class name.
        c                   ó   — e Zd ZdZy)ú2FancyStrMixinTests.test_fancybasename.<locals>.FooÚBarN)rJ   rK   rL   ÚfancybasenamerM   r#   r!   rV   râ  ç  s   „ Ø!‰Mr#   rV   z<Bar>NrÏ  rÒ  s     r!   Útest_fancybasenamez%FancyStrMixinTests.test_fancybasenameâ  s,   € ô
	"”$×$Ñ$ô 	"ð 	×Ñœ™S›U› WÕ-r#   c                 óŒ   —  G d„ dt         j                  «      } |«       }| j                  t        |«      t	        |«      «       y)zE
        C{__repr__} outputs the same content as C{__str__}.
        c                   ó   — e Zd ZdZdZdZy)ú)FancyStrMixinTests.test_repr.<locals>.FoorÈ  r   rË  NrÌ  rM   r#   r!   rV   rè  ñ  rÎ  r#   rV   N)r   rÐ  r   rÑ  rÒ   )r   rV   Úobjs      r!   Ú	test_reprzFancyStrMixinTests.test_reprì  s5   € ô
	”$×$Ñ$ô 	ñ
 ‹eˆØ×Ñœ˜S›¤4¨£9Õ-r#   N)	rJ   rK   rL   r_   rÓ  rÚ  rß  rå  rê  rM   r#   r!   rÄ  rÄ  ²  s"   „ ñòEòKò>ò.ó.r#   rÄ  c                   ó:   — e Zd ZdZd„ Zd„ Zd„ Zd„ Zd„ Zd„ Z	d„ Z
y	)
Ú
PadToTestsz"
    Tests for L{util.padTo}.
    c                 ó\   — t        j                  dg «      }| j                  dgdz  |«       y)ze
        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_defaultzPadToTests.test_defaultÿ  s*   € ô
 —‘˜A˜rÓ"ˆØ×Ñ˜$˜ !™ VÕ,r#   c                 ó^   — t        j                  dg d«      }| j                  dgdz  |«       y)zg
        A specific value can be added to a list to cause it to have a certain
        length.
        r   r™   Nrî  rð  s     r!   Útest_specificDefaultValuez$PadToTests.test_specificDefaultValue  s,   € ô
 —‘˜A˜r 3Ó'ˆØ×Ñ˜#˜ ™ FÕ+r#   c                 ó^   — t        j                  dddgd«      }| j                  g d¢|«       y)zl
        A list which already has some items has the padding value added after
        those items.
        r   r   r   r…  )r   r   r…  Nrî  rð  s     r!   Útest_padNonEmptyListzPadToTests.test_padNonEmptyList  s*   € ô
 —‘˜A  1˜v sÓ+ˆØ×Ñš fÕ-r#   c                 óT   — | j                  t        t        j                  dddg«       y)z{
        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)r4  r5  r   rï  r+   s    r!   Útest_padToSmallerSizez PadToTests.test_padToSmallerSize  s    € ð
 	×Ñœ*¤d§j¡j°!°a¸°VÕ<r#   c                 ón   — ddg}t        j                  t        |«      |«      }| j                  ||«       y)zŠ
        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   rï  r‰   r   ©r   rÔ   rñ  s      r!   Útest_alreadyPaddedzPadToTests.test_alreadyPadded  s1   € ð
 �A�ˆÜ—‘œC ›J¨Ó.ˆØ×Ñ˜ Õ'r#   c                 ón   — ddg}t        j                  t        |«      |«      }| j                  ||«       y)z‹
        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   rï  r‰   ÚassertIsNotrú  s      r!   Útest_alreadyPaddedCopiesz#PadToTests.test_alreadyPaddedCopies'  s1   € ð
 �A�ˆÜ—‘œC ›J¨Ó.ˆØ×Ñ˜ Õ'r#   c                 óX   — g }t        j                  d|«       | j                  g |«       y)zO
        L{util.padTo} doesn't modify the input list but makes a copy.
        r   Nrî  )r   rÔ   s     r!   Útest_makeCopyzPadToTests.test_makeCopy0  s'   € ð ˆÜ�
‰
�1�eÔØ×Ñ˜˜UÕ#r#   N)rJ   rK   rL   r_   rò  rô  rö  rø  rû  rþ  r   rM   r#   r!   rì  rì  ú  s*   „ ñò-ò,ò.ò=ò(ò(ó$r#   rì  )Gr_   rg   Úos.pathr7   r  rû   rµ  Útypingr   r   r   r   Úunittestr   rC   Ú_grpr5   Ú_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   rO   ra   Úgetattrrq   r’   rº   rÄ   rá   Ú
providedByrð   r  r  rX  r8  rB  rE  rG  rP  rS  rl  rœ  r˜  r£  r­  rÄ  rì  rM   r#   r!   ú<module>r     se  ðñ
ó
 Û Û Û 
Û ß >Ó >Ý ðÛÛð
 €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