§
    Ètºf+( ã                  ór  — d Z ddlmZ ddlZddlZddlZddl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mZmZmZmZmZmZmZmZmZmZmZm Z m!Z!m"Z"m#Z# ddl$m%Z%m&Z&m'Z' ddl(m)Z) ddl*m+Z+ dd	l,m-Z- dd
l.m/Z/m0Z0 ddl1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;m<Z<m=Z= ddl>m?Z? ddl@mAZA ddlBmCZC ddlDmEZE ddlFm	Z	 dOd„ZG G d„ deH¦  «        ZIdPd„ZJ e!deH¬¦  «        ZK G d„ d¦  «        ZL G d „ d!e	jM        ¦  «        ZN G d"„ d#e	jO        eL¦  «        ZP G d$„ d%¦  «        ZQdQd)„ZR G d*„ d+e	jO        ¦  «        ZS G d,„ d-e	jO        ¦  «        ZT G d.„ d/e	jO        ¦  «        ZU G d0„ d1e	jO        ¦  «        ZV G d2„ d3e	jO        ¦  «        ZW G d4„ d5e	jO        ¦  «        ZX G d6„ d7e	jO        eL¦  «        ZY G d8„ d9e	jM        ¦  «        ZZdRd?„Z[ G d@„ dAe	jO        ¦  «        Z\ G dB„ dCe	jM        ¦  «        Z] G dD„ dEe	jM        eL¦  «        Z^dSdH„Z_ G dI„ dJe	jM        ¦  «        Z` G dK„ dLe	jM        ¦  «        Za G dM„ dNe	jO        ¦  «        ZbdS )Tz+
Test cases for L{twisted.internet.defer}.
é    )ÚannotationsN)ÚAbstractEventLoopÚCancelledErrorÚFutureÚnew_event_loop)ÚAnyÚCallableÚ	CoroutineÚDictÚ	GeneratorÚListÚLiteralÚMappingÚNoReturnÚOptionalÚSetÚTupleÚTypeÚTypeVarÚUnionÚcast)Úassert_thatÚemptyÚequal_to)Úgiven)Úintegers)Úassert_type)ÚdeferÚreactor)Ú_TÚDeferredÚDeferredFilesystemLockÚDeferredListÚDeferredLockÚDeferredQueueÚDeferredSemaphoreÚFailureGroupÚ_DeferredListResultListTÚ_DeferredListSingleResultTÚensureDeferredÚrace)ÚClock)Úlog)Ú_PYPY©ÚFailure)ÚunittestÚfú0Callable[..., Coroutine[Deferred[Any], Any, _T]]ÚreturnúCallable[..., Deferred[_T]]c                óH   ‡ — t          j        ‰ ¦  «        dˆ fd„¦   «         }|S )NÚargsÚobjectÚkwargsr4   úDeferred[_T]c                 ó<   •—  ‰| i |¤Ž}t          j        |¦  «        S ©N)r!   ÚfromCoroutine)r7   r9   Úcoror2   s      €úV/var/www/surfInsights/venv3-11/lib/python3.11/site-packages/twisted/test/test_defer.pyÚwrapperz!ensuringDeferred.<locals>.wrapperJ   s(   ø€ àˆq�$Ð!˜&Ð!Ð!ˆÝÔ% dÑ+Ô+Ð+ó    )r7   r8   r9   r8   r4   r:   )Ú	functoolsÚwraps)r2   r@   s   ` r?   ÚensuringDeferredrD   G   s?   ø€ õ „_�QÑÔð,ð ,ð ,ð ,ð ,ñ Ôð,ð €NrA   c                  ó   — e Zd ZdS )ÚGenericErrorN©Ú__name__Ú
__module__Ú__qualname__© rA   r?   rF   rF   R   s   € € € € € Ø€DrA   rF   ÚdeferredúDeferred[str]ÚNonec                ó0   — |                       d¦  «         dS )z­
    A fake L{Deferred} canceller which callbacks the L{Deferred}
    with C{str} "Callback Result" when cancelling it.

    @param deferred: The cancelled L{Deferred}.
    úCallback ResultN©Úcallback©rL   s    r?   ÚfakeCallbackCancellerrT   V   s   € ð ×ÒÐ'Ñ(Ô(Ð(Ð(Ð(rA   Ú_ExceptionT)Úboundc                  ó   — e Zd ZdZd
d„Zd	S )ÚImmediateFailureMixinz+
    Add additional assertion methods.
    rL   úDeferred[Any]Ú	exceptionúType[_ExceptionT]r4   rU   c                óP  — t          t          j        | ¦  «        }g }|                     |j        ¦  «         |                     t          |¦  «        d¦  «         |                     |d                              |¦  «        ¦  «         t          t          |d         j
        ¦  «        S )z¨
        Assert that the given Deferred current result is a Failure with the
        given exception.

        @return: The exception instance in the Deferred.
        é   r   )r   r1   ÚTestCaseÚ
addErrbackÚappendÚassertEqualÚlenÚ
assertTrueÚcheckrU   Úvalue)ÚselfrL   rZ   ÚtestCaseÚfailuress        r?   ÚassertImmediateFailurez,ImmediateFailureMixin.assertImmediateFailureh   sŠ   € õ �Ô)¨4Ñ0Ô0ˆØ"$ˆØ×Ò˜HœOÑ,Ô,Ð,Ø×Ò�S ™]œ]¨AÑ.Ô.Ð.Ø×Ò˜H QœK×-Ò-¨iÑ8Ô8Ñ9Ô9Ð9Ý•K ¨!¤Ô!2Ñ3Ô3Ð3rA   N)rL   rY   rZ   r[   r4   rU   )rH   rI   rJ   Ú__doc__ri   rK   rA   r?   rX   rX   c   s2   € € € € € ðð ð4ð 4ð 4ð 4ð 4ð 4rA   rX   c                  ó*   — e Zd ZdZdd„Zdd„Zdd„ZdS )	Ú	UtilTestsz&
    Tests for utility functions.
    r4   rN   c                óÄ   — t          t          ¦   «         ¦  «        }t          j        |¦  «        }|                      t          ¦  «         |                      ||¦  «         dS )z<
        L{defer.logError} returns the given error.
        N)r0   ÚRuntimeErrorr   ÚlogErrorÚflushLoggedErrorsÚassertIs)rf   ÚerrorÚresults      r?   Útest_logErrorReturnsErrorz#UtilTests.test_logErrorReturnsError~   sR   € õ �™œÑ'Ô'ˆÝ” Ñ&Ô&ˆØ×Ò�|Ñ,Ô,Ð,à�Š�e˜VÑ$Ô$Ð$Ð$Ð$rA   c                óÆ   — t          t          ¦   «         ¦  «        }t          j        |¦  «         |                      t          ¦  «        }|                      ||g¦  «         dS )z9
        L{defer.logError} logs the given error.
        N)r0   rn   r   ro   rp   ra   )rf   rr   Úerrorss      r?   Útest_logErrorLogsErrorz UtilTests.test_logErrorLogsErrorˆ   sV   € õ �™œÑ'Ô'ˆÝŒ�uÑÔÐØ×'Ò'­Ñ5Ô5ˆà×Ò˜ % Ñ)Ô)Ð)Ð)Ð)rA   c                ó.  ‡— g Šd	ˆfd„}t          j        |¦  «         t          t          ¦   «         ¦  «        }t	          j        |¦  «         |                      t          ¦  «         |                      ‰d                              d¦  «        ¦  «         dS )
zR
        The text logged by L{defer.logError} has no repr of the failure.
        Ú	eventDictúDict[str, Any]r4   rN   c                ób   •— t          j        | ¦  «        }|€J ‚‰                     |¦  «         d S r<   )r-   ÚtextFromEventDictr`   )ry   ÚtextÚoutputs     €r?   Úemitz4UtilTests.test_logErrorLogsErrorNoRepr.<locals>.emit˜   s7   ø€ ÝÔ(¨Ñ3Ô3ˆDØÐ#Ð#Ð#Ø�MŠM˜$ÑÔÐÐÐrA   r   úUnhandled Error
Traceback N)ry   rz   r4   rN   )	r-   ÚaddObserverr0   rn   r   ro   rp   rc   Ú
startswith)rf   r   rr   r~   s      @r?   Útest_logErrorLogsErrorNoReprz&UtilTests.test_logErrorLogsErrorNoRepr’   sš   ø€ ð ˆð	 ð 	 ð 	 ð 	 ð 	 ð 	 õ
 	Œ˜ÑÔÐå�™œÑ'Ô'ˆÝŒ�uÑÔÐØ×Ò�|Ñ,Ô,Ð,à�Š˜˜qœ	×,Ò,Ð-JÑKÔKÑLÔLÐLÐLÐLrA   N©r4   rN   )rH   rI   rJ   rj   rt   rw   rƒ   rK   rA   r?   rl   rl   y   s`   € € € € € ðð ð%ð %ð %ð %ð*ð *ð *ð *ðMð Mð Mð Mð Mð MrA   rl   c                  ó8  — e Zd Zd^d„Zd_d„Zd`d	„Zdad„Zd^d„Zd^d„Zd^d„Z	d^d„Z
d^d„Zd^d„Zd^d„Zd^d„Zd^d„Zd^d„Zd^d„Zd^d„Zd^d„Zd^d„Zd^d„Zd^d„Zd^d„Zd^d„Zd^d„Zd^d„Zd^d „Zd^d!„Zd^d"„Zd^d#„Zd^d$„Zd^d%„Z d^d&„Z!d^d'„Z"d^d(„Z#d^d)„Z$d^d*„Z%d^d+„Z&d^d,„Z'd^d-„Z(d^d.„Z)d^d/„Z*d^d0„Z+d^d1„Z,d^d2„Z-d^d3„Z.d^d4„Z/d^d5„Z0d^d6„Z1d^d7„Z2d^d8„Z3d^d9„Z4d^d:„Z5d^d;„Z6d^d<„Z7d^d=„Z8d^d>„Z9d^d?„Z:d^d@„Z;d^dA„Z<d^dB„Z=d^dC„Z>d^dD„Z?d^dE„Z@d^dF„ZAd^dG„ZBd^dH„ZCd^dI„ZDd^dJ„ZEd^dK„ZFd^dL„ZGd^dM„ZHd^dN„ZId^dO„ZJd^dP„ZKd^dQ„ZLd^dR„ZMd^dS„ZNd^dT„ZOd^dU„ZPd^dV„ZQd^dW„ZR eSjT        eUdX¦  «        d^dY„¦   «         ZV eSjT        eUdX¦  «        d^dZ„¦   «         ZW eSjT        eUdX¦  «        d^d[„¦   «         ZXd^d\„ZYd]S )bÚDeferredTestsr4   rN   c                ó’   — d | _         d | _        d | _        |                      t          j        t	          j        ¦   «         ¦  «         d S r<   )ÚcallbackResultsÚcallback2ResultsÚerrbackResultsÚ
addCleanupr   ÚsetDebuggingÚgetDebugging©rf   s    r?   ÚsetUpzDeferredTests.setUp§   sQ   € ð ð 	Ôð
 ð 	Ôð
 ð 	Ôð
 	�Š�Ô*­EÔ,>Ñ,@Ô,@ÑAÔAÐAÐAÐArA   r7   r8   r9   r   c                ó$   — ||f| _         |d         S ©Nr   ©rˆ   ©rf   r7   r9   s      r?   Ú	_callbackzDeferredTests._callbackµ   s   € Ø# V˜|ˆÔØ�AŒwˆrA   c                ó   — ||f| _         d S r<   ©r‰   r“   s      r?   Ú
_callback2zDeferredTests._callback2¹   s   € Ø $ f ˆÔÐÐrA   r0   c                ó   — ||f| _         d S r<   ©rŠ   r“   s      r?   Ú_errbackzDeferredTests._errback¼   s   € Ø" F˜lˆÔÐÐrA   c                óî   — t          ¦   «         }|                     | j        ¦  «         |                     d¦  «         |                      | j        ¦  «         |                      | j        di f¦  «         d S ©NÚhello©r�   ©r!   ÚaddCallbackr”   rR   ÚassertIsNonerŠ   ra   rˆ   ©rf   rL   s     r?   ÚtestCallbackWithoutArgsz%DeferredTests.testCallbackWithoutArgs¿   sp   € Ý"*¡*¤*ˆØ×Ò˜Tœ^Ñ,Ô,Ð,Ø×Ò˜'Ñ"Ô"Ð"Ø×Ò˜$Ô-Ñ.Ô.Ð.Ø×Ò˜Ô-°
¸BÐ/?Ñ@Ô@Ð@Ð@Ð@rA   c                óð   — t          ¦   «         }|                     | j        d¦  «         |                     d¦  «         |                      | j        ¦  «         |                      | j        di f¦  «         d S )NÚworldr�   )r�   r¥   rŸ   r¢   s     r?   ÚtestCallbackWithArgsz"DeferredTests.testCallbackWithArgsÆ   ss   € Ý"*¡*¤*ˆØ×Ò˜Tœ^¨WÑ5Ô5Ð5Ø×Ò˜'Ñ"Ô"Ð"Ø×Ò˜$Ô-Ñ.Ô.Ð.Ø×Ò˜Ô-Ð0BÀBÐ/GÑHÔHÐHÐHÐHrA   c                óö   — t          ¦   «         }|                     | j        d¬¦  «         |                     d¦  «         |                      | j        ¦  «         |                      | j        dddif¦  «         d S )Nr¥   )r¥   r�   rž   rŸ   r¢   s     r?   ÚtestCallbackWithKwArgsz$DeferredTests.testCallbackWithKwArgsÍ   sz   € Ý"*¡*¤*ˆØ×Ò˜Tœ^°7ÐÑ;Ô;Ð;Ø×Ò˜'Ñ"Ô"Ð"Ø×Ò˜$Ô-Ñ.Ô.Ð.Ø×Ò˜Ô-°
¸WÀgÐ<NÐ/OÑPÔPÐPÐPÐPrA   c                ó\  — t          ¦   «         }|                     | j        ¦  «         |                     | j        ¦  «         |                     d¦  «         |                      | j        ¦  «         |                      | j        di f¦  «         |                      | j	        di f¦  «         d S rœ   )
r!   r    r”   r—   rR   r¡   rŠ   ra   rˆ   r‰   r¢   s     r?   ÚtestTwoCallbackszDeferredTests.testTwoCallbacksÔ   s¤   € Ý"*¡*¤*ˆØ×Ò˜Tœ^Ñ,Ô,Ð,Ø×Ò˜Tœ_Ñ-Ô-Ð-Ø×Ò˜'Ñ"Ô"Ð"Ø×Ò˜$Ô-Ñ.Ô.Ð.Ø×Ò˜Ô-°
¸BÐ/?Ñ@Ô@Ð@Ø×Ò˜Ô.°¸RÐ0@ÑAÔAÐAÐAÐArA   c                óP  — t          d¦  «        }t          ¦   «         }|                     | j        t	          t
          dt          f         d¦  «        ¦  «         |                     |¦  «         |                     | j	        ¦  «         |  
                    | j        ¦  «         | j        €J ‚|                      t          | j        d         ¦  «        d¦  «         |                      | j        d         d         j        |¦  «         |                      | j        d         i ¦  «         dS )zQ
        If given None for an errback, addCallbacks uses a pass-through.
        Úoopsie.Nr   r]   )rF   r!   ÚaddCallbacksr”   r   r	   r8   Úerrbackr_   rš   r¡   rˆ   rŠ   ra   rb   re   ©rf   rr   rL   s      r?   Útest_addCallbacksNoneErrbackz*DeferredTests.test_addCallbacksNoneErrbackÝ   s  € õ ˜XÑ&Ô&ˆÝ#+¡:¤:ˆØ×Ò˜dœn­dµ8¸CÅ¸KÔ3HÈ$Ñ.OÔ.OÑPÔPÐPØ×Ò˜ÑÔÐØ×Ò˜DœMÑ*Ô*Ð*Ø×Ò˜$Ô.Ñ/Ô/Ð/ØÔ"Ð.Ð.Ð.Ø×Ò�˜TÔ0°Ô3Ñ4Ô4°aÑ8Ô8Ð8Ø×Ò˜Ô,¨QÔ/°Ô2Ô8¸%Ñ@Ô@Ð@Ø×Ò˜Ô,¨QÔ/°Ñ4Ô4Ð4Ð4Ð4rA   c           
     óˆ  — t          ¦   «         }|                     | j        | j        t	          t
          t                   d¦  «        t	          t          t          t          f         d¦  «        di ¦  «         | 	                    d¦  «         |  
                    | j        ¦  «         |                      | j        di f¦  «         dS )zR
        If given None as a callback args and kwargs, () and {} are used.
        NrK   r�   rž   )r!   r­   r”   rš   r   r   r8   r   ÚstrrR   r¡   rŠ   ra   rˆ   r¢   s     r?   Ú!test_addCallbacksNoneCallbackArgsz/DeferredTests.test_addCallbacksNoneCallbackArgsì   s­   € õ #+¡*¤*ˆØ×ÒØŒNØŒMÝ••v” Ñ%Ô%Ý•��f˜Ô% tÑ,Ô,ØØñ	
ô 	
ð 	
ð 	×Ò˜'Ñ"Ô"Ð"Ø×Ò˜$Ô-Ñ.Ô.Ð.Ø×Ò˜Ô-°
¸BÐ/?Ñ@Ô@Ð@Ð@Ð@rA   c                ó¨  — t          d¦  «        }t          ¦   «         }|                     | j        | j        di t          t          t                   d¦  «        t          t          t          t          f         d¦  «        ¦  «         | 
                    |¦  «         |                     | j        ¦  «         |                      | j        ¦  «         | j        €J ‚|                      t!          | j        d         ¦  «        d¦  «         |                      | j        d         d         j        |¦  «         |                      | j        d         i ¦  «         dS )zQ
        If given None as a errback args and kwargs, () and {} are used.
        r¬   rK   Nr   r]   )rF   r!   r­   r”   rš   r   r   r8   r   r²   r®   r_   r¡   rˆ   rŠ   ra   rb   re   r¯   s      r?   Ú test_addCallbacksNoneErrbackArgsz.DeferredTests.test_addCallbacksNoneErrbackArgsý   s+  € õ ˜XÑ&Ô&ˆÝ#+¡:¤:ˆØ×ÒØŒNØŒMØØÝ••v” Ñ%Ô%Ý•��f˜Ô% tÑ,Ô,ñ	
ô 	
ð 	
ð 	×Ò˜ÑÔÐØ×Ò˜DœMÑ*Ô*Ð*Ø×Ò˜$Ô.Ñ/Ô/Ð/ØÔ"Ð.Ð.Ð.Ø×Ò�˜TÔ0°Ô3Ñ4Ô4°aÑ8Ô8Ð8Ø×Ò˜Ô,¨QÔ/°Ô2Ô8¸%Ñ@Ô@Ð@Ø×Ò˜Ô,¨QÔ/°Ñ4Ô4Ð4Ð4Ð4rA   c                ó  — t           t          t          t          t          t
          f         f                  }t          ¦   «         }t          ¦   «         }t          ¦   «         }t          |||g¦  «        }g }|fdd„}dd	„}|                     ||¦  «         | 	                    d
¦  «         | 
                    |¦  «         |                     t          d¦  «        ¦  «         | 	                    d¦  «         |                      |d         |d         d         t	          t          t
          |d         d         ¦  «        j        ¦  «        f|d         gt           j        d
ft           j        dft           j        dfg¦  «         d S )NÚ
resultListÚ
ResultListrs   r4   rN   c                ó0   — |                      | ¦  «         d S r<   )Úextend©r·   rs   s     r?   Úcbz*DeferredTests.testDeferredList.<locals>.cb  s   € Ø�MŠM˜*Ñ%Ô%Ð%Ð%Ð%rA   Úerrr0   c                ó   — d S r<   rK   ©r½   s    r?   Úcatchz-DeferredTests.testDeferredList.<locals>.catch  ó   € Ø�4rA   Ú1Ú2Ú3r   r]   é   )r·   r¸   rs   r¸   r4   rN   ©r½   r0   r4   rN   )r   r   Úboolr   r²   r0   r!   r#   r­   rR   r_   r®   rF   ra   r   re   r   ÚSUCCESSÚFAILURE)	rf   r¸   Údefr1Údefr2Údefr3Údlrs   r¼   rÀ   s	            r?   ÚtestDeferredListzDeferredTests.testDeferredList  sp  € Ý�%¥¥e­Cµ¨LÔ&9Ð 9Ô:Ô;ˆ
å'™zœzˆÝ'™zœzˆÝ'™zœzˆÝ˜5 %¨Ð/Ñ0Ô0ˆØˆà<Bð 	&ð 	&ð 	&ð 	&ð 	&ð	ð 	ð 	ð 	ð 	�Š˜˜BÑÔÐØ�Š�sÑÔÐØ×Ò˜ÑÔÐð 	�Š•l 3Ñ'Ô'Ñ(Ô(Ð(Ø�Š�sÑÔÐØ×Òà�q”	à˜”˜1”�s¥4­°¸´¸1´Ñ#>Ô#>Ô#DÑEÔEÐFØ�q”	ð	õ Œm˜SÐ!¥E¤M°3Ð#7½%¼-ÈÐ9MÐNñ	
ô 	
ð 	
ð 	
ð 	
rA   c                ó  — g }|fd
d„}t          g ¦  «        }|                     |¦  «         |                      |g g¦  «         g |d d …<   t          g d¬	¦  «        }|                     |¦  «         |                      |g ¦  «         d S )Nr·   ú_DeferredListResultListT[None]rs   ú$List[_DeferredListResultListT[None]]r4   rN   c                ó0   — |                      | ¦  «         d S r<   ©r`   r»   s     r?   r¼   z/DeferredTests.testEmptyDeferredList.<locals>.cb:  s   € ð �MŠM˜*Ñ%Ô%Ð%Ð%Ð%rA   T©ÚfireOnOneCallback)r·   rÐ   rs   rÑ   r4   rN   )r#   r­   ra   )rf   rs   r¼   Údl1Údl2s        r?   ÚtestEmptyDeferredListz#DeferredTests.testEmptyDeferredList7  sº   € Ø79ˆð <Bð	&ð 	&ð 	&ð 	&ð 	&õ 9EÀRÑ8HÔ8HˆØ×Ò˜ÑÔÐØ×Ò˜ " Ñ&Ô&Ð&àˆˆqˆqˆq‰	Ý:FØ $ð;
ñ ;
ô ;
ˆð 	×Ò˜ÑÔÐØ×Ò˜ Ñ$Ô$Ð$Ð$Ð$rA   c                ó*  — t          ¦   «         }t          ¦   «         }t          ¦   «         }t          |||gd¬¦  «        }g }|                     |j        ¦  «         dd„}|                     |¦  «         |                     d¦  «         |                      |g ¦  «         |                     t          d	¦  «        ¦  «         |                      t          |¦  «        d
¦  «         |d         }|  	                    t          |j        t          j        ¦  «        d|j        ›�¦  «         |j        }|                      |j        j        t          ¦  «         |                      |j        j        j        d¦  «         |                      |j        d
¦  «         d S )NT©ÚfireOnOneErrbackr½   r0   r4   rN   c                ó   — d S r<   rK   r¿   s    r?   rÀ   z;DeferredTests.testDeferredListFireOnOneError.<locals>.catchU  rÁ   rA   rÂ   ú	from def2r]   r   zFissubclass(aFailure.type, defer.FirstError) failed: failure's type is )rÝ   rÆ   )r!   r#   r_   r`   rR   ra   r®   rF   rb   rc   Ú
issubclassÚtyper   Ú
FirstErrorre   Ú
subFailurer7   Úindex)	rf   rÊ   rË   rÌ   rÍ   rs   rÀ   ÚaFailureÚ
firstErrors	            r?   ÚtestDeferredListFireOnOneErrorz,DeferredTests.testDeferredListFireOnOneErrorK  s„  € Ý'™zœzˆÝ'™zœzˆÝ'™zœzˆÝ˜5 %¨Ð/À$ÐGÑGÔGˆØ "ˆØ
�Š�f”mÑ$Ô$Ð$ð	ð 	ð 	ð 	ð 	×Ò˜ÑÔÐð 	�Š�sÑÔÐØ×Ò˜ Ñ$Ô$Ð$ð 	�Š•l ;Ñ/Ô/Ñ0Ô0Ð0Ø×Ò�˜V™œ aÑ(Ô(Ð(ð ˜!”9ˆð 	�ŠÝ�x”}¥eÔ&6Ñ7Ô7Ð7à&.¤m mð6ñ	
ô 	
ð 	
ð ”^ˆ
ð 	×Ò˜Ô.Ô3µ\ÑBÔBÐBØ×Ò˜Ô.Ô4Ô9¸>ÑJÔJÐJØ×Ò˜Ô)¨1Ñ-Ô-Ð-Ð-Ð-rA   c                ó  — t          ¦   «         }t          |g¦  «        }g }|                     |j        ¦  «         g }|                     |j        ¦  «         |                     t          d¦  «        ¦  «         |                      d|d         j        j	        d         ¦  «         |                      dt          |¦  «        ¦  «         |d         d         }|€J ‚|                      d|d         j        j	        d         ¦  «         d S )NÚBangr   r]   )r!   r#   r_   r`   r    r®   rF   ra   re   r7   rb   ©rf   Úd1rÍ   Ú	errorTrapÚresultListsÚfirstResults         r?   Ú!testDeferredListDontConsumeErrorsz/DeferredTests.testDeferredListDontConsumeErrorst  sð   € Ý%™ZœZˆÝ˜2˜$ÑÔˆà#%ˆ	Ø
�Š�iÔ&Ñ'Ô'Ð'à<>ˆØ
�Š�{Ô)Ñ*Ô*Ð*à
�
Š
•< Ñ'Ô'Ñ(Ô(Ð(Ø×Ò˜ ¨1¤Ô!3Ô!8¸Ô!;Ñ<Ô<Ð<Ø×Ò˜�C Ñ,Ô,Ñ-Ô-Ð-Ø! !”n QÔ'ˆØÐ&Ð&Ð&Ø×Ò˜ ¨Q¤Ô!5Ô!:¸1Ô!=Ñ>Ô>Ð>Ð>Ð>rA   c                óè  — t          ¦   «         }t          |gd¬¦  «        }g }|                     |j        ¦  «         g }|                     |j        ¦  «         |                     t          d¦  «        ¦  «         |                      g |¦  «         |                      dt          |¦  «        ¦  «         |d         d         }|€J ‚|                      d|d         j	        j
        d         ¦  «         d S )NT©ÚconsumeErrorsrç   r]   r   )r!   r#   r_   r`   r    r®   rF   ra   rb   re   r7   rè   s         r?   ÚtestDeferredListConsumeErrorsz+DeferredTests.testDeferredListConsumeErrors…  sæ   € Ý%™ZœZˆÝ˜2˜$¨dÐ3Ñ3Ô3ˆà#%ˆ	Ø
�Š�iÔ&Ñ'Ô'Ð'à<>ˆØ
�Š�{Ô)Ñ*Ô*Ð*à
�
Š
•< Ñ'Ô'Ñ(Ô(Ð(Ø×Ò˜˜YÑ'Ô'Ð'Ø×Ò˜�C Ñ,Ô,Ñ-Ô-Ð-Ø! !”n QÔ'ˆØÐ&Ð&Ð&Ø×Ò˜ ¨Q¤Ô!5Ô!:¸1Ô!=Ñ>Ô>Ð>Ð>Ð>rA   c                óR  — t          ¦   «         }t          ¦   «         }|                     t          d¦  «        ¦  «         t          ||gd¬¦  «        }g }|                     |j        ¦  «         |                      dt          |¦  «        ¦  «         |                     d„ ¦  «         d S )Nrç   TrÚ   r]   c                ó   — d S r<   rK   ©Úes    r?   ú<lambda>zWDeferredTests.testDeferredListFireOnOneErrorWithAlreadyFiredDeferreds.<locals>.<lambda>¢  ó   €  € rA   )r!   r®   rF   r#   r_   r`   ra   rb   ©rf   ré   Úd2rÍ   rs   s        r?   Ú7testDeferredListFireOnOneErrorWithAlreadyFiredDeferredszEDeferredTests.testDeferredListFireOnOneErrorWithAlreadyFiredDeferreds–  s•   € å%™ZœZˆÝ%™ZœZˆØ
�
Š
•< Ñ'Ô'Ñ(Ô(Ð(õ ˜2˜r˜(°TÐ:Ñ:Ô:ˆØ "ˆØ
�Š�f”mÑ$Ô$Ð$Ø×Ò˜�C ™KœKÑ(Ô(Ð(à
�Š�n�nÑ%Ô%Ð%Ð%Ð%rA   c                óx  — t          ¦   «         }t          ¦   «         }|                     t          d¦  «        ¦  «         |                     d¦  «         t	          ||g¦  «        }g }|                     |j        ¦  «         |                      dt          |¦  «        ¦  «         | 	                    d„ ¦  «         d S )Nrç   rÅ   r]   c                ó   — d S r<   rK   rô   s    r?   rö   zIDeferredTests.testDeferredListWithAlreadyFiredDeferreds.<locals>.<lambda>³  r÷   rA   )
r!   r®   rF   rR   r#   r    r`   ra   rb   r_   rø   s        r?   Ú)testDeferredListWithAlreadyFiredDeferredsz7DeferredTests.testDeferredListWithAlreadyFiredDeferreds¤  sŸ   € å$™JœJˆÝ$™JœJˆØ
�
Š
•< Ñ'Ô'Ñ(Ô(Ð(Ø
�Š�A‰Œˆõ ˜2˜r˜(Ñ#Ô#ˆà/1ˆØ
�Š�v”}Ñ%Ô%Ð%à×Ò˜�C ™KœKÑ(Ô(Ð(à
�Š�n�nÑ%Ô%Ð%Ð%Ð%rA   c                ó  — t          ¦   «         }t          ¦   «         }t          ||g¦  «        }|                     ¦   «          |                      |t          j        ¦  «         |                      |t          j        ¦  «         dS )zk
        When cancelling an unfired L{DeferredList}, cancel every
        L{Deferred} in the list.
        N©r!   r#   ÚcancelÚfailureResultOfr   r   ©rf   ÚdeferredOneÚdeferredTwoÚdeferredLists       r?   Útest_cancelDeferredListz%DeferredTests.test_cancelDeferredListµ  sr   € õ
 '/¡j¤jˆÝ&.¡j¤jˆÝ# [°+Ð$>Ñ?Ô?ˆØ×ÒÑÔÐØ×Ò˜[­%Ô*>Ñ?Ô?Ð?Ø×Ò˜[­%Ô*>Ñ?Ô?Ð?Ð?Ð?rA   c                óB  — t          t          ¦  «        }t          ¦   «         }t          ||g¦  «        }|                     ¦   «          |                      |t
          j        ¦  «         |                      |¦  «        }|                      |d         d         ¦  «         |  	                    |d         d         d¦  «         |  
                    |d         d         ¦  «         |                      |d         d                              t
          j        ¦  «        ¦  «         dS )zì
        When cancelling an unfired L{DeferredList} without the
        C{fireOnOneCallback} and C{fireOnOneErrback} flags set, the
        L{DeferredList} will be callback with a C{list} of
        (success, result) C{tuple}s.
        r   r]   rP   N)r!   rT   r#   r   r  r   r   ÚsuccessResultOfrc   ra   ÚassertFalserd   ©rf   r  r  r  rs   s        r?   Útest_cancelDeferredListCallbackz-DeferredTests.test_cancelDeferredListCallbackÁ  sñ   € õ &.Õ.CÑ%DÔ%DˆÝ%-¡Z¤ZˆÝ# [°+Ð$>Ñ?Ô?ˆØ×ÒÑÔÐØ×Ò˜[­%Ô*>Ñ?Ô?Ð?Ø×%Ò% lÑ3Ô3ˆØ�Š˜˜qœ	 !œÑ%Ô%Ð%Ø×Ò˜ œ 1œÐ'8Ñ9Ô9Ð9Ø×Ò˜ œ 1œÑ&Ô&Ð&Ø�Š˜˜qœ	 !œ×*Ò*­5Ô+?Ñ@Ô@ÑAÔAÐAÐAÐArA   c                ó  — t          ¦   «         }t          ¦   «         }t          ||gd¬¦  «        }|                     ¦   «          |                      |t          j        ¦  «         |                      |t          j        ¦  «         dS )z’
        When cancelling an unfired L{DeferredList} with the flag
        C{fireOnOneCallback} set, cancel every L{Deferred} in the list.
        TrÔ   Nrÿ   r  s       r?   Ú,test_cancelDeferredListWithFireOnOneCallbackz:DeferredTests.test_cancelDeferredListWithFireOnOneCallbackÓ  sx   € õ
 '/¡j¤jˆÝ&.¡j¤jˆÝ# [°+Ð$>ÐRVÐWÑWÔWˆØ×ÒÑÔÐØ×Ò˜[­%Ô*>Ñ?Ô?Ð?Ø×Ò˜[­%Ô*>Ñ?Ô?Ð?Ð?Ð?rA   c                ó.  — t          t          ¦  «        }t          ¦   «         }t          ||gd¬¦  «        }|                     ¦   «          |                      |t
          j        ¦  «         |                      |¦  «        }|                      |d¦  «         dS )a  
        When cancelling an unfired L{DeferredList} with the flag
        C{fireOnOneCallback} set, if one of the L{Deferred} callbacks
        in its canceller, the L{DeferredList} will callback with the
        result and the index of the L{Deferred} in a C{tuple}.
        TrÔ   )rP   r   N)	r!   rT   r#   r   r  r   r   r  ra   r
  s        r?   Ú?test_cancelDeferredListWithFireOnOneCallbackAndDeferredCallbackzMDeferredTests.test_cancelDeferredListWithFireOnOneCallbackAndDeferredCallbackß  sŽ   € õ &.Õ.CÑ%DÔ%DˆÝ%-¡Z¤ZˆÝ# [°+Ð$>ÐRVÐWÑWÔWˆØ×ÒÑÔÐØ×Ò˜[­%Ô*>Ñ?Ô?Ð?Ø×%Ò% lÑ3Ô3ˆØ×Ò˜Ð!7Ñ8Ô8Ð8Ð8Ð8rA   c                óÈ  — t          ¦   «         }t          ¦   «         }t          ||gd¬¦  «        }|                     ¦   «          |                      |t          j        ¦  «         |                      |t          j        ¦  «         |                      |t          j        ¦  «        }|j        }|                      |j	         
                    t          j        ¦  «        ¦  «         dS )z‘
        When cancelling an unfired L{DeferredList} with the flag
        C{fireOnOneErrback} set, cancel every L{Deferred} in the list.
        TrÚ   N)r!   r#   r   r  r   r   rà   re   rc   rá   rd   )rf   r  r  r  ÚdeferredListFailurerä   s         r?   Ú+test_cancelDeferredListWithFireOnOneErrbackz9DeferredTests.test_cancelDeferredListWithFireOnOneErrbackî  s¿   € õ
 '/¡j¤jˆÝ&.¡j¤jˆÝ# [°+Ð$>ÐQUÐVÑVÔVˆØ×ÒÑÔÐØ×Ò˜[­%Ô*>Ñ?Ô?Ð?Ø×Ò˜[­%Ô*>Ñ?Ô?Ð?Ø"×2Ò2°<ÅÔAQÑRÔRÐØ(Ô.ˆ
Ø�Š˜
Ô-×3Ò3µEÔ4HÑIÔIÑJÔJÐJÐJÐJrA   c                óÚ  — t          t          ¦  «        }t          t          ¦  «        }t          ||gd¬¦  «        }|                     ¦   «          |                      |¦  «        }|                      |d         d         ¦  «         |                      |d         d         d¦  «         |                      |d         d         ¦  «         |                      |d         d         d¦  «         dS )zÿ
        When cancelling an unfired L{DeferredList} with the flag
        C{fireOnOneErrback} set, if all the L{Deferred} callbacks
        in its canceller, the L{DeferredList} will callback with a
        C{list} of (success, result) C{tuple}s.
        TrÚ   r   r]   rP   N)r!   rT   r#   r   r  rc   ra   r
  s        r?   Ú?test_cancelDeferredListWithFireOnOneErrbackAllDeferredsCallbackzMDeferredTests.test_cancelDeferredListWithFireOnOneErrbackAllDeferredsCallbacký  sÕ   € õ &.Õ.CÑ%DÔ%DˆÝ%-Õ.CÑ%DÔ%DˆÝ# [°+Ð$>ÐQUÐVÑVÔVˆØ×ÒÑÔÐØ×%Ò% lÑ3Ô3ˆØ�Š˜˜qœ	 !œÑ%Ô%Ð%Ø×Ò˜ œ 1œÐ'8Ñ9Ô9Ð9Ø�Š˜˜qœ	 !œÑ%Ô%Ð%Ø×Ò˜ œ 1œÐ'8Ñ9Ô9Ð9Ð9Ð9rA   c                ó|  — t          ¦   «         }t          ¦   «         }||g}t          |¦  «        }t          ¦   «         }|                     |¦  «         |                     ¦   «          |                      |t
          j        ¦  «         |                      |t
          j        ¦  «         |                      |¦  «         dS )zg
        Cancelling a L{DeferredList} will cancel the original
        L{Deferred}s passed in.
        N)r!   r#   r`   r   r  r   r   ÚassertNoResult)rf   r  r  ÚargumentListr  ÚdeferredThrees         r?   Ú,test_cancelDeferredListWithOriginalDeferredsz:DeferredTests.test_cancelDeferredListWithOriginalDeferreds  s¨   € õ
 '/¡j¤jˆÝ&.¡j¤jˆØ# [Ð1ˆÝ# LÑ1Ô1ˆÝ(0©
¬
ˆØ×Ò˜MÑ*Ô*Ð*Ø×ÒÑÔÐØ×Ò˜[­%Ô*>Ñ?Ô?Ð?Ø×Ò˜[­%Ô*>Ñ?Ô?Ð?Ø×Ò˜MÑ*Ô*Ð*Ð*Ð*rA   c                óL  — dd„}t          |¦  «        }t          ¦   «         }t          ||g¦  «        }|                     ¦   «          |                      |t          j        ¦  «         |                      t          ¦  «        }|                      t          |¦  «        d¦  «         dS )	z®
        Cancelling a L{DeferredList} will cancel every L{Deferred}
        in the list even exceptions raised from the C{cancel} method of the
        L{Deferred}s.
        rL   úDeferred[object]r4   rN   c                ó    — t          d¦  «        ‚)z„
            A L{Deferred} canceller that raises an exception.

            @param deferred: The cancelled L{Deferred}.
            Útest)rn   rS   s    r?   ÚcancellerRaisesExceptionzTDeferredTests.test_cancelDeferredListWithException.<locals>.cancellerRaisesException%  s   € õ ˜vÑ&Ô&Ð&rA   r]   N)rL   r  r4   rN   )
r!   r#   r   r  r   r   rp   rn   ra   rb   )rf   r  r  r  r  rv   s         r?   Ú$test_cancelDeferredListWithExceptionz2DeferredTests.test_cancelDeferredListWithException  s¡   € ð	'ð 	'ð 	'ð 	'õ '/Ð/GÑ&HÔ&HˆÝ&.¡j¤jˆÝ# [°+Ð$>Ñ?Ô?ˆØ×ÒÑÔÐØ×Ò˜[­%Ô*>Ñ?Ô?Ð?Ø×'Ò'­Ñ5Ô5ˆØ×Ò�˜V™œ aÑ(Ô(Ð(Ð(Ð(rA   c                óà   — t          ¦   «         }t          ¦   «         }t          ||gd¬¦  «        }|                     d¦  «         |                     ¦   «          |                      |¦  «         dS )zÜ
        When a L{DeferredList} has fired because one L{Deferred} in
        the list fired with a non-failure result, the cancellation will do
        nothing instead of cancelling the rest of the L{Deferred}s.
        TrÔ   N)r!   r#   rR   r   r  r  s       r?   Ú)test_cancelFiredOnOneCallbackDeferredListz7DeferredTests.test_cancelFiredOnOneCallbackDeferredList5  sn   € õ '/¡j¤jˆÝ&.¡j¤jˆÝ# [°+Ð$>ÐRVÐWÑWÔWˆØ×Ò˜TÑ"Ô"Ð"Ø×ÒÑÔÐØ×Ò˜KÑ(Ô(Ð(Ð(Ð(rA   c                óp  — t          ¦   «         }t          ¦   «         }t          ||gd¬¦  «        }|                     t          d¦  «        ¦  «         |                     ¦   «          |                      |¦  «         |                      |t          ¦  «         |                      |t          j        ¦  «         dS )zØ
        When a L{DeferredList} has fired because one L{Deferred} in
        the list fired with a failure result, the cancellation will do
        nothing instead of cancelling the rest of the L{Deferred}s.
        TrÚ   r  N)	r!   r#   r®   rF   r   r  r  r   rà   r  s       r?   Ú(test_cancelFiredOnOneErrbackDeferredListz6DeferredTests.test_cancelFiredOnOneErrbackDeferredListB  s¥   € õ '/¡j¤jˆÝ&.¡j¤jˆÝ# [°+Ð$>ÐQUÐVÑVÔVˆØ×Ò�L¨Ñ0Ô0Ñ1Ô1Ð1Ø×ÒÑÔÐØ×Ò˜KÑ(Ô(Ð(Ø×Ò˜[­,Ñ7Ô7Ð7Ø×Ò˜\­5Ô+;Ñ<Ô<Ð<Ð<Ð<rA   c                ó”   — g }t          j        d¦  «        }|                     |j        ¦  «         |                      |dg¦  «         d S )NÚsuccess)r   Úsucceedr    r`   ra   ©rf   ÚlÚds      r?   ÚtestImmediateSuccessz"DeferredTests.testImmediateSuccessQ  sH   € ØˆÝ œ=¨Ñ3Ô3ˆØ	�Š�a”hÑÔÐØ×Ò˜˜Y˜KÑ(Ô(Ð(Ð(Ð(rA   c                óÜ   — g }t          j        t          d¦  «        ¦  «        }|                     |j        ¦  «         |                      t          |d         j        ¦  «        d¦  «         d S ©NÚfailr   )r   r-  rF   r_   r`   ra   r²   re   r'  s      r?   ÚtestImmediateFailurez"DeferredTests.testImmediateFailureW  sZ   € ØˆÝ!œJ¥|°FÑ';Ô';Ñ<Ô<ˆØ	�Š�Q”XÑÔÐØ×Ò�˜Q˜qœTœZ™œ¨&Ñ1Ô1Ð1Ð1Ð1rA   c                óX  — g }t          j        t          d¦  «        ¦  «        }|                     ¦   «          |                     |j        ¦  «         |                      |g ¦  «         |                     ¦   «          |                      t          |d         j	        ¦  «        d¦  «         d S r,  )
r   r-  rF   Úpauser_   r`   ra   Úunpauser²   re   r'  s      r?   ÚtestPausedFailurezDeferredTests.testPausedFailure]  sŠ   € ØˆÝŒJ•| FÑ+Ô+Ñ,Ô,ˆØ	�Š‰	Œ	ˆ	Ø	�Š�Q”XÑÔÐØ×Ò˜˜BÑÔÐØ	�	Š	‰ŒˆØ×Ò�˜Q˜qœTœZ™œ¨&Ñ1Ô1Ð1Ð1Ð1rA   c                ó   — g }t          ¦   «         }|                     d„ ¦  «                             |j        ¦  «         |                     d¦  «         |                      |d         j        t          ¦  «         g }t          t                   ¦   «         }|                     d„ ¦  «                             |j        ¦  «         |                     d¦  «         |                      |d         j        t          ¦  «         d S )Nc                ó   — ddz  S ©Nr]   r   rK   ©Ú_s    r?   rö   z2DeferredTests.testCallbackErrors.<locals>.<lambda>i  s
   €   Q¡€ rA   r]   r   c                ó8   — t          t          ¦   «         ¦  «        S r<   )r0   ÚZeroDivisionErrorr6  s    r?   rö   z2DeferredTests.testCallbackErrors.<locals>.<lambda>n  s   € ¥Õ):Ñ)<Ô)<Ñ!=Ô!=€ rA   )	r!   r    r_   r`   rR   ÚassertIsInstancere   r9  Úint)rf   r(  r)  rù   s       r?   ÚtestCallbackErrorsz DeferredTests.testCallbackErrorsf  sÌ   € ØˆÝ#™:œ:ˆØ	�ŠÐ&Ð&Ñ'Ô'×2Ò2°1´8Ñ<Ô<Ð<Ø	�
Š
�1‰ŒˆØ×Ò˜a œdœjÕ*;Ñ<Ô<Ð<ØˆÝ•cŒ]‰_Œ_ˆØ
�ŠÐ=Ð=Ñ>Ô>×IÒIÈ!Ì(ÑSÔSÐSØ
�Š�A‰ŒˆØ×Ò˜a œdœjÕ*;Ñ<Ô<Ð<Ð<Ð<rA   c                ó¦   — t          ¦   «         }|                     ¦   «          |                     | j        ¦  «         |                     ¦   «          d S r<   )r!   r0  r    r”   r1  ©rf   r)  s     r?   ÚtestUnpauseBeforeCallbackz'DeferredTests.testUnpauseBeforeCallbackr  s=   € Ý$™JœJˆØ	�Š‰	Œ	ˆ	Ø	�Š�d”nÑ%Ô%Ð%Ø	�	Š	‰ŒˆˆˆrA   c                óŒ  ‡— t          ¦   «         }t          ¦   «         Š‰                     ¦   «          |                     ˆfd„¦  «         |                     | j        ¦  «         |                     d¦  «         |                      | j        d¦  «         ‰                     d¦  «         |                      | j        d¦  «         ‰                     ¦   «          |                      | j        d¦  «         | j        €
J d¦   «         ‚|  	                    | j        d	         d	         dd
 
                    | j        ¦  «        ¦  «         dS )z›
        Callbacks passed to L{Deferred.addCallback} can return Deferreds and
        the next callback will not be run until that Deferred fires.
        c                ó   •— ‰S r<   rK   )Úrrù   s    €r?   rö   z<DeferredTests.test_callbackReturnsDeferred.<locals>.<lambda>€  s   ø€  € rA   r]   z Should not have been called yet.rÅ   z&Still should not have been called yet.zShould have been called nowNz%make that legible to the type checkerr   z/Result should have been from second deferred:{})r!   r0  r    r”   rR   r¡   rˆ   r1  ÚassertIsNotNoneÚassertEqualsÚformat©rf   ré   rù   s     @r?   Útest_callbackReturnsDeferredz*DeferredTests.test_callbackReturnsDeferredx  s8  ø€ õ
 %™JœJˆÝ$™JœJˆØ
�Š‰
Œ
ˆ
Ø
�Š�|�|�|�|Ñ$Ô$Ð$Ø
�Š�t”~Ñ&Ô&Ð&Ø
�Š�A‰ŒˆØ×Ò˜$Ô.Ð0RÑSÔSÐSØ
�Š�A‰ŒˆØ×ÒØÔ Ð"Jñ	
ô 	
ð 	
ð 	�
Š
‰ŒˆØ×Ò˜TÔ1Ð3PÑQÔQÐQØÔ#Ð/Ð/Ð1XÑ/Ô/Ð/Ø×ÒØÔ  Ô# AÔ&ØØ=×DÒDØÔ$ñô ñ	
ô 	
ð 	
ð 	
ð 	
rA   c                ó
  ‡‡— t          ¦   «         }dŠt          ¦   «         Šdˆˆfd„}|                     d¦  «         |                      |                      |                     |¦  «        ¦  «        d¦  «         t          t                   ¦   «         }d	Š|                     d¦  «         |                      |                      |                     |¦  «                             |¦  «        t          ¦  «        j	        ‰¦  «         d
S )zF
        Callbacks passed to addCallback may return Failures.
        Frs   r;  r4   úUnion[int, Failure]c                ó0   •— ‰rt          ‰¦  «        S | dz   S ©Nr]   r/   )rs   ÚrteÚ
shouldFails    €€r?   Ú	maybeFailzADeferredTests.test_callbackMaybeReturnsFailure.<locals>.maybeFailœ  s!   ø€ àð "Ý˜s‘|”|Ð#à ‘zÐ!rA   é   é   TN)rs   r;  r4   rI  )
r!   rn   rR   ra   r  r    r;  rq   r  re   )rf   r)  rN  rL  rM  s      @@r?   Ú test_callbackMaybeReturnsFailurez.DeferredTests.test_callbackMaybeReturnsFailure“  sý   øø€ õ $™:œ:ˆàˆ
Ý‰nŒnˆð	"ð 	"ð 	"ð 	"ð 	"ð 	"ð 	"ð 	
�
Š
�1‰ŒˆØ×Ò˜×-Ò-¨a¯mªm¸IÑ.FÔ.FÑGÔGÈÑKÔKÐKÝ•SŒM‰OŒOˆØˆ
Ø	�
Š
�1‰ŒˆØ�ŠØ× Ò à—’˜iÑ(Ô(×4Ò4°YÑ?Ô?Ýñô ô Øñ	
ô 	
ð 	
ð 	
ð 	
rA   c                óž  ‡‡— t          ¦   «         }t          ¦   «         Šg Šd
ˆfd„}dˆfd„}|                     |¦  «                             |¦  «         |                     t	          ¦   «         ¦  «         |                      |¦  «         |                      ‰g ¦  «         ‰                     d¦  «         |                      ‰dg¦  «         d	S )zo
        Errbacks passed to L{Deferred.addErrback} can return Deferreds just as
        callbacks can.
        rs   r0   r4   rM   c                ó   •— ‰S r<   rK   )rs   rù   s    €r?   ÚasyncErrbackz?DeferredTests.test_errbackReturnsDeferred.<locals>.asyncErrbackº  s   ø€ ØˆIrA   úUnion[str, int]rN   c                ó2   •— ‰                      | ¦  «         d S r<   rÓ   )rs   ÚresultValuess    €r?   ÚsyncCallbackz?DeferredTests.test_errbackReturnsDeferred.<locals>.syncCallback½  s   ø€ Ø×Ò Ñ'Ô'Ð'Ð'Ð'rA   N)rs   r0   r4   rM   )rs   rU  r4   rN   )r!   r_   r    r®   Ú
ValueErrorr  ra   rR   )rf   r)  rT  rX  rù   rW  s       @@r?   Útest_errbackReturnsDeferredz)DeferredTests.test_errbackReturnsDeferred±  së   øø€ õ
 $™:œ:ˆÝ$™JœJˆØˆð	ð 	ð 	ð 	ð 	ð 	ð	(ð 	(ð 	(ð 	(ð 	(ð 	(ð 	
�Š�\Ñ"Ô"×.Ò.¨|Ñ<Ô<Ð<Ø	�	Š	•*‘,”,ÑÔÐØ×Ò˜AÑÔÐØ×Ò˜ rÑ*Ô*Ð*Ø
�Š�HÑÔÐØ×Ò˜¨ zÑ2Ô2Ð2Ð2Ð2rA   c                óÂ  ‡— t          ¦   «         }t          ¦   «         Š‰                     |¦  «         ‰                     ¦   «          t          ¦   «         }|                     ˆfd„¦  «         |                     d¦  «         g }|                     |j        ¦  «         |                      |g ¦  «         ‰                     ¦   «          |                      ||g¦  «         dS )zÃ
        When a paused Deferred with a result is returned from a callback on
        another Deferred, the other Deferred is chained to the first and waits
        for it to be unpaused.
        c                ó   •— ‰S r<   rK   )ÚignoredÚpauseds    €r?   rö   zDDeferredTests.test_chainedPausedDeferredWithResult.<locals>.<lambda>Ò  s   ø€ ¨F€ rA   N)r8   r!   rR   r0  r    r`   ra   r1  )rf   ÚexpectedÚchainedrs   r^  s       @r?   Ú$test_chainedPausedDeferredWithResultz2DeferredTests.test_chainedPausedDeferredWithResultÇ  sÐ   ø€ õ ‘8”8ˆÝ#+¡:¤:ˆØ�Š˜Ñ!Ô!Ð!Ø�Š‰ŒˆÝ"*¡*¤*ˆØ×ÒÐ2Ð2Ð2Ð2Ñ3Ô3Ð3Ø×Ò˜ÑÔÐà!ˆØ×Ò˜FœMÑ*Ô*Ð*Ø×Ò˜ Ñ$Ô$Ð$Ø�ŠÑÔÐØ×Ò˜ ( Ñ,Ô,Ð,Ð,Ð,rA   c                óR  ‡— t          ¦   «         }t          ¦   «         Š|                     ˆfd„¦  «         |                     d¦  «         |                     ¦   «          ‰                     d¦  «         g }‰                     |j        ¦  «         |                      |dg¦  «         dS )z½
        A paused Deferred encountered while pushing a result forward through a
        chain does not prevent earlier Deferreds from continuing to execute
        their callbacks.
        c                ó   •— ‰S r<   rK   ©r]  Úseconds    €r?   rö   z:DeferredTests.test_pausedDeferredChained.<locals>.<lambda>ã  ó   ø€ ¨&€ rA   N)r!   r    rR   r0  r`   ra   )rf   Úfirstrs   re  s      @r?   Útest_pausedDeferredChainedz(DeferredTests.test_pausedDeferredChainedÛ  sŸ   ø€ õ !)¡
¤
ˆÝ!)¡¤ˆØ×ÒÐ0Ð0Ð0Ð0Ñ1Ô1Ð1Ø�Š�tÑÔÐØ�Š‰ŒˆØ�Š˜ÑÔÐØˆØ×Ò˜6œ=Ñ)Ô)Ð)Ø×Ò˜ $ Ñ(Ô(Ð(Ð(Ð(rA   c                ód  — g }t          j        t          j        d¦  «        t          j        d¦  «        g¦  «                             |j        ¦  «         |                      |ddgg¦  «         g }t          j        d¦  «        t          j        t          ¦   «         ¦  «        g}t          j        |¦  «                             |j        ¦  «         |                      t          |¦  «        d¦  «         |  
                    |d         t          ¦  «         |d                              d„ ¦  «         d S )Nr]   rÅ   r   c                ó   — dS rK  rK   rô   s    r?   rö   z2DeferredTests.test_gatherResults.<locals>.<lambda>ù  s   €  1€ rA   )r   ÚgatherResultsr&  r    r`   ra   r-  rY  r_   rb   r:  r0   )rf   Úresultsrv   rÍ   s       r?   Útest_gatherResultsz DeferredTests.test_gatherResultsë  s  € à#%ˆÝÔ�Uœ]¨1Ñ-Ô-­u¬}¸QÑ/?Ô/?Ð@ÑAÔA×MÒMØŒNñ	
ô 	
ð 	
ð 	×Ò˜ A q 6 (Ñ+Ô+Ð+à "ˆÝŒm˜AÑÔ¥¤
­:©<¬<Ñ 8Ô 8Ð9ˆÝÔ˜BÑÔ×*Ò*¨6¬=Ñ9Ô9Ð9Ø×Ò�˜V™œ aÑ(Ô(Ð(Ø×Ò˜f Qœi­Ñ1Ô1Ð1à
ˆ1Œ×Ò˜˜Ñ%Ô%Ð%Ð%Ð%rA   c                ó.  — t          j        d¦  «        }t          j        t          d¦  «        ¦  «        }t          j        ||gd¬¦  «        }g }|                     |j        ¦  «         g }|                     |j        ¦  «         |                      t          |¦  «        t          |¦  «        fd¦  «         |  	                    |d         j
        t           j        ¦  «         |d         j
        j        }|  	                    |j
        t          ¦  «         dS )zÒ
        If a L{Deferred} in the list passed to L{gatherResults} fires with a
        failure and C{consumerErrors} is C{True}, the failure is converted to a
        L{None} result on that L{Deferred}.
        r]   zoh noesTrï   ©r   r]   r   N)r   r&  r-  rn   rk  r_   r`   ra   rb   r:  re   rà   rá   )rf   ÚdgoodÚdbadr)  ÚunconsumedErrorsÚgatheredErrorsrä   s          r?   Ú#test_gatherResultsWithConsumeErrorsz1DeferredTests.test_gatherResultsWithConsumeErrorsû  sõ   € õ ”˜aÑ Ô ˆÝŒz�, yÑ1Ô1Ñ2Ô2ˆÝÔ ¨ ¸TÐBÑBÔBˆØ*,ÐØ�ŠÐ(Ô/Ñ0Ô0Ð0Ø(*ˆØ	�Š�^Ô*Ñ+Ô+Ð+à×Ò�#Ð.Ñ/Ô/µ°^Ñ1DÔ1DÐEÀvÑNÔNÐNØ×Ò˜n¨QÔ/Ô5µuÔ7GÑHÔHÐHØ# AÔ&Ô,Ô7ˆ
Ø×Ò˜jÔ.µÑ=Ô=Ð=Ð=Ð=rA   c                óÎ  — t          ¦   «         }t          ¦   «         }t          j        ||g¦  «        }|                     ¦   «          |                      |t          j        ¦  «         |                      |t          j        ¦  «         |                      |t          j        ¦  «        }|j        }|                      |j	         
                    t          j        ¦  «        ¦  «         dS )z~
        When cancelling the L{defer.gatherResults} call, all the
        L{Deferred}s in the list will be cancelled.
        N)r!   r   rk  r   r  r   rà   re   rc   rá   rd   )rf   r  r  rs   ÚgatherResultsFailurerä   s         r?   Útest_cancelGatherResultsz&DeferredTests.test_cancelGatherResults  s·   € õ
 '/¡j¤jˆÝ&.¡j¤jˆÝÔ$ k°;Ð%?Ñ@Ô@ˆØ�Š‰ŒˆØ×Ò˜[­%Ô*>Ñ?Ô?Ð?Ø×Ò˜[­%Ô*>Ñ?Ô?Ð?Ø#×3Ò3°F½EÔ<LÑMÔMÐØ)Ô/ˆ
Ø�Š˜
Ô-×3Ò3µEÔ4HÑIÔIÑJÔJÐJÐJÐJrA   c                óD  — t          t          ¦  «        }t          t          ¦  «        }t          j        ||g¦  «        }|                     ¦   «          |                      |¦  «        }|                      |d         d¦  «         |                      |d         d¦  «         dS )zö
        When cancelling the L{defer.gatherResults} call, if all the
        L{Deferred}s callback in their canceller, the L{Deferred}
        returned by L{defer.gatherResults} will be callbacked with the C{list}
        of the results.
        r   rP   r]   N)r!   rT   r   rk  r   r  ra   )rf   r  r  rs   ÚcallbackResults        r?   Ú0test_cancelGatherResultsWithAllDeferredsCallbackz>DeferredTests.test_cancelGatherResultsWithAllDeferredsCallback  s“   € õ &.Õ.CÑ%DÔ%DˆÝ%-Õ.CÑ%DÔ%DˆÝÔ$ k°;Ð%?Ñ@Ô@ˆØ�Š‰ŒˆØ×-Ò-¨fÑ5Ô5ˆØ×Ò˜¨Ô*Ð,=Ñ>Ô>Ð>Ø×Ò˜¨Ô*Ð,=Ñ>Ô>Ð>Ð>Ð>rA   c                óD  ‡— t          ¦   «         Šg }g }t          j        ˆfd„¦  «        }|                     |j        |j        ¦  «         |                      |g ¦  «         |                      t          |¦  «        d¦  «         |                      |d         ‰¦  «         dS )z�
        L{defer.maybeDeferred} should retrieve the result of a synchronous
        function and pass it to its resulting L{Deferred}.
        c                 ó   •— ‰ S r<   rK   ©rs   s   €r?   rö   z6DeferredTests.test_maybeDeferredSync.<locals>.<lambda>5  s   ø€ ¨€ rA   r]   r   N)r8   r   ÚmaybeDeferredr­   r`   ra   rb   ÚassertIdentical)rf   rl  rv   r)  rs   s       @r?   Útest_maybeDeferredSyncz$DeferredTests.test_maybeDeferredSync-  s˜   ø€ õ
 ‘”ˆØ "ˆØ "ˆÝÔ    Ñ/Ô/ˆØ	�Š�w”~ v¤}Ñ5Ô5Ð5Ø×Ò˜ Ñ$Ô$Ð$Ø×Ò�˜W™œ qÑ)Ô)Ð)Ø×Ò˜W QœZ¨Ñ0Ô0Ð0Ð0Ð0rA   c                ó  — dd„}g }g }t          j        |d¦  «        }t          |t          t                   ¦  «         |                     |j        |j        ¦  «         |                      |g ¦  «         |                      |dg¦  «         dS )	zV
        L{defer.maybeDeferred} should pass arguments to the called function.
        Úxr;  r4   c                ó   — | dz   S )Né   rK   ©r‚  s    r?   ÚplusFivez>DeferredTests.test_maybeDeferredSyncWithArgs.<locals>.plusFive@  s   € Ø�q‘5ˆLrA   é
   é   N)r‚  r;  r4   r;  )r   r~  r   r!   r;  r­   r`   ra   )rf   r†  rl  rv   r)  s        r?   Útest_maybeDeferredSyncWithArgsz,DeferredTests.test_maybeDeferredSyncWithArgs;  s”   € ð
	ð 	ð 	ð 	ð  ˆØ "ˆÝÔ ¨"Ñ-Ô-ˆÝ�A•x¥”}Ñ%Ô%Ð%Ø	�Š�w”~ v¤}Ñ5Ô5Ð5Ø×Ò˜ Ñ$Ô$Ð$Ø×Ò˜ 2 $Ñ'Ô'Ð'Ð'Ð'rA   c                ó†  ‡— t          d¦  «        Šdˆfd„}g }g }t          j        |¦  «                             |j        |j        ¦  «         |                      |g ¦  «         |                      t          |¦  «        d¦  «         |                      t          |d         j        ¦  «        t          ‰¦  «        ¦  «         dS )	zš
        L{defer.maybeDeferred} should catch an exception raised by a synchronous
        function and errback its resulting L{Deferred} with it.
        zthat value is unacceptabler4   r   c                 ó   •— ‰ ‚r<   rK   ©r_  s   €r?   ÚraisesExceptionzFDeferredTests.test_maybeDeferredSyncException.<locals>.raisesExceptionR  s   ø€ ØˆNrA   r]   r   N)r4   r   )	rY  r   r~  r­   r`   ra   rb   r²   re   )rf   r�  rl  rv   r_  s       @r?   Útest_maybeDeferredSyncExceptionz-DeferredTests.test_maybeDeferredSyncExceptionK  sÄ   ø€ õ
 Ð:Ñ;Ô;ˆð	ð 	ð 	ð 	ð 	ð 	ð  ˆØ "ˆÝÔ˜OÑ,Ô,×9Ò9¸'¼.È&Ì-ÑXÔXÐXØ×Ò˜ "Ñ%Ô%Ð%Ø×Ò�˜V™œ aÑ(Ô(Ð(Ø×Ò�˜V AœYœ_Ñ-Ô-­s°8©}¬}Ñ=Ô=Ð=Ð=Ð=rA   c                ór  ‡— 	 ddz    n# t           $ r t          ¦   «         ŠY nw xY wg }g }t          j        ˆfd„¦  «        }|                     |j        |j        ¦  «         |                      |g ¦  «         |                      t          |¦  «        d¦  «         |                      |d         ‰¦  «         dS )zw
        L{defer.maybeDeferred} should handle a L{Failure} returned by a
        function and errback with it.
        Ú10r„  c                 ó   •— ‰ S r<   rK   rŒ  s   €r?   rö   z=DeferredTests.test_maybeDeferredSyncFailure.<locals>.<lambda>h  s   ø€ ¨€ rA   r]   r   N)	Ú	TypeErrorr0   r   r~  r­   r`   ra   rb   r  )rf   rl  rv   r)  r_  s       @r?   Útest_maybeDeferredSyncFailurez+DeferredTests.test_maybeDeferredSyncFailure\  sË   ø€ ð
	!Ø�1‰HˆHˆHøÝð 	!ð 	!ð 	!Ý‘y”yˆHˆHˆHð	!øøøð  ˆØ "ˆÝÔÐ 0Ð 0Ð 0Ð 0Ñ1Ô1ˆØ	�Š�w”~ v¤}Ñ5Ô5Ð5Ø×Ò˜ "Ñ%Ô%Ð%Ø×Ò�˜V™œ aÑ(Ô(Ð(Ø×Ò˜V AœY¨Ñ1Ô1Ð1Ð1Ð1s   ƒ	 ‰$£$c                óâ   ‡— t          ¦   «         Št          j        ˆfd„¦  «        }‰                     d¦  «         g }|                     |j        ¦  «         |                      |dg¦  «         dS )z}
        L{defer.maybeDeferred} should let L{Deferred} instance pass by
        so that original result is the same.
        c                 ó   •— ‰ S r<   rK   ©ré   s   €r?   rö   z7DeferredTests.test_maybeDeferredAsync.<locals>.<lambda>t  s   ø€ ¨€ rA   ÚSuccessN)r!   r   r~  rR   r    r`   ra   )rf   rù   rs   ré   s      @r?   Útest_maybeDeferredAsyncz%DeferredTests.test_maybeDeferredAsyncn  sm   ø€ õ
 %™JœJˆÝÔ     Ñ,Ô,ˆØ
�Š�IÑÔÐØˆØ
�Š�v”}Ñ%Ô%Ð%Ø×Ò˜ ) Ñ-Ô-Ð-Ð-Ð-rA   c                óä   ‡— t          ¦   «         Št          j        ˆfd„¦  «        }‰                     t	          t          ¦   «         ¦  «        ¦  «         |                      |t
          ¦  «         dS )z¢
        L{defer.maybeDeferred} should let L{Deferred} instance pass by
        so that L{Failure} returned by the original instance is the
        same.
        c                 ó   •— ‰ S r<   rK   r–  s   €r?   rö   z<DeferredTests.test_maybeDeferredAsyncError.<locals>.<lambda>�  s   ø€ ¸€ rA   N)r!   r   r~  r®   r0   rn   ri   )rf   rù   ré   s     @r?   Útest_maybeDeferredAsyncErrorz*DeferredTests.test_maybeDeferredAsyncErrorz  s^   ø€ õ &™ZœZˆÝ"Ô0°°°°Ñ<Ô<ˆØ
�
Š
•7�<™>œ>Ñ*Ô*Ñ+Ô+Ð+Ø×#Ò# B­Ñ5Ô5Ð5Ð5Ð5rA   c                óÈ   — dd„}t          j        |¦  «        }t          |t          t                   ¦  «         |                      |                      |¦  «        d¦  «         dS )ú¿
        When called with a coroutine function L{defer.maybeDeferred} returns a
        L{defer.Deferred} which has the same result as the coroutine returned
        by the function.
        r4   r;  c               “  ó
   K  — dS ©NrP  rK   rK   rA   r?   r2   z;DeferredTests.test_maybeDeferredCoroutineSuccess.<locals>.fŒ  ó   è è € Ø�1rA   rP  N©r4   r;  )r   r~  r   r!   r;  ra   r  )rf   r2   ÚcoroutineDeferreds      r?   Ú"test_maybeDeferredCoroutineSuccessz0DeferredTests.test_maybeDeferredCoroutineSuccess…  si   € ð	ð 	ð 	ð 	õ "Ô/°Ñ2Ô2ÐÝÐ%¥xµ¤}Ñ5Ô5Ð5Ø×Ò˜×-Ò-Ð.?Ñ@Ô@À!ÑDÔDÐDÐDÐDrA   c                ó  ‡— d
d„Šdˆfd„}dd„}t          j        |¦  «        }t          |t          t                   ¦  «         |                     |¦  «        }|                      |                      |¦  «        d¦  «         d	S )r�  r4   r;  c               “  ó
   K  — dS rŸ  rK   rK   rA   r?   r2   zCDeferredTests.test_maybeDeferredCoroutineSuccessIndirect.<locals>.fš  r   rA   ú"Coroutine[Deferred[int], Any, Any]c                 ó   •—  ‰ ¦   «         S r<   rK   ©r2   s   €r?   ÚgzCDeferredTests.test_maybeDeferredCoroutineSuccessIndirect.<locals>.gŸ  ó   ø€ Ø�1‘3”3ˆJrA   rs   c                ó   — | dz   S rK  rK   r}  s    r?   ÚtypedCallbackzODeferredTests.test_maybeDeferredCoroutineSuccessIndirect.<locals>.typedCallback¤  s   € Ø˜A‘:ÐrA   é   Nr¡  )r4   r¦  )rs   r;  r4   r;  )r   r~  r   r!   r   r    ra   r  )rf   r©  r¬  r¢  ÚmodifiedDeferredr2   s        @r?   Ú*test_maybeDeferredCoroutineSuccessIndirectz8DeferredTests.test_maybeDeferredCoroutineSuccessIndirect“  s°   ø€ ð	ð 	ð 	ð 	ð
	ð 	ð 	ð 	ð 	ð 	ð
	ð 	ð 	ð 	õ "Ô/°Ñ2Ô2ÐÝÐ%¥xµ¤}Ñ5Ô5Ð5Ø,×8Ò8¸ÑGÔGÐØ×Ò˜×-Ò-Ð.>Ñ?Ô?ÀÑCÔCÐCÐCÐCrA   c                óÖ   ‡‡—  G d„ dt           ¦  «        Šd	ˆfd„Šd
ˆfd„}t          |                      t          j        |¦  «        ¦  «        j        t          ‰¦  «        ¦  «         dS )zÑ
        When called with a coroutine function L{defer.maybeDeferred} returns a
        L{defer.Deferred} which has a L{Failure} result wrapping the exception
        raised by the coroutine function.
        c                  ó   — e Zd ZdS )úGDeferredTests.test_maybeDeferredCoroutineFailure.<locals>.SomeExceptionNrG   rK   rA   r?   ÚSomeExceptionr²  ³  ó   € € € € € ØˆDrA   r³  r4   rN   c               “  ó   •K  —  ‰ ¦   «         ‚r<   rK   )r³  s   €r?   r2   z;DeferredTests.test_maybeDeferredCoroutineFailure.<locals>.f¶  s   øè è € Ø�-‘/”/Ð!rA   úCoroutine[None, None, None]c                 ó   •—  ‰ ¦   «         S r<   rK   r¨  s   €r?   r©  z;DeferredTests.test_maybeDeferredCoroutineFailure.<locals>.g»  rª  rA   Nr„   )r4   r¶  )Ú	Exceptionr   r  r   r~  rß   r   )rf   r©  r³  r2   s     @@r?   Ú"test_maybeDeferredCoroutineFailurez0DeferredTests.test_maybeDeferredCoroutineFailure¬  s²   øø€ ð	ð 	ð 	ð 	ð 	�Iñ 	ô 	ð 	ð	"ð 	"ð 	"ð 	"ð 	"ð 	"ð
	ð 	ð 	ð 	ð 	ð 	õ 	Ø× Ò ¥Ô!4°QÑ!7Ô!7Ñ8Ô8Ô=Ý�]Ñ#Ô#ñ	
ô 	
ð 	
ð 	
ð 	
rA   c                ó´  ‡‡‡— g Šg Št          ¦   «         Šd
ˆˆˆfd„}t          j        d¦  «        }|                     |¦  «         ‰                     d¦  «         |                     ‰j        ¦  «         ‰                     ‰j        ¦  «         |                     ‰j        ¦  «         |                      g ‰¦  «         |                      ‰g d¢¦  «         d	S )a  
        When a L{Deferred} encounters a result which is another L{Deferred}
        which is waiting on a third L{Deferred}, the middle L{Deferred}'s
        callbacks are executed after the third L{Deferred} fires and before the
        first receives a result.
        rs   r²   r4   rM   c                óü   •— ‰                      d| f¦  «         t          j        d¦  «        }d	ˆˆfd„}d
ˆfd„}|                     |¦  «                             |¦  «         |                     ‰j         ¦  «         |S )Nústart-of-cbÚinnerrs   r²   r4   rM   c                ó2   •— ‰                      d¦  «         ‰S ©N©ÚfirstCallbackr½  rÓ   ©rs   r½  rl  s    €€r?   rÁ  zMDeferredTests.test_innerCallbacksPreserved.<locals>.cb.<locals>.firstCallbackÒ  s   ø€ Ø—’Ð9Ñ:Ô:Ð:Ø�rA   c                ó<   •— ‰                      d| f¦  «         | dz  S ©NÚsecondCallbackrÅ   rÓ   ©rs   rl  s    €r?   rÅ  zNDeferredTests.test_innerCallbacksPreserved.<locals>.cb.<locals>.secondCallbackÖ  ó%   ø€ Ø—’Ð 0°&Ð9Ñ:Ô:Ð:Ø ‘zÐ!rA   ©rs   r²   r4   rM   ©rs   r²   r4   r²   ©r`   r   r&  r    r_   ©rs   r)  rÁ  rÅ  rh   r½  rl  s       €€€r?   r¼   z6DeferredTests.test_innerCallbacksPreserved.<locals>.cbÎ  s¥   ø€ Ø�NŠN˜M¨6Ð2Ñ3Ô3Ð3Ý”˜gÑ&Ô&ˆAðð ð ð ð ð ð ð"ð "ð "ð "ð "ð "ð �MŠM˜-Ñ(Ô(×4Ò4°^ÑDÔDÐDØ�LŠL˜œÑ)Ô)Ð)ØˆHrA   ÚouterÚorange©©r¼  rÌ  rÀ  )rÅ  rÍ  ÚorangeorangeNrÈ  )r!   r   r&  r    rR   r`   r_   ra   ©rf   r¼   rÌ  rh   r½  rl  s      @@@r?   Útest_innerCallbacksPreservedz*DeferredTests.test_innerCallbacksPreservedÃ  s  øøø€ ð 68ˆØ"$ˆÝ'™zœzˆð	ð 	ð 	ð 	ð 	ð 	ð 	ð 	õ  ”˜gÑ&Ô&ˆØ×Ò˜"ÑÔÐØ�Š�xÑ Ô Ð Ø×Ò˜'œ.Ñ)Ô)Ð)Ø×Ò˜œÑ)Ô)Ð)Ø×Ò˜œÑ)Ô)Ð)Ø×Ò˜˜XÑ&Ô&Ð&Ø×ÒØðð ð ñ	
ô 	
ð 	
ð 	
ð 	
rA   c                ó|  ‡‡‡— g Šg Št          ¦   «         Šdˆˆˆfd„}t          j        d¦  «                             |¦  «                             ‰j        ¦  «         |                      ddg‰¦  «         ‰                     d	¦  «         |                      g ‰¦  «         |                      ‰ddd
d	gfg¦  «         dS )a   
        The continue callback of a L{Deferred} waiting for another L{Deferred}
        is not necessarily the first one. This is somewhat a whitebox test
        checking that we search for that callback among the whole list of
        callbacks.
        rs   r²   r4   úDeferred[None]c                ó  •— ‰                      d| f¦  «         t          ¦   «         }d	ˆˆfd„}d
ˆfd„}|                     |¦  «                             |¦  «                             ‰j         ¦  «        }|                     d ¦  «         |S )Nr¼   rs   rN   r4   úDeferred[List[str]]c                ó\   •— ‰                      d| f¦  «         t          j        ‰g¦  «        S ©NrÁ  ©r`   r   rk  ©rs   Úarl  s    €€r?   rÁ  zNDeferredTests.test_continueCallbackNotFirst.<locals>.cb.<locals>.firstCallbackþ  ó-   ø€ Ø—’ °Ð8Ñ9Ô9Ð9ÝÔ*¨A¨3Ñ/Ô/Ð/rA   ú	List[str]c                ó6   •— ‰                      d| f¦  «         d S ©NrÅ  rÓ   rÆ  s    €r?   rÅ  zODeferredTests.test_continueCallbackNotFirst.<locals>.cb.<locals>.secondCallback  ó!   ø€ Ø—’Ð 0°&Ð9Ñ:Ô:Ð:Ð:Ð:rA   ©rs   rN   r4   rÖ  ©rs   rÝ  r4   rN   ©r`   r!   r    r_   rR   ©rs   r)  rÁ  rÅ  ÚreturnerrÛ  rh   rl  s        €€€r?   r¼   z7DeferredTests.test_continueCallbackNotFirst.<locals>.cbú  ó®   ø€ Ø�NŠN˜D &˜>Ñ*Ô*Ð*Ý (¡
¤
ˆAð0ð 0ð 0ð 0ð 0ð 0ð 0ð;ð ;ð ;ð ;ð ;ð ;ð —’˜mÑ,Ô,ß’˜^Ñ,Ô,ß’˜HœOÑ,Ô,ð ð
 �JŠJ�tÑÔÐØˆOrA   rÌ  ©r¼   rÌ  ©rÁ  NÚwithersrÅ  N©rs   r²   r4   rÔ  )r!   r   r&  r    r_   r`   ra   rR   )rf   r¼   rÛ  rh   rl  s     @@@r?   Útest_continueCallbackNotFirstz+DeferredTests.test_continueCallbackNotFirstï  sð   øøø€ ð BDˆØ"$ˆÝ#™:œ:ˆð	ð 	ð 	ð 	ð 	ð 	ð 	ð 	õ& 	Œ�gÑÔ×*Ò*¨2Ñ.Ô.×9Ò9¸(¼/ÑJÔJÐJØ×Ò˜/Ð+BÐCÀWÑMÔMÐMØ	�
Š
�9ÑÔÐØ×Ò˜˜XÑ&Ô&Ð&Ø×ÒØØÐ5Ð8HÈ9È+Ð7VÐWñ	
ô 	
ð 	
ð 	
ð 	
rA   c                óÔ  ‡‡‡— g Šg Št          ¦   «         Šdˆˆˆfd„}t          ¦   «         }|                     |¦  «         |                     ˆfd„¦  «         |                     ‰j        ¦  «         |                     d¦  «         |                      dd	g‰¦  «         ‰                     d
¦  «         |                      g ‰¦  «         |                      ‰dd	dd
gfdg¦  «         dS )zÃ
        A callback added to a L{Deferred} after a previous callback attached
        another L{Deferred} as a result is run after the callbacks of the other
        L{Deferred} are run.
        rs   r²   r4   rÔ  c                ó  •— ‰                      d| f¦  «         t          ¦   «         }d	ˆˆfd„}d
ˆfd„}|                     |¦  «                             |¦  «                             ‰j         ¦  «        }|                     d ¦  «         |S )Nr¼   rs   rN   r4   rÖ  c                ó\   •— ‰                      d| f¦  «         t          j        ‰g¦  «        S rØ  rÙ  rÚ  s    €€r?   rÁ  zLDeferredTests.test_callbackOrderPreserved.<locals>.cb.<locals>.firstCallback$  rÜ  rA   rÝ  c                ó6   •— ‰                      d| f¦  «         d S rß  rÓ   rÆ  s    €r?   rÅ  zMDeferredTests.test_callbackOrderPreserved.<locals>.cb.<locals>.secondCallback(  rà  rA   rá  râ  rã  rä  s        €€€r?   r¼   z5DeferredTests.test_callbackOrderPreserved.<locals>.cb   ræ  rA   c                ó.   •— ‰                      d¦  «        S )N©ÚfinalNrÓ   )r‚  rl  s    €r?   rö   z;DeferredTests.test_callbackOrderPreserved.<locals>.<lambda>5  s   ø€  G§N¢N°?Ñ$CÔ$C€ rA   rÌ  rç  rè  ré  rÅ  rñ  Nrê  )r!   r    r_   r`   rR   ra   )rf   r¼   rÌ  rÛ  rh   rl  s      @@@r?   Útest_callbackOrderPreservedz)DeferredTests.test_callbackOrderPreserved  s*  øøø€ ð BDˆØ"$ˆÝ#™:œ:ˆð	ð 	ð 	ð 	ð 	ð 	ð 	ð 	õ&  (™zœzˆØ×Ò˜"ÑÔÐØ×ÒÐCÐCÐCÐCÑDÔDÐDØ×Ò˜œÑ)Ô)Ð)Ø�Š�wÑÔÐØ×Ò˜/Ð+BÐCÀWÑMÔMÐMØ	�
Š
�9ÑÔÐØ×Ò˜˜XÑ&Ô&Ð&Ø×ÒØàØ'Ø! I ;Ð/Øð	ñ	
ô 	
ð 	
ð 	
ð 	
rA   c                ó  ‡‡‡— t          ¦   «         Šg Šd	ˆfd„Šd	ˆfd„}d	ˆˆˆfd„}‰                     |¦  «         ‰                     |¦  «         ‰                     d¦  «         |                      ‰g d¢¦  «         dS )
z�
        A callback added to a L{Deferred} by a callback on that L{Deferred}
        should be added to the end of the callback chain.
        rs   rN   r4   c                ó2   •— ‰                      d¦  «         d S ©Né   rÓ   ©rs   Úcalleds    €r?   Ú	callback3z;DeferredTests.test_reentrantRunCallbacks.<locals>.callback3M  ó   ø€ Ø�MŠM˜!ÑÔÐÐÐrA   c                ó2   •— ‰                      d¦  «         d S ©NrÅ   rÓ   rø  s    €r?   Ú	callback2z;DeferredTests.test_reentrantRunCallbacks.<locals>.callback2P  rû  rA   c                ó\   •— ‰                      d¦  «         ‰                     ‰¦  «         d S rK  ©r`   r    )rs   rú  rù  rL   s    €€€r?   Ú	callback1z;DeferredTests.test_reentrantRunCallbacks.<locals>.callback1S  s/   ø€ Ø�MŠM˜!ÑÔÐØ× Ò  Ñ+Ô+Ð+Ð+Ð+rA   N)r]   rÅ   r÷  ©rs   rN   r4   rN   ©r!   r    rR   ra   )rf   rþ  r  rú  rù  rL   s      @@@r?   Útest_reentrantRunCallbacksz(DeferredTests.test_reentrantRunCallbacksE  s×   øøø€ õ
 $,¡:¤:ˆØˆð	ð 	ð 	ð 	ð 	ð 	ð	ð 	ð 	ð 	ð 	ð 	ð	,ð 	,ð 	,ð 	,ð 	,ð 	,ð 	,ð 	,ð 	×Ò˜YÑ'Ô'Ð'Ø×Ò˜YÑ'Ô'Ð'Ø×Ò˜$ÑÔÐØ×Ò˜   Ñ+Ô+Ð+Ð+Ð+rA   c                óÐ   ‡ ‡‡‡— t          ¦   «         Šg Šd	ˆfd„Šd	ˆˆˆˆ fd„}‰                     |¦  «         ‰                     d¦  «         ‰                      ‰ddg¦  «         dS )
z˜
        A callback added to a L{Deferred} by a callback on that L{Deferred}
        should not be executed until the running callback returns.
        rs   rN   r4   c                ó2   •— ‰                      d¦  «         d S rý  rÓ   rø  s    €r?   rþ  z;DeferredTests.test_nonReentrantCallbacks.<locals>.callback2d  rû  rA   c                óŠ   •— ‰                      d¦  «         ‰                     ‰¦  «         ‰                     ‰dg¦  «         d S rK  )r`   r    ra   )rs   rþ  rù  rL   rf   s    €€€€r?   r  z;DeferredTests.test_nonReentrantCallbacks.<locals>.callback1g  sG   ø€ Ø�MŠM˜!ÑÔÐØ× Ò  Ñ+Ô+Ð+Ø×Ò˜V a SÑ)Ô)Ð)Ð)Ð)rA   Nr]   rÅ   r  r  )rf   r  rþ  rù  rL   s   ` @@@r?   Útest_nonReentrantCallbacksz(DeferredTests.test_nonReentrantCallbacks\  s«   øøøø€ õ
 $,¡:¤:ˆØˆð	ð 	ð 	ð 	ð 	ð 	ð	*ð 	*ð 	*ð 	*ð 	*ð 	*ð 	*ð 	*ð 	*ð
 	×Ò˜YÑ'Ô'Ð'Ø×Ò˜$ÑÔÐØ×Ò˜ ! Q Ñ(Ô(Ð(Ð(Ð(rA   c                ó  ‡‡‡— dŠt          ¦   «         Šd	ˆfd„Šd	ˆˆfd„}‰                     |¦  «         ‰                     d¦  «         |                      ‰t          ¦  «        }|                      |j        ‰f¦  «         dS )
zé
        After an exception is raised by a callback which was added to a
        L{Deferred} by a callback on that L{Deferred}, the L{Deferred} should
        call the first errback with a L{Failure} wrapping that exception.
        zcallback raised exceptionrs   r8   r4   rN   c                ó"   •— t          ‰¦  «        ‚r<   )r¸  )rs   ÚexceptionMessages    €r?   rþ  zFDeferredTests.test_reentrantRunCallbacksWithFailure.<locals>.callback2y  s   ø€ ÝÐ,Ñ-Ô-Ð-rA   c                ó2   •— ‰                      ‰¦  «         d S r<   )r    )rs   rþ  rL   s    €€r?   r  zFDeferredTests.test_reentrantRunCallbacksWithFailure.<locals>.callback1|  s   ø€ Ø× Ò  Ñ+Ô+Ð+Ð+Ð+rA   N©rs   r8   r4   rN   )r!   r    rR   ri   r¸  ra   r7   )rf   r  rZ   rþ  rL   r  s      @@@r?   Ú%test_reentrantRunCallbacksWithFailurez3DeferredTests.test_reentrantRunCallbacksWithFailurep  s¸   øøø€ ð 7ÐÝ#+¡:¤:ˆð	.ð 	.ð 	.ð 	.ð 	.ð 	.ð	,ð 	,ð 	,ð 	,ð 	,ð 	,ð 	,ð 	×Ò˜YÑ'Ô'Ð'Ø×Ò˜$ÑÔÐØ×/Ò/°½)ÑDÔDˆ	Ø×Ò˜œÐ*:Ð)<Ñ=Ô=Ð=Ð=Ð=rA   c                óœ  ‡— t          ¦   «         }t          j        |¦  «        Št          ¦   «         }|                     ˆfd„¦  «         |                     d¦  «         g }‰                     |j        ¦  «         |                      |d         ¦  «         |                     |j        ¦  «         |                      |d         |¦  «         dS )a  
        If a first L{Deferred} with a result is returned from a callback on a
        second L{Deferred}, the result of the second L{Deferred} becomes the
        result of the first L{Deferred} and the result of the first L{Deferred}
        becomes L{None}.
        c                ó   •— ‰S r<   rK   ©Úignrg  s    €r?   rö   z=DeferredTests.test_synchronousImplicitChain.<locals>.<lambda>Ž  ó   ø€  u€ rA   Nr   r]   )	r8   r   r&  r!   r    rR   r`   r¡   rq   )rf   rs   re  rl  rg  s       @r?   Útest_synchronousImplicitChainz+DeferredTests.test_synchronousImplicitChain„  s½   ø€ õ ‘”ˆÝ”˜fÑ%Ô%ˆÝ!)¡¤ˆØ×ÒÐ,Ð,Ð,Ð,Ñ-Ô-Ð-Ø�Š˜ÑÔÐà*,ˆØ×Ò˜'œ.Ñ)Ô)Ð)Ø×Ò˜' !œ*Ñ%Ô%Ð%Ø×Ò˜7œ>Ñ*Ô*Ð*Ø�Š�g˜a”j &Ñ)Ô)Ð)Ð)Ð)rA   c                ó  ‡— t          ¦   «         Št          ¦   «         }|                     ˆfd„¦  «         |                     d¦  «         g }‰                     |j        ¦  «         g }|                     |j        ¦  «         |                      |g ¦  «         |                      |g ¦  «         t          ¦   «         }‰                     |¦  «         |                      |dg¦  «         |                      ||g¦  «         dS )a9  
        If a first L{Deferred} without a result is returned from a callback on
        a second L{Deferred}, the result of the second L{Deferred} becomes the
        result of the first L{Deferred} as soon as the first L{Deferred} has
        one and the result of the first L{Deferred} becomes L{None}.
        c                ó   •— ‰S r<   rK   r  s    €r?   rö   z>DeferredTests.test_asynchronousImplicitChain.<locals>.<lambda>   r  rA   N)r!   r    rR   r`   ra   r8   )rf   re  rì   ÚsecondResultrs   rg  s        @r?   Útest_asynchronousImplicitChainz,DeferredTests.test_asynchronousImplicitChain—  sü   ø€ õ #+¡*¤*ˆÝ#+¡:¤:ˆØ×ÒÐ,Ð,Ð,Ð,Ñ-Ô-Ð-Ø�Š˜ÑÔÐà$&ˆØ×Ò˜+Ô,Ñ-Ô-Ð-Ø%'ˆØ×Ò˜<Ô.Ñ/Ô/Ð/à×Ò˜ bÑ)Ô)Ð)Ø×Ò˜ rÑ*Ô*Ð*å‘”ˆØ�Š�vÑÔÐà×Ò˜ t fÑ-Ô-Ð-Ø×Ò˜¨ xÑ0Ô0Ð0Ð0Ð0rA   c                óh  — t          j        t          d¦  «        ¦  «        }|fd
d„}t          ¦   «         }|                     |¦  «         |                     d¦  «         g }|                     |j        ¦  «         |                      |d	         ¦  «         |                      |t          ¦  «         dS )a  
        If a first L{Deferred} with a L{Failure} result is returned from a
        callback on a second L{Deferred}, the first L{Deferred}'s result is
        converted to L{None} and no unhandled error is logged when it is
        garbage collected.
        úFirst Deferred's Failurer7  rN   rg  rÔ  r4   c                ó   — |S r<   rK   )r7  rg  s     r?   r¼   z<DeferredTests.test_synchronousImplicitErrorChain.<locals>.cbº  s   € ØˆLrA   Nr   )r7  rN   rg  rÔ  r4   rÔ  )	r   r-  rn   r!   r    rR   r`   r¡   ri   )rf   rg  r¼   re  rì   s        r?   Ú"test_synchronousImplicitErrorChainz0DeferredTests.test_synchronousImplicitErrorChain±  s¹   € õ ”
�<Ð(BÑCÔCÑDÔDˆà05ð 	ð 	ð 	ð 	ð 	õ "*¡¤ˆØ×Ò˜2ÑÔÐØ�Š˜ÑÔÐØ"$ˆØ×Ò˜+Ô,Ñ-Ô-Ð-Ø×Ò˜+ aœ.Ñ)Ô)Ð)Ø×#Ò# F­LÑ9Ô9Ð9Ð9Ð9rA   c                ó¸  ‡— t          ¦   «         Št          ¦   «         }|                     ˆfd„¦  «         |                     d¦  «         g }|                     |j        ¦  «         g }‰                     |j        ¦  «         g }|                     |j        ¦  «         |                      |g ¦  «         |                      |g ¦  «         ‰                     t          d¦  «        ¦  «         |                      |d          	                    t          ¦  «        ¦  «         |                      |dg¦  «         |                      t          |¦  «        d¦  «         dS )aP  
        Let C{a} and C{b} be two L{Deferred}s.

        If C{a} has no result and is returned from a callback on C{b} then when
        C{a} fails, C{b}'s result becomes the L{Failure} that was C{a}'s result,
        the result of C{a} becomes L{None} so that no unhandled error is logged
        when it is garbage collected.
        c                ó   •— ‰S r<   rK   r  s    €r?   rö   zCDeferredTests.test_asynchronousImplicitErrorChain.<locals>.<lambda>Ð  r  rA   Nr  r   r]   )r!   r    rR   r_   r`   ra   r®   rn   rc   rd   rb   )rf   re  ÚsecondErrorrì   r  rg  s        @r?   Ú#test_asynchronousImplicitErrorChainz1DeferredTests.test_asynchronousImplicitErrorChainÅ  sB  ø€ õ !)¡
¤
ˆÝ!)¡¤ˆØ×ÒÐ,Ð,Ð,Ð,Ñ-Ô-Ð-Ø�Š˜ÑÔÐØ%'ˆØ×Ò˜+Ô,Ñ-Ô-Ð-à"$ˆØ×Ò˜+Ô,Ñ-Ô-Ð-Ø#%ˆØ×Ò˜<Ô.Ñ/Ô/Ð/à×Ò˜ bÑ)Ô)Ð)Ø×Ò˜ rÑ*Ô*Ð*à�Š•lÐ#=Ñ>Ô>Ñ?Ô?Ð?Ø�Š˜ Aœ×,Ò,­\Ñ:Ô:Ñ;Ô;Ð;Ø×Ò˜ t fÑ-Ô-Ð-Ø×Ò�˜\Ñ*Ô*¨AÑ.Ô.Ð.Ð.Ð.rA   c                óê  ‡‡— t          ¦   «         Št          ¦   «         Š‰                     ˆfd„¦  «         t          ¦   «         }|                     ˆfd„¦  «         g }|                     |j        ¦  «         t          ¦   «         }‰                     d¦  «         |                     d¦  «         |                      |g ¦  «         ‰                     |¦  «         |                      ||g¦  «         dS )zæ
        L{Deferred} chaining is transitive.

        In other words, let A, B, and C be Deferreds.  If C is returned from a
        callback on B and B is returned from a callback on A then when C fires,
        A fires.
        c                ó   •— ‰S r<   rK   r  s    €r?   rö   zGDeferredTests.test_doubleAsynchronousImplicitChaining.<locals>.<lambda>ì  r  rA   c                ó   •— ‰S r<   rK   )r  re  s    €r?   rö   zGDeferredTests.test_doubleAsynchronousImplicitChaining.<locals>.<lambda>î  s   ø€  f€ rA   N)r!   r    r`   r8   rR   ra   )rf   ÚthirdÚthirdResultrs   rg  re  s       @@r?   Ú'test_doubleAsynchronousImplicitChainingz5DeferredTests.test_doubleAsynchronousImplicitChainingâ  sð   øø€ õ #+¡*¤*ˆÝ#+¡:¤:ˆØ×ÒÐ,Ð,Ð,Ð,Ñ-Ô-Ð-Ý"*¡*¤*ˆØ×ÒÐ,Ð,Ð,Ð,Ñ-Ô-Ð-à$&ˆØ×Ò˜+Ô,Ñ-Ô-Ð-å‘”ˆà�Š˜ÑÔÐà�Š�tÑÔÐð 	×Ò˜ bÑ)Ô)Ð)ð 	�Š�vÑÔÐà×Ò˜ v hÑ/Ô/Ð/Ð/Ð/rA   c                óÞ  ‡‡‡— g Šg Št          ¦   «         Šdˆˆˆfd„}t          j        d¦  «                             |¦  «                             ‰j        ¦  «        }|                      ‰ddg¦  «         ‰                     d	¦  «         ‰                     ‰j        ¦  «         |                     ‰j        ¦  «         |                      g ‰d
¦  «         |                      ‰g d¢¦  «         dS )zÀ
        L{Deferred}s can have callbacks that themselves return L{Deferred}s.
        When these "inner" L{Deferred}s fire (even asynchronously), the
        callback chain continues.
        rs   r²   r4   rM   c                óü   •— ‰                      d| f¦  «         t          j        d¦  «        }d	ˆˆfd„}d
ˆfd„}|                     |¦  «                             |¦  «         |                     ‰j         ¦  «         |S )Nr¼  r½  rs   r²   r4   rM   c                ó2   •— ‰                      d¦  «         ‰S r¿  rÓ   rÂ  s    €€r?   rÁ  zXDeferredTests.test_nestedAsynchronousChainedDeferreds.<locals>.cb.<locals>.firstCallback  s   ø€ Ø—’Ð9Ñ:Ô:Ð:ð �rA   c                ó<   •— ‰                      d| f¦  «         | dz  S rÄ  rÓ   rÆ  s    €r?   rÅ  zYDeferredTests.test_nestedAsynchronousChainedDeferreds.<locals>.cb.<locals>.secondCallback  rÇ  rA   rÈ  rÉ  rÊ  rË  s       €€€r?   r¼   zADeferredTests.test_nestedAsynchronousChainedDeferreds.<locals>.cb  s¥   ø€ Ø�NŠN˜M¨6Ð2Ñ3Ô3Ð3Ý”˜gÑ&Ô&ˆAðð ð ð ð ð ð ð"ð "ð "ð "ð "ð "ð �MŠM˜-Ñ(Ô(×4Ò4°^ÑDÔDÐDØ�LŠL˜œÑ)Ô)Ð)ØˆHrA   rÌ  rÏ  rÀ  rÍ  ú&Got errbacks but wasn't expecting any.rÎ  NrÈ  ©r!   r   r&  r    r`   ra   rR   r_   rÑ  s      @@@r?   Ú'test_nestedAsynchronousChainedDeferredsz5DeferredTests.test_nestedAsynchronousChainedDeferreds  s+  øøø€ ð 68ˆØ"$ˆõ  (™zœzˆð	ð 	ð 	ð 	ð 	ð 	ð 	ð 	õ, ŒM˜'Ñ"Ô"×.Ò.¨rÑ2Ô2×>Ò>¸w¼~ÑNÔNð 	ð
 	×ÒØÐ.Ð0JÐKñ	
ô 	
ð 	
ð 	�Š�xÑ Ô Ð ð 	×Ò˜œÑ)Ô)Ð)Ø×Ò˜œÑ)Ô)Ð)Ø×Ò˜˜XÐ'OÑPÔPÐPà×ÒØðð ð ñ	
ô 	
ð 	
ð 	
ð 	
rA   c                óô  ‡‡‡— g Šg Št          ¦   «         Šdˆˆˆfd„}t          j        d¦  «        }|                     |¦  «         |                     ‰j        ¦  «         |                      ‰ddg¦  «         ‰                     d	¦  «         |                     ‰j        ¦  «         ‰                     ‰j        ¦  «         |                      g ‰d
¦  «         |                      ‰dddd	gfd	d	gg¦  «         dS )aK  
        L{Deferred}s can have callbacks that themselves return L{Deferred}s.
        These L{Deferred}s can have other callbacks added before they are
        returned, which subtly changes the callback chain. When these "inner"
        L{Deferred}s fire (even asynchronously), the outer callback chain
        continues.
        rs   r²   r4   úDeferred[Optional[List[str]]]c                óô   •— ‰                      d| f¦  «         t          j        d¦  «        }d
ˆˆfd„}dˆfd	„}|                     |¦  «                             |¦  «                             ‰j         ¦  «        S )Nr¼  r½  rs   r²   r4   rÖ  c                ód   •— ‰                      d| f¦  «         dd„}‰                     |¦  «        S )NrÁ  rs   r²   r4   rÝ  c                ó   — | gS r<   rK   r}  s    r?   Ú	transformz}DeferredTests.test_nestedAsynchronousChainedDeferredsWithExtraCallbacks.<locals>.cb.<locals>.firstCallback.<locals>.transformX  s	   € Ø"˜8�OrA   )rs   r²   r4   rÝ  r   )rs   r3  r½  rl  s     €€r?   rÁ  zjDeferredTests.test_nestedAsynchronousChainedDeferredsWithExtraCallbacks.<locals>.cb.<locals>.firstCallbackQ  sD   ø€ Ø—’ °Ð8Ñ9Ô9Ð9ð$ð $ð $ð $ð ×(Ò(¨Ñ3Ô3Ð3rA   rÝ  c                ó<   •— ‰                      d| f¦  «         | dz  S rÄ  rÓ   rÆ  s    €r?   rÅ  zkDeferredTests.test_nestedAsynchronousChainedDeferredsWithExtraCallbacks.<locals>.cb.<locals>.secondCallback]  rÇ  rA   )rs   r²   r4   rÖ  )rs   rÝ  r4   rÝ  rÊ  rË  s       €€€r?   r¼   zSDeferredTests.test_nestedAsynchronousChainedDeferredsWithExtraCallbacks.<locals>.cbM  sœ   ø€ Ø�NŠN˜M¨6Ð2Ñ3Ô3Ð3Ý”˜gÑ&Ô&ˆAð
4ð 
4ð 
4ð 
4ð 
4ð 
4ð 
4ð"ð "ð "ð "ð "ð "ð
 —’˜mÑ,Ô,ß’˜^Ñ,Ô,ß’˜HœOÑ,Ô,ðrA   rÌ  rÏ  rÀ  ré  r+  rÅ  N)rs   r²   r4   r/  r,  rÑ  s      @@@r?   Ú9test_nestedAsynchronousChainedDeferredsWithExtraCallbackszGDeferredTests.test_nestedAsynchronousChainedDeferredsWithExtraCallbacks>  sB  øøø€ ð  ˆØ"$ˆõ  (™zœzˆð	ð 	ð 	ð 	ð 	ð 	ð 	ð 	õ: ”˜gÑ&Ô&ˆØ×Ò˜"ÑÔÐØ×Ò˜'œ.Ñ)Ô)Ð)ð 	×ÒØÐ.Ð0JÐKñ	
ô 	
ð 	
ð 	�Š�yÑ!Ô!Ð!ð 	×Ò˜œÑ)Ô)Ð)Ø×Ò˜œÑ)Ô)Ð)Ø×Ò˜˜XÐ'OÑPÔPÐPà×ÒØà(Ø*Ø! I ;Ð/Ø˜IÐ&ð	ñ	
ô 	
ð 	
ð 	
ð 	
rA   c                óž   — t          ¦   «         }t          ¦   «         }|                     |¦  «         |                      |j        |¦  «         dS )zT
        When we chain a L{Deferred}, that chaining is recorded explicitly.
        N)r!   ÚchainDeferredrq   Ú
_chainedTo©rf   rÛ  Úbs      r?   Ú&test_chainDeferredRecordsExplicitChainz4DeferredTests.test_chainDeferredRecordsExplicitChain†  sD   € õ %™JœJˆÝ$™JœJˆØ	�Š˜ÑÔÐØ�Š�a”l AÑ&Ô&Ð&Ð&Ð&rA   c                óÆ   — t          ¦   «         }t          ¦   «         }|                     |¦  «         |                     d¦  «         |                      |j        ¦  «         dS )aR  
        Any recorded chaining is cleared once the chaining is resolved, since
        it no longer exists.

        In other words, if one L{Deferred} is recorded as depending on the
        result of another, and I{that} L{Deferred} has fired, then the
        dependency is resolved and we no longer benefit from recording it.
        N)r!   r7  rR   r¡   r8  r9  s      r?   Ú%test_explicitChainClearedWhenResolvedz3DeferredTests.test_explicitChainClearedWhenResolved�  sV   € õ %™JœJˆÝ$™JœJˆØ	�Š˜ÑÔÐØ	�
Š
�4ÑÔÐØ×Ò˜!œ,Ñ'Ô'Ð'Ð'Ð'rA   c                óÐ   ‡— t          ¦   «         }t          ¦   «         Š|                     ˆfd„¦  «         |                     d¦  «         |                      |j        ‰¦  «         dS )zÍ
        We can chain L{Deferred}s implicitly by adding callbacks that return
        L{Deferred}s. When this chaining happens, we record it explicitly as
        soon as we can find out about it.
        c                ó   •— ‰S r<   rK   )r]  r:  s    €r?   rö   zFDeferredTests.test_chainDeferredRecordsImplicitChain.<locals>.<lambda>¦  s   ø€  a€ rA   N)r!   r    rR   rq   r8  r9  s     @r?   Ú&test_chainDeferredRecordsImplicitChainz4DeferredTests.test_chainDeferredRecordsImplicitChainž  sa   ø€ õ %™JœJˆÝ$™JœJˆØ	�ŠÐ'Ð'Ð'Ð'Ñ(Ô(Ð(Ø	�
Š
�4ÑÔÐØ�Š�a”l AÑ&Ô&Ð&Ð&Ð&rA   c                óÞ  ‡— t          ¦   «         Šdˆfd„}‰                     |¦  «         ‰                     d¦  «         |                      |g¦  «        }|                      t          |¦  «        d¦  «         |d         }|                      |d	         t          ¦  «         d
}|                      t          j	        ||d         ¦  «        d 
                    ||d         ¦  «        ¦  «         dS )z„
        When a Deferred is returned from a callback directly attached to that
        same Deferred, a warning is emitted.
        rs   r²   r4   rM   c                ó   •— ‰S r<   rK   ©rs   r)  s    €r?   ÚcircularCallbackzADeferredTests.test_circularChainWarning.<locals>.circularCallback±  ó   ø€ ØˆHrA   Úfoor]   r   Úcategoryz1Callback returned the Deferred it was attached toÚmessagez
Expected match: {!r}
Got: {!r}NrÈ  )r!   r    rR   ÚflushWarningsra   rb   ÚDeprecationWarningrc   ÚreÚsearchrE  )rf   rD  Úcircular_warningsÚwarningÚpatternr)  s        @r?   Útest_circularChainWarningz'DeferredTests.test_circularChainWarningª  s  ø€ õ
 $™:œ:ˆð	ð 	ð 	ð 	ð 	ð 	ð 	
�ŠÐ&Ñ'Ô'Ð'Ø	�
Š
�5ÑÔÐà ×.Ò.Ð0@Ð/AÑBÔBÐØ×Ò�Ð.Ñ/Ô/°Ñ3Ô3Ð3Ø# AÔ&ˆØ×Ò˜ Ô,Õ.@ÑAÔAÐAØEˆØ�ŠÝŒI�g˜w yÔ1Ñ2Ô2Ø/×6Ò6°wÀÈ	Ô@RÑSÔSñ	
ô 	
ð 	
ð 	
ð 	
rA   c                óp  ‡— |                       t          t          dt          j        ¦  «         t          j        dt
          ¬¦  «         t          ¦   «         Šdˆfd„}‰                     |¦  «         ‰                     d	¦  «         |  	                    ‰¦  «        }| 
                    t
          ¦  «         d
S )z¸
        If the deprecation warning for circular deferred callbacks is
        configured to be an error, the exception will become the failure
        result of the Deferred.
        Úfiltersrr   )rG  rs   r²   r4   rM   c                ó   •— ‰S r<   rK   rC  s    €r?   rD  zCDeferredTests.test_circularChainException.<locals>.circularCallbackÐ  rE  rA   rF  NrÈ  )r‹   ÚsetattrÚwarningsrR  ÚfilterwarningsrJ  r!   r    rR   r  Útrap)rf   rD  Úfailurer)  s      @r?   Útest_circularChainExceptionz)DeferredTests.test_circularChainExceptionÁ  s½   ø€ ð 	�ŠÝÝØÝÔñ		
ô 	
ð 	
õ 	Ô Õ2DÐEÑEÔEÐEÝ#™:œ:ˆð	ð 	ð 	ð 	ð 	ð 	ð 	
�ŠÐ&Ñ'Ô'Ð'Ø	�
Š
�5ÑÔÐØ×&Ò& qÑ)Ô)ˆØ�ŠÕ'Ñ(Ô(Ð(Ð(Ð(rA   c                ó�   — t          ¦   «         }t          |¦  «        }|                      t          |¦  «        d|d›d�¦  «         dS )z€
        The C{repr()} of a L{Deferred} contains the class name and a
        representation of the internal Python ID.
        ú<Deferred at 0xr‚  ú>N)r!   Úidra   Úrepr)rf   r)  Úaddresss      r?   Ú	test_reprzDeferredTests.test_reprØ  sI   € õ
 %™JœJˆÝ�Q‘%”%ˆØ×Ò�˜a™œÐ"@°GÐ"@Ð"@Ð"@Ð"@ÑAÔAÐAÐAÐArA   c                ó¶   — t          ¦   «         }|                     d¦  «         |                      t          |¦  «        dt	          |¦  «        d›d�¦  «         dS )zb
        If a L{Deferred} has been fired, then its C{repr()} contains its
        result.
        rÍ  r[  r‚  z current result: 'orange'>N)r!   rR   ra   r^  r]  r>  s     r?   Útest_reprWithResultz!DeferredTests.test_reprWithResultá  sV   € õ
 $™:œ:ˆØ	�
Š
�8ÑÔÐØ×Ò�˜a™œÐ"WµB°q±E´EÐ"WÐ"WÐ"WÐ"WÑXÔXÐXÐXÐXrA   c           	     óô   — t          ¦   «         }t          ¦   «         }|                     |¦  «         |                      t          |¦  «        dt	          |¦  «        d›dt	          |¦  «        d›d�¦  «         dS )zÇ
        If a L{Deferred} C{a} has been fired, but is waiting on another
        L{Deferred} C{b} that appears in its callback chain, then C{repr(a)}
        says that it is waiting on C{b}.
        r[  r‚  z waiting on Deferred at 0xr\  N)r!   r7  ra   r^  r]  r9  s      r?   Útest_reprWithChainingz#DeferredTests.test_reprWithChainingê  s{   € õ %™JœJˆÝ$™JœJˆØ	�Š˜ÑÔÐØ×ÒÝ�‰GŒGØK�b ™eœeÐKÐKÐKÅÀAÁÄÐKÐKÐKÐKñ	
ô 	
ð 	
ð 	
ð 	
rA   c                ód   ‡ — dˆ fd„}‰                        |d¦  «         |d¦  «        ¦  «         dS )	zw
        The depth of the call stack does not grow as more L{Deferred} instances
        are chained together.
        ÚhowManyr;  r4   c                ó|  •‡	‡
— g Š
dˆ
fd„}t          ¦   «         }d„ t          | ¦  «        D ¦   «         }|d d …         }t          ¦   «         Š	|                     ¦   «         }|fdd	„}|                     |¦  «         |                     |¦  «         |r3|                     ¦   «         }|fdd
„}|                     |¦  «         |}|°3|                     ˆ	fd„¦  «         |                     d ¦  «         |D ]}|                     d ¦  «         Œ‰                     ‰
g ¦  «         ‰	                     d ¦  «         ‰
d         S )Nr]  r8   r4   rN   c                ón   •— ‰                      t          t          j        ¦   «         ¦  «        ¦  «         d S r<   )r`   rb   Ú	tracebackÚextract_stack)r]  Ústacks    €r?   ÚrecordStackDepthzVDeferredTests.test_boundedStackDepth.<locals>.chainDeferreds.<locals>.recordStackDepth  s,   ø€ Ø—’�S¥Ô!8Ñ!:Ô!:Ñ;Ô;Ñ<Ô<Ð<Ð<Ð<rA   c                ó*   — g | ]}t          ¦   «         ‘ŒS rK   ©r!   )Ú.0r]  s     r?   ú
<listcomp>zPDeferredTests.test_boundedStackDepth.<locals>.chainDeferreds.<locals>.<listcomp>  s)   € ð 4ð 4ð 4Ø&•‘
”
ð4ð 4ð 4rA   r½  rÔ  c                ó   — |S r<   rK   ©r]  r½  s     r?   ÚcbInnerzMDeferredTests.test_boundedStackDepth.<locals>.chainDeferreds.<locals>.cbInner  s	   € ð �rA   c                ó   — |S r<   rK   rr  s     r?   Ú
cbNewInnerzPDeferredTests.test_boundedStackDepth.<locals>.chainDeferreds.<locals>.cbNewInner  s	   € ð !�LrA   c                ó   •— ‰S r<   rK   )r  Úlasts    €r?   rö   zNDeferredTests.test_boundedStackDepth.<locals>.chainDeferreds.<locals>.<lambda>   s   ø€ ¨$€ rA   r   ©r]  r8   r4   rN   )r]  r8   r½  rÔ  r4   rÔ  )r!   ÚrangeÚpopr    rR   ra   )rf  rl  ÚtopÚinnerDeferredsÚoriginalInnersr½  rs  ÚnewInnerru  rw  rk  rf   s            @@€r?   ÚchainDeferredsz<DeferredTests.test_boundedStackDepth.<locals>.chainDeferredsþ  s®  øøø€ ØˆEð=ð =ð =ð =ð =ð =õ #+¡*¤*ˆCð4ð 4Ý*/°©.¬.ð4ñ 4ô 4ˆNð ,¨A¨A¨AÔ.ˆNÝ#+¡:¤:ˆDà"×&Ò&Ñ(Ô(ˆEð :?ðð ð ð ð ð
 �OŠO˜GÑ$Ô$Ð$Ø�OŠOÐ,Ñ-Ô-Ð-à ð 	!Ø)×-Ò-Ñ/Ô/�ð >Fð!ð !ð !ð !ð !ð
 ×!Ò! *Ñ-Ô-Ð-Ø �ð !ð 	!ð ×ÒÐ.Ð.Ð.Ð.Ñ/Ô/Ð/à�LŠL˜ÑÔÐØ'ð %ð %�Ø—’˜tÑ$Ô$Ð$Ð$ð ×Ò˜U BÑ'Ô'Ð'ð �MŠM˜$ÑÔÐØ˜”8ˆOrA   r]   rÅ   N)rf  r;  r4   r;  )ra   )rf   r  s   ` r?   Útest_boundedStackDepthz$DeferredTests.test_boundedStackDepthø  sT   ø€ ð/	ð /	ð /	ð /	ð /	ð /	ðf 	×Ò˜˜¨Ñ*Ô*¨N¨N¸1Ñ,=Ô,=Ñ>Ô>Ð>Ð>Ð>rA   c                ó¢  ‡‡— t          ¦   «         }t          ¦   «         Št          ¦   «         Š|                     ˆfd„¦  «         ‰                     ˆfd„¦  «         ‰                     d¦  «         |                     d¦  «         ‰                     d¦  «         g }‰                     |j        ¦  «         |                      |dg¦  «         dS )a  
        Given three Deferreds, one chained to the next chained to the next,
        callbacks on the middle Deferred which are added after the chain is
        created are called once the last Deferred fires.

        This is more of a regression-style test.  It doesn't exercise any
        particular code path through the current implementation of Deferred, but
        it does exercise a broken codepath through one of the variations of the
        implementation proposed as a resolution to ticket #411.
        c                ó   •— ‰S r<   rK   rd  s    €r?   rö   zZDeferredTests.test_resultOfDeferredResultOfDeferredOfFiredDeferredCalled.<locals>.<lambda>A  rf  rA   c                ó   •— ‰S r<   rK   )r]  r$  s    €r?   rö   zZDeferredTests.test_resultOfDeferredResultOfDeferredOfFiredDeferredCalled.<locals>.<lambda>B  s   ø€ ¨5€ rA   N)r!   r    rR   r`   ra   )rf   rg  rl  re  r$  s      @@r?   Ú:test_resultOfDeferredResultOfDeferredOfFiredDeferredCalledzHDeferredTests.test_resultOfDeferredResultOfDeferredOfFiredDeferredCalled3  sÌ   øø€ õ !)¡
¤
ˆÝ!)¡¤ˆÝ (¡
¤
ˆØ×ÒÐ0Ð0Ð0Ð0Ñ1Ô1Ð1Ø×ÒÐ0Ð0Ð0Ð0Ñ1Ô1Ð1Ø�Š˜ÑÔÐØ�Š�tÑÔÐØ�Š�tÑÔÐØ ˆØ×Ò˜7œ>Ñ*Ô*Ð*Ø×Ò˜ 4 &Ñ)Ô)Ð)Ð)Ð)rA   c                ó¼  — t          j        d¦  «         t          ¦   «         }g }t          d¦  «        }	 |‚# t          $ r |                     ¦   «          Y nw xY w|                     |j        ¦  «         |d         }|                      |j	        |¦  «         |j
        d         dd…         \  }}|                      d|¦  «         |                      d|¦  «         dS )z¿
        C{Deferred.errback()} creates a failure from the current Python
        exception.  When Deferred.debug is not set no globals or locals are
        captured in that failure.
        Frç   r   éþÿÿÿNrK   )r   rŒ   r!   rF   ÚBaseExceptionr®   r_   r`   ra   re   Úframes©rf   r)  r(  Úexcr-  ÚlocalzÚglobalzs          r?   Útest_errbackWithNoArgsNoDebugz+DeferredTests.test_errbackWithNoArgsNoDebugJ  så   € õ 	Ô˜5Ñ!Ô!Ð!Ý$™JœJˆØˆÝ˜6Ñ"Ô"ˆð	ØˆIøÝð 	ð 	ð 	Ø�IŠI‰KŒKˆKˆKˆKð	øøøà	�Š�Q”XÑÔÐØ�ŒtˆØ×Ò˜œ SÑ)Ô)Ð)Øœ+ aœ.¨¨¨Ô-‰ˆ�Ø×Ò˜˜VÑ$Ô$Ð$Ø×Ò˜˜WÑ%Ô%Ð%Ð%Ð%ó   µ7 ·AÁAc                ó¼  — t          j        d¦  «         t          ¦   «         }g }t          d¦  «        }	 |‚# t          $ r |                     ¦   «          Y nw xY w|                     |j        ¦  «         |d         }|                      |j	        |¦  «         |j
        d         dd…         \  }}|                      g |¦  «         |                      g |¦  «         dS )z¹
        C{Deferred.errback()} creates a failure from the current Python
        exception.  When Deferred.debug is set globals and locals are captured
        in that failure.
        Trç   r   r†  N)r   rŒ   r!   rF   r‡  r®   r_   r`   ra   re   rˆ  ÚassertNotEqualr‰  s          r?   Útest_errbackWithNoArgsz$DeferredTests.test_errbackWithNoArgs_  så   € õ 	Ô˜4Ñ Ô Ð Ý$™JœJˆØˆÝ˜6Ñ"Ô"ˆð	ØˆIøÝð 	ð 	ð 	Ø�IŠI‰KŒKˆKˆKˆKð	øøøà	�Š�Q”XÑÔÐØ�ŒtˆØ×Ò˜œ SÑ)Ô)Ð)Øœ+ aœ.¨¨¨Ô-‰ˆ�Ø×Ò˜B Ñ'Ô'Ð'Ø×Ò˜B Ñ(Ô(Ð(Ð(Ð(rŽ  c                óv  — t          ¦   «         }|                     d¦  «         t          j        d¦  «         dd„}|                     |¦  «         g }|                     |j        ¦  «         |d         }|j        d         d	d…         \  }}|                      d
|¦  «         |                      d
|¦  «         dS )úœ
        An error raised by a callback creates a Failure.  The Failure captures
        locals and globals if and only if C{Deferred.debug} is set.
        NFr]  r8   r4   rN   c                ó    — t          d¦  «        ‚©Nrç   ©rF   ©r]  s    r?   Ú
raiseErrorzHDeferredTests.test_errorInCallbackDoesNotCaptureVars.<locals>.raiseError}  ó   € Ý˜vÑ&Ô&Ð&rA   r   r†  rK   rx  )	r!   rR   r   rŒ   r    r_   r`   rˆ  ra   ©rf   r)  r˜  r(  r-  r‹  rŒ  s          r?   Ú&test_errorInCallbackDoesNotCaptureVarsz4DeferredTests.test_errorInCallbackDoesNotCaptureVarst  sÄ   € õ
 %™JœJˆØ	�
Š
�4ÑÔÐÝÔ˜5Ñ!Ô!Ð!ð	'ð 	'ð 	'ð 	'ð 	
�Š�jÑ!Ô!Ð!ØˆØ	�Š�Q”XÑÔÐØ�ŒtˆØœ+ aœ.¨¨¨Ô-‰ˆ�Ø×Ò˜˜VÑ$Ô$Ð$Ø×Ò˜˜WÑ%Ô%Ð%Ð%Ð%rA   c                óv  — t          ¦   «         }|                     d¦  «         t          j        d¦  «         d
d„}|                     |¦  «         g }|                     |j        ¦  «         |d         }|j        d         d	d…         \  }}|                      g |¦  «         |                      g |¦  «         dS )r“  NTr]  r8   r4   rN   c                ó    — t          d¦  «        ‚r•  r–  r—  s    r?   r˜  zODeferredTests.test_errorInCallbackCapturesVarsWhenDebugging.<locals>.raiseError‘  r™  rA   r   r†  rx  )	r!   rR   r   rŒ   r    r_   r`   rˆ  r�  rš  s          r?   Ú-test_errorInCallbackCapturesVarsWhenDebuggingz;DeferredTests.test_errorInCallbackCapturesVarsWhenDebuggingˆ  sÄ   € õ
 %™JœJˆØ	�
Š
�4ÑÔÐÝÔ˜4Ñ Ô Ð ð	'ð 	'ð 	'ð 	'ð 	
�Š�jÑ!Ô!Ð!ØˆØ	�Š�Q”XÑÔÐØ�ŒtˆØœ+ aœ.¨¨¨Ô-‰ˆ�Ø×Ò˜B Ñ'Ô'Ð'Ø×Ò˜B Ñ(Ô(Ð(Ð(Ð(rA   c                óØ   — dd„}t          j         |¦   «         ¦  «        }t          |t           t                   ¦  «         |                      d|                      |¦  «        ¦  «         dS )zM
        It can discover the return type of a first level coroutine.
        r4   r;  c               “  ó
   K  — dS rK  rK   rK   rA   r?   Ú
returnsIntz4DeferredTests.test_fromCoroutine.<locals>.returnsInt¡  r   rA   r]   Nr¡  )r!   r=   r   r;  ra   r  )rf   r¡  r)  s      r?   Útest_fromCoroutinez DeferredTests.test_fromCoroutineœ  sl   € ð
	ð 	ð 	ð 	õ Ô" : :¡<¤<Ñ0Ô0ˆÝ�A•x¥”}Ñ%Ô%Ð%Ø×Ò˜˜D×0Ò0°Ñ3Ô3Ñ4Ô4Ð4Ð4Ð4rA   c                óŒ   — d„ dd| j         dt          g}|D ]-}|                      t          j        t          j        |¦  «         Œ.dS )ú‰
        L{Deferred.fromCoroutine} requires a coroutine object or a generator,
        and will reject things that are not that.
        c                ó   — | S r<   rK   r…  s    r?   rö   zCDeferredTests.test_fromCoroutineRequiresCoroutine.<locals>.<lambda>¯  ó   € �a€ rA   r]   TN©Ú#test_fromCoroutineRequiresCoroutiner   ÚassertRaisesÚNotACoroutineErrorr!   r=   ©rf   ÚthingsThatAreNotCoroutinesÚthings      r?   r¨  z1DeferredTests.test_fromCoroutineRequiresCoroutine¨  ód   € ð ˆKàààÔ4àåð&
Ð"ð 0ð 	Wð 	WˆEØ×Ò�eÔ6½Ô8NÐPUÑVÔVÐVÐVð	Wð 	WrA   úGC works differently on PyPy.c                ó@  — t          ¦   «         }t          j        |¦  «        }t          |¦  «        }||_        t          j        |¦  «        }|                     d¦  «         ~~|                       |¦   «         ¦  «         |                       |¦   «         ¦  «         dS )z|
        A circular reference between a `Deferred` and its canceller
        is broken when the deferred is called.
        N)ÚDummyCancellerÚweakrefÚrefr!   rL   rR   r¡   )rf   Ú	cancellerÚweakCancellerrL   ÚweakDeferreds        r?   Ú*test_canceller_circular_reference_callbackz8DeferredTests.test_canceller_circular_reference_callback¿  sœ   € õ #Ñ$Ô$ˆ	Ýœ IÑ.Ô.ˆõ #+¨9Ñ"5Ô"5ˆØ%ˆ	ÔÝ”{ 8Ñ,Ô,ˆà×Ò˜$ÑÔÐð Øð 	×Ò˜-˜-™/œ/Ñ*Ô*Ð*Ø×Ò˜,˜,™.œ.Ñ)Ô)Ð)Ð)Ð)rA   c                ó¢  — t          ¦   «         }t          j        |¦  «        }t          |¦  «        }||_        t          j        |¦  «        }t          t          d¦  «        ¦  «        }|                     |¦  «         |                      |¦  «         ~~|  	                     |¦   «         ¦  «         |  	                     |¦   «         ¦  «         dS )zx
        A circular reference between a `Deferred` and its canceller
        is broken when the deferred fails.
        úThe test demands failures.N)
r±  r²  r³  r!   rL   r0   r¸  r®   r  r¡   )rf   r´  rµ  rL   r¶  rX  s         r?   Ú)test_canceller_circular_reference_errbackz7DeferredTests.test_canceller_circular_reference_errbackÜ  sÆ   € õ #Ñ$Ô$ˆ	Ýœ IÑ.Ô.ˆõ #+¨9Ñ"5Ô"5ˆØ%ˆ	ÔÝ”{ 8Ñ,Ô,ˆå�)Ð$@ÑAÔAÑBÔBˆØ×Ò˜Ñ!Ô!Ð!ð 	×Ò˜XÑ&Ô&Ð&àØð 	×Ò˜-˜-™/œ/Ñ*Ô*Ð*Ø×Ò˜,˜,™.œ.Ñ)Ô)Ð)Ð)Ð)rA   c                ó
  — t          ¦   «         }t          j        |¦  «        }t          |¦  «        }||_        |                     d„ ¦  «         |                     d¦  «         ~~|                       |¦   «         ¦  «         dS )z¶
        A circular reference between a `Deferred` and its canceller is broken
        when the deferred is called, even if another deferred gets added to its
        chain.
        c                ó   — t          ¦   «         S r<   rn  r6  s    r?   rö   zKDeferredTests.test_canceller_circular_reference_non_final.<locals>.<lambda>  s
   € ¥x¡z¤z€ rA   N)r±  r²  r³  r!   rL   r    rR   r¡   )rf   r´  rµ  rL   s       r?   Ú+test_canceller_circular_reference_non_finalz9DeferredTests.test_canceller_circular_reference_non_finalü  s‰   € õ #Ñ$Ô$ˆ	Ýœ IÑ.Ô.ˆõ #+¨9Ñ"5Ô"5ˆØ%ˆ	Ôà×ÒÐ1Ð1Ñ2Ô2Ð2Ø×Ò˜$ÑÔÐàØð 	×Ò˜-˜-™/œ/Ñ*Ô*Ð*Ð*Ð*rA   c                ó¢  — |                       t          j        dd…         t          t          g¦  «          G d„ dt          t
                   ¦  «        }|                       t          j        d         |¦  «         t          j                             d¦  «         t          j        D ]*}|                      t          |t          ¦  «        ¦  «         Œ+dS )zQ
        C{_DEFERRED_SUBCLASSES} includes all subclasses of L{Deferred}.
        NrÅ   c                  ó   — e Zd ZdS )ú2DeferredTests.test_DEFERRED_SUBCLASSES.<locals>.D2NrG   rK   rA   r?   ÚD2rÀ    r´  rA   rÁ  éÿÿÿÿ)	ra   r   Ú_DEFERRED_SUBCLASSESr!   r#   r;  rz  rc   rÞ   )rf   rÁ  Úklasss      r?   Útest_DEFERRED_SUBCLASSESz&DeferredTests.test_DEFERRED_SUBCLASSES  sÍ   € ð 	×Ò�Ô3°B°Q°BÔ7½(ÅLÐ9QÑRÔRÐRð	ð 	ð 	ð 	ð 	•�#”ñ 	ô 	ð 	ð 	×Ò�Ô3°BÔ7¸Ñ<Ô<Ð<ÝÔ"×&Ò& rÑ*Ô*Ð*õ Ô/ð 	9ð 	9ˆEØ�OŠO�J u­hÑ7Ô7Ñ8Ô8Ð8Ð8ð	9ð 	9rA   Nr„   )r7   r8   r9   r8   r4   r   ©r7   r8   r9   r8   r4   rN   )r7   r0   r9   r8   r4   rN   )ZrH   rI   rJ   r�   r”   r—   rš   r£   r¦   r¨   rª   r°   r³   rµ   rÎ   rØ   rå   rí   rñ   rú   rý   r  r  r  r  r  r  r  r  r!  r#  r*  r.  r2  r<  r?  rG  rQ  rZ  ra  rh  rm  rt  rw  rz  r€  r‰  rŽ  r“  r˜  r›  r£  r¯  r¹  rÒ  rë  ró  r  r  r  r  r  r  r   r&  r-  r5  r;  r=  r@  rP  rY  r`  rb  rd  r€  r„  r�  r‘  r›  rž  r¢  r¨  ÚpyunitÚskipIfr.   r·  rº  r½  rÅ  rK   rA   r?   r†   r†   ¦   sD  € € € € € ðBð Bð Bð Bðð ð ð ð-ð -ð -ð -ð+ð +ð +ð +ðAð Að Að AðIð Ið Ið IðQð Qð Qð QðBð Bð Bð Bð5ð 5ð 5ð 5ðAð Að Að Að"5ð 5ð 5ð 5ð,"
ð "
ð "
ð "
ðH%ð %ð %ð %ð('.ð '.ð '.ð '.ðR?ð ?ð ?ð ?ð"?ð ?ð ?ð ?ð"&ð &ð &ð &ð&ð &ð &ð &ð"
@ð 
@ð 
@ð 
@ðBð Bð Bð Bð$
@ð 
@ð 
@ð 
@ð9ð 9ð 9ð 9ðKð Kð Kð Kð:ð :ð :ð :ð"+ð +ð +ð +ð )ð )ð )ð )ð.)ð )ð )ð )ð=ð =ð =ð =ð)ð )ð )ð )ð2ð 2ð 2ð 2ð2ð 2ð 2ð 2ð
=ð 
=ð 
=ð 
=ðð ð ð ð
ð 
ð 
ð 
ð6
ð 
ð 
ð 
ð<3ð 3ð 3ð 3ð,-ð -ð -ð -ð()ð )ð )ð )ð &ð &ð &ð &ð >ð >ð >ð >ð(Kð Kð Kð Kð?ð ?ð ?ð ?ð1ð 1ð 1ð 1ð(ð (ð (ð (ð >ð >ð >ð >ð"2ð 2ð 2ð 2ð$
.ð 
.ð 
.ð 
.ð	6ð 	6ð 	6ð 	6ðEð Eð Eð EðDð Dð Dð Dð2
ð 
ð 
ð 
ð.*
ð *
ð *
ð *
ðX%
ð %
ð %
ð %
ðN-
ð -
ð -
ð -
ð^,ð ,ð ,ð ,ð.)ð )ð )ð )ð(>ð >ð >ð >ð(*ð *ð *ð *ð&1ð 1ð 1ð 1ð4:ð :ð :ð :ð(/ð /ð /ð /ð:0ð 0ð 0ð 0ð>;
ð ;
ð ;
ð ;
ðzF
ð F
ð F
ð F
ðP'ð 'ð 'ð 'ð(ð (ð (ð (ð
'ð 
'ð 
'ð 
'ð
ð 
ð 
ð 
ð.)ð )ð )ð )ð.Bð Bð Bð BðYð Yð Yð Yð
ð 
ð 
ð 
ð9?ð 9?ð 9?ð 9?ðv*ð *ð *ð *ð.&ð &ð &ð &ð*)ð )ð )ð )ð*&ð &ð &ð &ð()ð )ð )ð )ð(
5ð 
5ð 
5ð 
5ðWð Wð Wð Wð. €V„]�5Ð9Ñ:Ô:ð*ð *ð *ñ ;Ô:ð*ð8 €V„]�5Ð9Ñ:Ô:ð*ð *ð *ñ ;Ô:ð*ð> €V„]�5Ð9Ñ:Ô:ð+ð +ð +ñ ;Ô:ð+ð49ð 9ð 9ð 9ð 9ð 9rA   r†   c                  ó*   — e Zd ZU dZdZded<   d	d„ZdS )
r±  z†
    A callable that does nothing.
    It is intended to be used just to get an object reference
    to support GC related tests.
    NzOptional[Deferred[Any]]rL   rY   r4   rN   c                ó   — dS )zV
        This is not expected to be called as part of the current test suite.
        NrK   r¢   s     r?   Ú__call__zDummyCanceller.__call__2  s   € € € rA   )rL   rY   r4   rN   )rH   rI   rJ   rj   rL   Ú__annotations__rË  rK   rA   r?   r±  r±  )  sG   € € € € € € ðð ð )-€HÐ,Ð,Ð,Ñ,ðð ð ð ð ð rA   r±  ÚnumDeferredsr;  ú(tuple[list[int], list[Deferred[object]]]c                ó–   ‡— dg| z  Šg }t          | ¦  «        D ]-}|fd
ˆfd„}|                     t          |¬	¦  «        ¦  «         Œ.‰|fS )zÄ
    Create a list of Deferreds and a corresponding list of integers
    tracking how many times each Deferred has been cancelled.  Without
    additional steps the Deferreds will never fire.
    r   r)  r  Únr;  r4   rN   c                ó(   •— ‰|xx         dz  cc<   d S rK  rK   )r)  rÐ  ÚcancelledStates     €r?   r   z_setupRaceState.<locals>.cancelC  s%   ø€ Ø˜1ÐÐÔ Ñ"ÐÐÑÐÐrA   ©r´  )r)  r  rÐ  r;  r4   rN   )ry  r`   r!   )rÍ  ÚdsrÐ  r   rÒ  s       @r?   Ú_setupRaceStaterÕ  8  s€   ø€ ð �S˜<Ñ'€Nà!#€BÝ�<Ñ Ô ð .ð .ˆà12ð 	#ð 	#ð 	#ð 	#ð 	#ð 	#ð 	#ð 	�	Š	•( VÐ,Ñ,Ô,Ñ-Ô-Ð-Ð-à˜2ÐÐrA   c                  ój  — e Zd ZdZ e edd¬¦  «         edd¬¦  «        ¬¦  «        dd„¦   «         Z e edd¬¦  «         edd¬¦  «        ¬¦  «        dd„¦   «         Z e edd¬¦  «         edd¬¦  «        ¬¦  «        dd„¦   «         Zdd„Z	 e edd¬¦  «        ¬¦  «        dd„¦   «         Z
dS )Ú	RaceTestsz
    Tests for L{race}.
    r   r÷  )Ú	min_valueÚ	max_value)ÚbeforeWinnerÚafterWinnerrÚ  r;  rÛ  r4   rN   c                óf  — t          |dz   |z   ¦  «        \  }}t          |¦  «        }t          ¦   «         }||                              |¦  «         t	          |                      |¦  «        t          ||f¦  «        ¦  «         dg|z  dgz   dg|z  z   }t	          |t          |¦  «        ¦  «         dS )a	  
        When one of the L{Deferred}s passed to L{race} fires successfully,
        the L{Deferred} return by L{race} fires with the index of that
        L{Deferred} and its result and cancels the rest of the L{Deferred}s.

        @param beforeWinner: A randomly selected number of Deferreds to
            appear before the "winning" Deferred in the list passed in.

        @param beforeWinner: A randomly selected number of Deferreds to
            appear after the "winning" Deferred in the list passed in.
        r]   r   N)rÕ  r+   r8   rR   r   r  r   )rf   rÚ  rÛ  rÒ  rÔ  Ú
raceResultr_  ÚexpectedCancelledStates           r?   Útest_successzRaceTests.test_successP  sÏ   € õ  -¨\¸AÑ-=ÀÑ-KÑLÔLÑˆ˜å˜"‘X”Xˆ
Ý‘8”8ˆØ
ˆ<Ô×!Ò! (Ñ+Ô+Ð+õ 	Ø× Ò  Ñ,Ô,Ý�l HÐ-Ñ.Ô.ñ	
ô 	
ð 	
ð
 #$  |Ñ!3°q°cÑ!9¸Q¸CÀ+Ñ<MÑ!MÐÝØÝÐ+Ñ,Ô,ñ	
ô 	
ð 	
ð 	
ð 	
rA   c           	     óÂ  — t          |dz   |z   ¦  «        \  }}t          t          d¦  «        ¦  «        }t          |¦  «        }|D ]}|                     |¦  «         Œ|                      |t          ¦  «        }t          |j        j	        t          |gt          |¦  «        z  ¦  «        ¦  «         t          |t          dgt          |¦  «        z  ¦  «        ¦  «         dS )aâ  
        When all of the L{Deferred}s passed to L{race} fire with failures,
        the L{Deferred} return by L{race} fires with L{FailureGroup} wrapping
        all of their failures.

        @param beforeWinner: A randomly selected number of Deferreds to
            appear before the "winning" Deferred in the list passed in.

        @param beforeWinner: A randomly selected number of Deferreds to
            appear after the "winning" Deferred in the list passed in.
        r]   r¹  r   N)rÕ  r0   r¸  r+   r®   r  r'   r   re   rh   r   rb   )	rf   rÚ  rÛ  rÒ  rÔ  rX  rÝ  r)  ÚactualFailures	            r?   Útest_failurezRaceTests.test_failures  så   € õ  -¨\¸AÑ-=ÀÑ-KÑLÔLÑˆ˜å�)Ð$@ÑAÔAÑBÔBˆÝ˜"‘X”Xˆ
Øð 	ð 	ˆAØ�IŠI�gÑÔÐÐà×,Ò,¨Z½ÑFÔFˆÝØÔÔ(Ý�g�Y¥ R¡¤Ñ(Ñ)Ô)ñ	
ô 	
ð 	
õ 	ØÝ�a�S�3˜r™7œ7‘]Ñ#Ô#ñ	
ô 	
ð 	
ð 	
ð 	
rA   c                óZ  — d„ t          |dz   |z   ¦  «        D ¦   «         }t          |¦  «        }||                              d¦  «         ||dz                                 d¦  «         |                      |¦  «         t	          |                      ¦   «         t          ¦   «         ¦  «         dS )zª
        If one of the Deferreds fires after it was cancelled its result
        goes nowhere.  In particular, it does not cause any errors to be
        logged.
        c                ó*   — g | ]}t          ¦   «         ‘ŒS rK   rn  )ro  rÐ  s     r?   rp  z4RaceTests.test_resultAfterCancel.<locals>.<listcomp>   s)   € ð $
ð $
ð $
Ø�H‰JŒJð$
ð $
ð $
rA   rÅ   Nr]   )ry  r+   rR   r  r   rp   r   )rf   rÚ  rÛ  rÔ  rÝ  s        r?   Útest_resultAfterCancelz RaceTests.test_resultAfterCancel”  s°   € ð$
ð $
Ý % l°QÑ&6¸Ñ&DÑ EÔ Eð$
ñ $
ô $
ˆõ ˜"‘X”Xˆ
Ø
ˆ<Ô×!Ò! $Ñ'Ô'Ð'Ø
ˆ<˜!ÑÔ×%Ò% dÑ+Ô+Ð+à×Ò˜ZÑ(Ô(Ð(Ý�D×*Ò*Ñ,Ô,­e©g¬gÑ6Ô6Ð6Ð6Ð6rA   c                ó  — t          ¦   «         }|t          d„ ¬¦  «        g}t          ¦   «         }t          |¦  «        }|                     |¦  «         t	          |                      |¦  «        t          d|f¦  «        ¦  «         dS )z~
        If one of the input Deferreds has a cancel function that fires it
        with success, nothing bad happens.
        c                óD   — |                       t          ¦   «         ¦  «        S r<   )rR   r8   ©r)  s    r?   rö   z1RaceTests.test_resultFromCancel.<locals>.<lambda>³  s   € ¨¯ªµF±H´HÑ)=Ô)=€ rA   rÓ  r   N)r!   r8   r+   rR   r   r  r   )rf   ÚwinnerrÔ  r_  rÝ  s        r?   Útest_resultFromCancelzRaceTests.test_resultFromCancel«  s�   € õ
 $,¡:¤:ˆàÝÐ=Ð=Ð>Ñ>Ô>ð&
ˆõ ‘8”8ˆÝ˜"‘X”Xˆ
Ø�Š˜Ñ!Ô!Ð!å�D×(Ò(¨Ñ4Ô4µhÀÀ8¸}Ñ6MÔ6MÑNÔNÐNÐNÐNrA   r]   )rÍ  rÍ  c                óè   — t          |¦  «        \  }}t          |¦  «        }|                     ¦   «          t          |t	          dg|z  ¦  «        ¦  «         |                      |t          ¦  «         dS )zu
        If the result of L{race} is cancelled then all of the L{Deferred}s
        passed in are cancelled.
        r]   N)rÕ  r+   r   r   r   r  r'   )rf   rÍ  rÒ  rÔ  rÝ  s        r?   Útest_cancelzRaceTests.test_cancel»  sn   € õ -¨\Ñ:Ô:Ñˆ˜å˜"‘X”Xˆ
Ø×ÒÑÔÐå�N¥H¨a¨S°<Ñ-?Ñ$@Ô$@ÑAÔAÐAØ×Ò˜Z­Ñ6Ô6Ð6Ð6Ð6rA   N)rÚ  r;  rÛ  r;  r4   rN   r„   )rÍ  r;  r4   rN   )rH   rI   rJ   rj   r   r   rß  râ  rå  rê  rì  rK   rA   r?   r×  r×  K  s„  € € € € € ðð ð €UØ�X¨°QÐ7Ñ7Ô7Ø�H q°AÐ6Ñ6Ô6ðñ ô ð
ð 
ð 
ñ	ô ð
ð> €UØ�X¨°QÐ7Ñ7Ô7Ø�H q°AÐ6Ñ6Ô6ðñ ô ð
ð 
ð 
ñ	ô ð
ð: €UØ�X¨°QÐ7Ñ7Ô7Ø�H q°AÐ6Ñ6Ô6ðñ ô ð7ð 7ð 7ñ	ô ð7ð&Oð Oð Oð Oð  €UØ�X¨°QÐ7Ñ7Ô7ðñ ô ð7ð 7ð 7ñô ð7ð 7ð 7rA   r×  c                  ó*   — e Zd ZdZdd„Zdd„Zdd„ZdS )	ÚFirstErrorTestsz"
    Tests for L{FirstError}.
    r4   rN   c                óø   — t          d¦  «        }	 |‚# t          $ r t          ¦   «         }Y nw xY wt          j        |d¦  «        }|                      t          |¦  «        dt          |¦  «        › d�¦  «         dS )z¦
        The repr of a L{FirstError} instance includes the repr of the value of
        the sub-failure and the index which corresponds to the L{FirstError}.
        ú	some textr÷  zFirstError[#3, ú]N)rY  r‡  r0   r   rà   ra   r^  ©rf   rŠ  r2   rr   s       r?   r`  zFirstErrorTests.test_reprÑ  s‹   € õ
 ˜Ñ%Ô%ˆð	ØˆIøÝð 	ð 	ð 	Ý‘	”	ˆAˆAˆAð	øøøõ Ô   AÑ&Ô&ˆØ×Ò�˜e™œÐ&D½¸S¹	¼	Ð&DÐ&DÐ&DÑEÔEÐEÐEÐEó   ‘ “.­.c                óø   — t          d¦  «        }	 |‚# t          $ r t          ¦   «         }Y nw xY wt          j        |d¦  «        }|                      t          |¦  «        dt          |¦  «        › d�¦  «         dS )z—
        The str of a L{FirstError} instance includes the str of the
        sub-failure and the index which corresponds to the L{FirstError}.
        rð  r„  zFirstError[#5, rñ  N)rY  r‡  r0   r   rà   ra   r²   rò  s       r?   Útest_strzFirstErrorTests.test_strß  s‹   € õ
 ˜Ñ%Ô%ˆð	ØˆIøÝð 	ð 	ð 	Ý‘	”	ˆAˆAˆAð	øøøõ Ô   AÑ&Ô&ˆØ×Ò�˜U™œÐ%@µs¸1±v´vÐ%@Ð%@Ð%@ÑAÔAÐAÐAÐAró  c                ó$  — 	 ddz   n# t           $ r t          ¦   «         }Y nw xY wt          j        |d¦  «        }t          j        |d¦  «        }	 t	          d¦  «        ‚# t           $ r t          ¦   «         }Y nw xY wt          j        |d¦  «        }|                      ||k    ¦  «         |                      ||k    ¦  «         |                      ||k    ¦  «         |                      ||k    ¦  «         |                      |dk    ¦  «         dS )zÖ
        L{FirstError} instances compare equal to each other if and only if
        their failure and index compare equal.  L{FirstError} instances do not
        compare equal to instances of other types.
        r]   r   é   Úbaré	   r‡  N)r‡  r0   r   rà   rY  rc   r	  )rf   ÚfirstFailureÚoneÚ
anotherOneÚsecondFailureÚanothers         r?   Útest_comparisonzFirstErrorTests.test_comparisoní  s+  € ð	%Ø�‰FˆFˆFøÝð 	%ð 	%ð 	%Ý"™9œ9ˆLˆLˆLð	%øøøõ Ô˜|¨RÑ0Ô0ˆÝÔ% l°BÑ7Ô7ˆ
ð	&Ý˜UÑ#Ô#Ð#øÝð 	&ð 	&ð 	&Ý#™IœIˆMˆMˆMð	&øøøõ Ô" =°!Ñ4Ô4ˆà�Š˜˜zÒ)Ñ*Ô*Ð*Ø×Ò˜ šÑ(Ô(Ð(Ø�Š˜˜wšÑ'Ô'Ð'Ø×Ò˜ 
Ò*Ñ+Ô+Ð+à×Ò˜ šÑ#Ô#Ð#Ð#Ð#s   ‚ ˆ#¢#ÁA  Á A;Á:A;Nr„   )rH   rI   rJ   rj   r`  rõ  rÿ  rK   rA   r?   rî  rî  Ì  sb   € € € € € ðð ðFð Fð Fð FðBð Bð Bð Bð$ð $ð $ð $ð $ð $rA   rî  c                  ó®   — e Zd Zd)d„Zd)d„Zd*d„Zd*d	„Zd+d„Zd+d„Zd+d„Z	d+d„Z
d)d„Zd)d„Zd)d„Zd)d„Zd,d„Zd-d!„Zd)d"„Zd)d#„Zd)d$„Zd)d%„Zd)d&„Zd)d'„Zd(S ).ÚAlreadyCalledTestsr4   rN   c                ó^   — t          j        ¦   «         | _        t          j        d¦  «         d S ©NT)r   r�   Ú_deferredWasDebuggingrŒ   rŽ   s    r?   r�   zAlreadyCalledTests.setUp  s*   € Ý%*Ô%7Ñ%9Ô%9ˆÔ"ÝÔ˜4Ñ Ô Ð Ð Ð rA   c                ó8   — t          j        | j        ¦  «         d S r<   )r   rŒ   r  rŽ   s    r?   ÚtearDownzAlreadyCalledTests.tearDown  s   € ÝÔ˜4Ô5Ñ6Ô6Ð6Ð6Ð6rA   r7   r8   r9   c                ó   — d S r<   rK   r“   s      r?   r”   zAlreadyCalledTests._callback  ó   € ØˆrA   c                ó   — d S r<   rK   r“   s      r?   rš   zAlreadyCalledTests._errback  r  rA   r)  rM   c                ó0   — |                      d¦  «         d S )Nr�   rQ   r>  s     r?   Ú_call_1zAlreadyCalledTests._call_1  ó   € Ø	�
Š
�7ÑÔÐÐÐrA   c                ó0   — |                      d¦  «         d S )NÚtwicerQ   r>  s     r?   Ú_call_2zAlreadyCalledTests._call_2  r  rA   c                ób   — |                      t          t          ¦   «         ¦  «        ¦  «         d S r<   ©r®   r0   rn   r>  s     r?   Ú_err_1zAlreadyCalledTests._err_1  ó&   € Ø	�	Š	•'�,™.œ.Ñ)Ô)Ñ*Ô*Ð*Ð*Ð*rA   c                ób   — |                      t          t          ¦   «         ¦  «        ¦  «         d S r<   r  r>  s     r?   Ú_err_2zAlreadyCalledTests._err_2!  r  rA   c                óØ   — t          ¦   «         }|                     | j        | j        ¦  «         |                      |¦  «         |                      t          j        | j        |¦  «         d S r<   )	r!   r­   r”   rš   r  r©  r   ÚAlreadyCalledErrorr  r>  s     r?   ÚtestAlreadyCalled_CCz'AlreadyCalledTests.testAlreadyCalled_CC$  sU   € Ý#™:œ:ˆØ	�Š�t”~ t¤}Ñ5Ô5Ð5Ø�Š�Q‰ŒˆØ×Ò�%Ô2°D´LÀ!ÑDÔDÐDÐDÐDrA   c                óØ   — t          ¦   «         }|                     | j        | j        ¦  «         |                      |¦  «         |                      t          j        | j        |¦  «         d S r<   )	r!   r­   r”   rš   r  r©  r   r  r  r>  s     r?   ÚtestAlreadyCalled_CEz'AlreadyCalledTests.testAlreadyCalled_CE*  sU   € Ý#™:œ:ˆØ	�Š�t”~ t¤}Ñ5Ô5Ð5Ø�Š�Q‰ŒˆØ×Ò�%Ô2°D´KÀÑCÔCÐCÐCÐCrA   c                óØ   — t          ¦   «         }|                     | j        | j        ¦  «         |                      |¦  «         |                      t          j        | j        |¦  «         d S r<   )	r!   r­   r”   rš   r  r©  r   r  r  r>  s     r?   ÚtestAlreadyCalled_EEz'AlreadyCalledTests.testAlreadyCalled_EE0  sU   € Ý#™:œ:ˆØ	�Š�t”~ t¤}Ñ5Ô5Ð5Ø�Š�A‰ŒˆØ×Ò�%Ô2°D´KÀÑCÔCÐCÐCÐCrA   c                óØ   — t          ¦   «         }|                     | j        | j        ¦  «         |                      |¦  «         |                      t          j        | j        |¦  «         d S r<   )	r!   r­   r”   rš   r  r©  r   r  r  r>  s     r?   ÚtestAlreadyCalled_ECz'AlreadyCalledTests.testAlreadyCalled_EC6  sU   € Ý#™:œ:ˆØ	�Š�t”~ t¤}Ñ5Ô5Ð5Ø�Š�A‰ŒˆØ×Ò�%Ô2°D´LÀ!ÑDÔDÐDÐDÐDrA   Úlinetyper²   ÚfuncÚlinesrÝ  r_  r;  c                ó°   — d}|D ]7}|                      d|z  ¦  «        r|                     d|z  ¦  «        r|dz  }Œ8|                      ||k    ¦  «         d S )Nr   z %s:z %sr]   )r‚   Úendswithrc   )rf   r  r   r!  r_  ÚcountÚlines          r?   Ú_countzAlreadyCalledTests._count<  sm   € ØˆØð 	ð 	ˆDØ�Š˜v¨Ñ0Ñ1Ô1ð °d·m²mÀEÈDÁLÑ6QÔ6Qð Ø˜‘
�øØ�Š˜ Ò)Ñ*Ô*Ð*Ð*Ð*rA   rõ   r¸  ÚcallerÚinvoker1Úinvoker2c                ó–  — |j         d                              d¦  «        }|                      d||d¦  «         |                      dd|d¦  «         |                      dd|d¦  «         |                      dd|d¦  «         |                      dd|d¦  «         |                      d	||d¦  «         |                      d	||d¦  «         d S )
Nr   ú
ÚCr]   r  r  r  r  ÚI)r7   Úsplitr&  )rf   rõ   r'  r(  r)  r!  s         r?   Ú_checkzAlreadyCalledTests._checkC  sÉ   € à”�q”	—’ Ñ%Ô%ˆð 	�Š�C˜ ¨Ñ*Ô*Ð*Ø�Š�C˜ E¨1Ñ-Ô-Ð-Ø�Š�C˜ E¨1Ñ-Ô-Ð-Ø�Š�C˜ 5¨!Ñ,Ô,Ð,Ø�Š�C˜ 5¨!Ñ,Ô,Ð,à�Š�C˜ 5¨!Ñ,Ô,Ð,Ø�Š�C˜ 5¨!Ñ,Ô,Ð,Ð,Ð,rA   c                óL  — t          ¦   «         }|                     | j        | j        ¦  «         |                      |¦  «         	 |                      |¦  «         |                      d¦  «         d S # t          j        $ r#}|  	                    |ddd¦  «         Y d }~d S d }~ww xY w)Nú2second callback failed to raise AlreadyCalledErrorÚtestAlreadyCalledDebug_CCr  r  )
r!   r­   r”   rš   r  r  r-  r   r  r/  ©rf   r)  rõ   s      r?   r2  z,AlreadyCalledTests.testAlreadyCalledDebug_CCQ  sµ   € Ý#™:œ:ˆØ	�Š�t”~ t¤}Ñ5Ô5Ð5Ø�Š�Q‰Œˆð	LØ�LŠL˜‰OŒOˆOð �IŠIÐJÑKÔKÐKÐKÐKøõ Ô'ð 	Nð 	Nð 	NØ�KŠK˜Ð6¸	À9ÑMÔMÐMÐMÐMÐMÐMÐMÐMøøøøð	Nøøøó   ÁA1 Á1B#Â BÂB#c                óL  — t          ¦   «         }|                     | j        | j        ¦  «         |                      |¦  «         	 |                      |¦  «         |                      d¦  «         d S # t          j        $ r#}|  	                    |ddd¦  «         Y d }~d S d }~ww xY w)Nú1second errback failed to raise AlreadyCalledErrorÚtestAlreadyCalledDebug_CEr  r  )
r!   r­   r”   rš   r  r  r-  r   r  r/  r3  s      r?   r7  z,AlreadyCalledTests.testAlreadyCalledDebug_CE\  sµ   € Ý#™:œ:ˆØ	�Š�t”~ t¤}Ñ5Ô5Ð5Ø�Š�Q‰Œˆð	KØ�KŠK˜‰NŒNˆNð �IŠIÐIÑJÔJÐJÐJÐJøõ Ô'ð 	Mð 	Mð 	MØ�KŠK˜Ð6¸	À8ÑLÔLÐLÐLÐLÐLÐLÐLÐLøøøøð	Møøør4  c                óL  — t          ¦   «         }|                     | j        | j        ¦  «         |                      |¦  «         	 |                      |¦  «         |                      d¦  «         d S # t          j        $ r#}|  	                    |ddd¦  «         Y d }~d S d }~ww xY w)Nr1  ÚtestAlreadyCalledDebug_ECr  r  )
r!   r­   r”   rš   r  r  r-  r   r  r/  r3  s      r?   r9  z,AlreadyCalledTests.testAlreadyCalledDebug_ECg  sµ   € Ý#™:œ:ˆØ	�Š�t”~ t¤}Ñ5Ô5Ð5Ø�Š�A‰Œˆð	LØ�LŠL˜‰OŒOˆOð �IŠIÐJÑKÔKÐKÐKÐKøõ Ô'ð 	Mð 	Mð 	MØ�KŠK˜Ð6¸À)ÑLÔLÐLÐLÐLÐLÐLÐLÐLøøøøð	Møøør4  c                óL  — t          ¦   «         }|                     | j        | j        ¦  «         |                      |¦  «         	 |                      |¦  «         |                      d¦  «         d S # t          j        $ r#}|  	                    |ddd¦  «         Y d }~d S d }~ww xY w)Nr6  ÚtestAlreadyCalledDebug_EEr  r  )
r!   r­   r”   rš   r  r  r-  r   r  r/  r3  s      r?   r;  z,AlreadyCalledTests.testAlreadyCalledDebug_EEr  sµ   € Ý#™:œ:ˆØ	�Š�t”~ t¤}Ñ5Ô5Ð5Ø�Š�A‰Œˆð	KØ�KŠK˜‰NŒNˆNð �IŠIÐIÑJÔJÐJÐJÐJøõ Ô'ð 	Lð 	Lð 	LØ�KŠK˜Ð6¸À(ÑKÔKÐKÐKÐKÐKÐKÐKÐKøøøøð	Løøør4  c                óx  — t          j        d¦  «         t          ¦   «         }|                     | j        | j        ¦  «         |                      |¦  «         	 |                      |¦  «         |                      d¦  «         d S # t           j	        $ r%}|  
                    |j        ¦  «         Y d }~d S d }~ww xY w)NFr1  )r   rŒ   r!   r­   r”   rš   r  r  r-  r  r	  r7   r3  s      r?   ÚtestNoDebuggingz"AlreadyCalledTests.testNoDebugging}  s¿   € ÝÔ˜5Ñ!Ô!Ð!Ý#™:œ:ˆØ	�Š�t”~ t¤}Ñ5Ô5Ð5Ø�Š�Q‰Œˆð	LØ�LŠL˜‰OŒOˆOð �IŠIÐJÑKÔKÐKÐKÐKøõ Ô'ð 	%ð 	%ð 	%Ø×Ò˜QœVÑ$Ô$Ð$Ð$Ð$Ð$Ð$Ð$Ð$øøøøð	%øøøs   ÁB ÂB9ÂB4Â4B9c                óŠ  — t          j        d¦  «         t          ¦   «         }|                     d„ ¦  «         t          j        d¦  «         |                     d ¦  «         t          j        d¦  «         t          ¦   «         }|                     d ¦  «         t          j        d¦  «         |                     d„ ¦  «         d S )NFc                ó   — d S r<   rK   ©r  s    r?   rö   z8AlreadyCalledTests.testSwitchDebugging.<locals>.<lambda>Ž  ó   € ˜d€ rA   Tc                ó   — d S r<   rK   r@  s    r?   rö   z8AlreadyCalledTests.testSwitchDebugging.<locals>.<lambda>–  rA  rA   )r   rŒ   r!   ÚaddBothrR   r>  s     r?   ÚtestSwitchDebuggingz&AlreadyCalledTests.testSwitchDebugging‰  s°   € õ 	Ô˜5Ñ!Ô!Ð!Ý$™JœJˆØ	�	Š	Ð"Ð"Ñ#Ô#Ð#ÝÔ˜4Ñ Ô Ð Ø	�
Š
�4ÑÔÐåÔ˜5Ñ!Ô!Ð!Ý‰JŒJˆØ	�
Š
�4ÑÔÐÝÔ˜4Ñ Ô Ð Ø	�	Š	Ð"Ð"Ñ#Ô#Ð#Ð#Ð#rA   Nr„   rÆ  )r)  rM   r4   rN   )
r  r²   r   r²   r!  rÝ  r_  r;  r4   rN   )
rõ   r¸  r'  r²   r(  r²   r)  r²   r4   rN   )rH   rI   rJ   r�   r  r”   rš   r  r  r  r  r  r  r  r  r&  r/  r2  r7  r9  r;  r=  rD  rK   rA   r?   r  r  
  sÈ  € € € € € ð!ð !ð !ð !ð7ð 7ð 7ð 7ðð ð ð ðð ð ð ðð ð ð ðð ð ð ð+ð +ð +ð +ð+ð +ð +ð +ðEð Eð Eð EðDð Dð Dð DðDð Dð Dð DðEð Eð Eð Eð+ð +ð +ð +ð-ð -ð -ð -ð	Lð 	Lð 	Lð 	Lð	Kð 	Kð 	Kð 	Kð	Lð 	Lð 	Lð 	Lð	Kð 	Kð 	Kð 	Kð
Lð 
Lð 
Lð 
Lð$ð $ð $ð $ð $ð $rA   r  c                  ó¦   — e Zd Zdd„Zdd„Zdd„Zdd„Zdd„Zdd„Zdd„Z	dd„Z
dd„Zdd„Zdd„Zdd„Zdd„Zdd„Zdd„Zdd„Zdd„Zdd„Zdd„ZdS )ÚDeferredCancellerTestsr4   rN   c                ó>   — d | _         d | _        d | _        d| _        d S r‘   )rˆ   rŠ   r‰   ÚcancellerCallCountrŽ   s    r?   r�   zDeferredCancellerTests.setUpš  s(   € Ø.2ˆÔØ15ˆÔØ/3ˆÔØ"#ˆÔÐÐrA   c                ó<   — |                       | j        d¦  «         d S )Nro  )ÚassertInrH  rŽ   s    r?   r  zDeferredCancellerTests.tearDown   s   € à�Š�dÔ-¨vÑ6Ô6Ð6Ð6Ð6rA   Údatar²   c                ó   — || _         |S r<   r’   ©rf   rK  s     r?   r”   z DeferredCancellerTests._callback¤  s   € Ø#ˆÔØˆrA   c                ó   — || _         d S r<   r–   rM  s     r?   r—   z!DeferredCancellerTests._callback2¨  s   € Ø $ˆÔÐÐrA   rr   r0   c                ó   — || _         d S r<   r™   )rf   rr   s     r?   rš   zDeferredCancellerTests._errback«  s   € Ø#ˆÔÐÐrA   c                ó$  — t          ¦   «         }|                     | j        | j        ¦  «         |                     ¦   «          | j        €J ‚|                      | j        j        t          j	        ¦  «         |  
                    | j        ¦  «         dS )zy
        A L{Deferred} without a canceller must errback with a
        L{defer.CancelledError} and not callback.
        N)r!   r­   r”   rš   r   rŠ   ra   rß   r   r   r¡   rˆ   r>  s     r?   Útest_noCancellerz'DeferredCancellerTests.test_noCanceller®  s}   € õ
 %™JœJˆØ	�Š�t”~ t¤}Ñ5Ô5Ð5Ø	�Š‰
Œ
ˆ
ØÔ"Ð.Ð.Ð.Ø×Ò˜Ô,Ô1µ5Ô3GÑHÔHÐHØ×Ò˜$Ô.Ñ/Ô/Ð/Ð/Ð/rA   c                ód  — t          ¦   «         }|                     | j        | j        ¦  «         |                     ¦   «          |                     d¦  «         |                      t          j        |j        d¦  «         |                      t          j        |j	        t          ¦   «         ¦  «         dS )zÌ
        A L{Deferred} without a canceller, when cancelled must allow
        a single extra call to callback, and raise
        L{defer.AlreadyCalledError} if callbacked or errbacked thereafter.
        N)r!   r­   r”   rš   r   rR   r©  r   r  r®   r¸  r>  s     r?   Ú!test_raisesAfterCancelAndCallbackz8DeferredCancellerTests.test_raisesAfterCancelAndCallbackº  sŒ   € õ %™JœJˆØ	�Š�t”~ t¤}Ñ5Ô5Ð5Ø	�Š‰
Œ
ˆ
ð 	
�
Š
�4ÑÔÐð 	×Ò�%Ô2°A´JÀÑEÔEÐEØ×Ò�%Ô2°A´I½y¹{¼{ÑKÔKÐKÐKÐKrA   c                ó|  — t          ¦   «         }|                     | j        | j        ¦  «         |                     ¦   «          |                     t          ¦   «         ¦  «         |                      t          j	        |j
        d¦  «         |                      t          j	        |j        t          ¦   «         ¦  «         dS )zË
        A L{Deferred} without a canceller, when cancelled must allow
        a single extra call to errback, and raise
        L{defer.AlreadyCalledError} if callbacked or errbacked thereafter.
        N)r!   r­   r”   rš   r   r®   r¸  r©  r   r  rR   r>  s     r?   Ú test_raisesAfterCancelAndErrbackz7DeferredCancellerTests.test_raisesAfterCancelAndErrbackË  s�   € õ %™JœJˆØ	�Š�t”~ t¤}Ñ5Ô5Ð5Ø	�Š‰
Œ
ˆ
ð 	
�	Š	•)‘+”+ÑÔÐð 	×Ò�%Ô2°A´JÀÑEÔEÐEØ×Ò�%Ô2°A´I½y¹{¼{ÑKÔKÐKÐKÐKrA   c                ó   — t          ¦   «         }|                     | j        | j        ¦  «         |                     ¦   «          | j        }|                     d¦  «         |                     ¦   «          |                      || j        ¦  «         dS )z…
        A L{Deferred} without a canceller, when cancelled and then
        callbacked, ignores multiple cancels thereafter.
        N)r!   r­   r”   rš   r   rŠ   rR   rq   ©rf   r)  ÚcurrentFailures      r?   Ú5test_noCancellerMultipleCancelsAfterCancelAndCallbackzLDeferredCancellerTests.test_noCancellerMultipleCancelsAfterCancelAndCallbackÜ  sv   € õ
 %™JœJˆØ	�Š�t”~ t¤}Ñ5Ô5Ð5Ø	�Š‰
Œ
ˆ
ØÔ,ˆà	�
Š
�4ÑÔÐà	�Š‰
Œ
ˆ
Ø�Š�n dÔ&9Ñ:Ô:Ð:Ð:Ð:rA   c                óò  — t          ¦   «         }|                     | j        | j        ¦  «         |                     ¦   «          | j        €J ‚|                      | j        j        t          j	        ¦  «         | j        }| 
                    t          ¦   «         ¦  «         |                      | j        j        t          j	        ¦  «         |                     ¦   «          |                      || j        ¦  «         dS )z„
        A L{Deferred} without a canceller, when cancelled and then
        errbacked, ignores multiple cancels thereafter.
        N)r!   r­   r”   rš   r   rŠ   ra   rß   r   r   r®   rF   rq   rW  s      r?   Ú4test_noCancellerMultipleCancelsAfterCancelAndErrbackzKDeferredCancellerTests.test_noCancellerMultipleCancelsAfterCancelAndErrbackë  sÇ   € õ
 %™JœJˆØ	�Š�t”~ t¤}Ñ5Ô5Ð5Ø	�Š‰
Œ
ˆ
ØÔ"Ð.Ð.Ð.Ø×Ò˜Ô,Ô1µ5Ô3GÑHÔHÐHØÔ,ˆà	�	Š	•,‘.”.Ñ!Ô!Ð!à×Ò˜Ô,Ô1µ5Ô3GÑHÔHÐHØ	�Š‰
Œ
ˆ
Ø�Š�n dÔ&9Ñ:Ô:Ð:Ð:Ð:rA   c                ó\  — t          ¦   «         }|                     | j        | j        ¦  «         |                     ¦   «          | j        €J ‚|                      | j        j        t          j	        ¦  «         | j        }|                     ¦   «          |  
                    || j        ¦  «         dS )z·
        Calling cancel multiple times on a deferred with no canceller
        results in a L{defer.CancelledError}. Subsequent calls to cancel
        do not cause an error.
        N)r!   r­   r”   rš   r   rŠ   ra   rß   r   r   rq   rW  s      r?   Útest_noCancellerMultipleCancelz5DeferredCancellerTests.test_noCancellerMultipleCancelý  s’   € õ %™JœJˆØ	�Š�t”~ t¤}Ñ5Ô5Ð5Ø	�Š‰
Œ
ˆ
ØÔ"Ð.Ð.Ð.Ø×Ò˜Ô,Ô1µ5Ô3GÑHÔHÐHØÔ,ˆØ	�Š‰
Œ
ˆ
Ø�Š�n dÔ&9Ñ:Ô:Ð:Ð:Ð:rA   c                ó¤  ‡ — d	ˆ fd„}t          |¬¦  «        }|                     ‰ j        ‰ j        ¦  «         |                     ¦   «          ‰ j        €J ‚‰                      ‰ j        j        t          j	        ¦  «         ‰ j        }|                     ¦   «          ‰  
                    |‰ j        ¦  «         ‰                      ‰ j        d¦  «         dS )
a,  
        Verify that calling cancel multiple times on a deferred with a
        canceller that does not errback results in a
        L{defer.CancelledError} and that subsequent calls to cancel do not
        cause an error and that after all that, the canceller was only
        called once.
        r)  r  r4   rN   c                ó(   •— ‰xj         dz  c_         d S rK  ©rH  ©r)  rf   s    €r?   r   zCDeferredCancellerTests.test_cancellerMultipleCancel.<locals>.cancel	  ó   ø€ ØÐ#Ô# qÑ(Ð#Ô#Ð#Ð#rA   rÓ  Nr]   ©r)  r  r4   rN   )r!   r­   r”   rš   r   rŠ   ra   rß   r   r   rq   rH  )rf   r   r)  rX  s   `   r?   Útest_cancellerMultipleCancelz3DeferredCancellerTests.test_cancellerMultipleCancel	  sÑ   ø€ ð	)ð 	)ð 	)ð 	)ð 	)ð 	)õ %¨vÐ6Ñ6Ô6ˆØ	�Š�t”~ t¤}Ñ5Ô5Ð5Ø	�Š‰
Œ
ˆ
ØÔ"Ð.Ð.Ð.Ø×Ò˜Ô,Ô1µ5Ô3GÑHÔHÐHØÔ,ˆØ	�Š‰
Œ
ˆ
Ø�Š�n dÔ&9Ñ:Ô:Ð:Ø×Ò˜Ô0°!Ñ4Ô4Ð4Ð4Ð4rA   c                óè  ‡ — d	ˆ fd„}t          |¬¦  «        }|                     ‰ j        ‰ j        ¦  «         |                     ¦   «          ‰                      ‰ j        d¦  «         ‰ j        €J ‚‰                      ‰ j        j        t          j
        ¦  «         ‰                      t          j        |j        d¦  «         ‰                      t          j        |j        t          ¦   «         ¦  «         dS )
z±
        Verify that a L{Deferred} calls its specified canceller when
        it is cancelled, and that further call/errbacks raise
        L{defer.AlreadyCalledError}.
        r)  r  r4   rN   c                ó(   •— ‰xj         dz  c_         d S rK  r`  ra  s    €r?   r   z;DeferredCancellerTests.test_simpleCanceller.<locals>.cancel)	  rb  rA   rÓ  r]   Nrc  )r!   r­   r”   rš   r   ra   rH  rŠ   rß   r   r   r©  r  rR   r®   r¸  ©rf   r   r)  s   `  r?   Útest_simpleCancellerz+DeferredCancellerTests.test_simpleCanceller"	  så   ø€ ð	)ð 	)ð 	)ð 	)ð 	)ð 	)õ %¨vÐ6Ñ6Ô6ˆØ	�Š�t”~ t¤}Ñ5Ô5Ð5Ø	�Š‰
Œ
ˆ
Ø×Ò˜Ô0°!Ñ4Ô4Ð4ØÔ"Ð.Ð.Ð.Ø×Ò˜Ô,Ô1µ5Ô3GÑHÔHÐHð 	×Ò�%Ô2°A´JÀÑEÔEÐEØ×Ò�%Ô2°A´I½y¹{¼{ÑKÔKÐKÐKÐKrA   c                ó    ‡ ‡— dˆˆ fd„}t          |¬¦  «        Š‰                     ‰ j        ‰ j        ¦  «         ‰                     ¦   «          dS )	zQ
        Verify that a canceller is given the correct deferred argument.
        ré   r  r4   rN   c                ó4   •— ‰                      | ‰¦  «         d S r<   )rq   )ré   r)  rf   s    €€r?   r   z8DeferredCancellerTests.test_cancellerArg.<locals>.cancel<	  s   ø€ Ø�MŠM˜"˜aÑ Ô Ð Ð Ð rA   rÓ  N)ré   r  r4   rN   )r!   r­   r”   rš   r   rg  s   ` @r?   Útest_cancellerArgz(DeferredCancellerTests.test_cancellerArg7	  sb   øø€ ð
	!ð 	!ð 	!ð 	!ð 	!ð 	!ð 	!õ %¨vÐ6Ñ6Ô6ˆØ	�Š�t”~ t¤}Ñ5Ô5Ð5Ø	�Š‰
Œ
ˆ
ˆ
ˆ
rA   c                óf  ‡ — d
ˆ fd„}t          |¬¦  «        }|                     ‰ j        ‰ j        ¦  «         |                     d¦  «         |                     ¦   «          ‰                      ‰ j        d¦  «         ‰                      ‰ j	        ¦  «         ‰                      ‰ j
        d¦  «         d	S )zo
        Test that cancelling a deferred after it has been callbacked does
        not cause an error.
        r)  r  r4   rN   c                ój   •— ‰xj         dz  c_         |                      t          ¦   «         ¦  «         d S rK  ©rH  r®   rF   ra  s    €r?   r   z?DeferredCancellerTests.test_cancelAfterCallback.<locals>.cancelI	  ó3   ø€ ØÐ#Ô# qÑ(Ð#Ô#Ø�IŠI•l‘n”nÑ%Ô%Ð%Ð%Ð%rA   rÓ  zbiff!r   Nrc  )r!   r­   r”   rš   rR   r   ra   rH  r¡   rŠ   rˆ   rg  s   `  r?   Útest_cancelAfterCallbackz/DeferredCancellerTests.test_cancelAfterCallbackC	  s¹   ø€ ð	&ð 	&ð 	&ð 	&ð 	&ð 	&õ $¨fÐ5Ñ5Ô5ˆØ	�Š�t”~ t¤}Ñ5Ô5Ð5Ø	�
Š
�7ÑÔÐØ	�Š‰
Œ
ˆ
Ø×Ò˜Ô0°!Ñ4Ô4Ð4Ø×Ò˜$Ô-Ñ.Ô.Ð.Ø×Ò˜Ô-¨wÑ7Ô7Ð7Ð7Ð7rA   c                ó¤  ‡ — d	ˆ fd„}t          |¬¦  «        }|                     ‰ j        ‰ j        ¦  «         |                     t          ¦   «         ¦  «         |                     ¦   «          ‰                      ‰ j        d¦  «         ‰ j	        €J ‚‰                      ‰ j	        j
        t
          ¦  «         ‰                      ‰ j        ¦  «         dS )
z†
        Test that cancelling a L{Deferred} after it has been errbacked does
        not result in a L{defer.CancelledError}.
        r)  r  r4   rN   c                ój   •— ‰xj         dz  c_         |                      t          ¦   «         ¦  «         d S rK  rn  ra  s    €r?   r   z>DeferredCancellerTests.test_cancelAfterErrback.<locals>.cancel[	  ro  rA   rÓ  r   Nrc  )r!   r­   r”   rš   r®   rF   r   ra   rH  rŠ   rß   r¡   rˆ   rg  s   `  r?   Útest_cancelAfterErrbackz.DeferredCancellerTests.test_cancelAfterErrbackU	  sÏ   ø€ ð	&ð 	&ð 	&ð 	&ð 	&ð 	&õ %¨vÐ6Ñ6Ô6ˆØ	�Š�t”~ t¤}Ñ5Ô5Ð5Ø	�	Š	•,‘.”.Ñ!Ô!Ð!Ø	�Š‰
Œ
ˆ
Ø×Ò˜Ô0°!Ñ4Ô4Ð4ØÔ"Ð.Ð.Ð.Ø×Ò˜Ô,Ô1µ<Ñ@Ô@Ð@Ø×Ò˜$Ô.Ñ/Ô/Ð/Ð/Ð/rA   c                ó.  ‡ — d	ˆ fd„}t          |¬¦  «        }|                     ‰ j        ‰ j        ¦  «         |                     ¦   «          ‰                      ‰ j        d¦  «         ‰ j        €J ‚‰                      ‰ j        j        t          ¦  «         dS )
z?
        Test a canceller which errbacks its deferred.
        r)  r  r4   rN   c                ój   •— ‰xj         dz  c_         |                      t          ¦   «         ¦  «         d S rK  rn  ra  s    €r?   r   zADeferredCancellerTests.test_cancellerThatErrbacks.<locals>.cancelm	  ro  rA   rÓ  r]   Nrc  )
r!   r­   r”   rš   r   ra   rH  rŠ   rß   rF   rg  s   `  r?   Útest_cancellerThatErrbacksz1DeferredCancellerTests.test_cancellerThatErrbacksh	  s¢   ø€ ð
	&ð 	&ð 	&ð 	&ð 	&ð 	&õ %¨vÐ6Ñ6Ô6ˆØ	�Š�t”~ t¤}Ñ5Ô5Ð5Ø	�Š‰
Œ
ˆ
Ø×Ò˜Ô0°!Ñ4Ô4Ð4ØÔ"Ð.Ð.Ð.Ø×Ò˜Ô,Ô1µ<Ñ@Ô@Ð@Ð@Ð@rA   c                ó<  ‡ — d
ˆ fd„}t          |¬¦  «        }|                     ‰ j        ‰ j        ¦  «         |                     ¦   «          ‰                      ‰ j        d¦  «         ‰                      ‰ j        d¦  «         ‰                      ‰ j	        ¦  «         d	S )z<
        Test a canceller which calls its deferred.
        r)  r  r4   rN   c                óR   •— ‰xj         dz  c_         |                      d¦  «         d S )Nr]   úhello!)rH  rR   ra  s    €r?   r   zBDeferredCancellerTests.test_cancellerThatCallbacks.<locals>.cancel}	  s/   ø€ ØÐ#Ô# qÑ(Ð#Ô#Ø�JŠJ�xÑ Ô Ð Ð Ð rA   rÓ  r]   ry  Nrc  )
r!   r­   r”   rš   r   ra   rH  rˆ   r¡   rŠ   rg  s   `  r?   Útest_cancellerThatCallbacksz2DeferredCancellerTests.test_cancellerThatCallbacksx	  s§   ø€ ð
	!ð 	!ð 	!ð 	!ð 	!ð 	!õ %¨vÐ6Ñ6Ô6ˆØ	�Š�t”~ t¤}Ñ5Ô5Ð5Ø	�Š‰
Œ
ˆ
Ø×Ò˜Ô0°!Ñ4Ô4Ð4Ø×Ò˜Ô-¨xÑ8Ô8Ð8Ø×Ò˜$Ô-Ñ.Ô.Ð.Ð.Ð.rA   c                óÀ  ‡ ‡— dˆ fd„}dˆ fd„}t          |¬¦  «        Št          |¬¦  «        }|                     d¦  «         |                     ˆfd	„¦  «         |                     ¦   «          |                     ‰ j        ‰ j        ¦  «         ‰                      ‰ j        d
¦  «         ‰ j	        €J ‚‰                      ‰ j	        j
        t          j        ¦  «         dS )zÅ
        Verify that a Deferred, a, which is waiting on another Deferred, b,
        returned from one of its callbacks, will propagate
        L{defer.CancelledError} when a is cancelled.
        r)  r  r4   rN   c                ó(   •— ‰xj         dz  c_         d S rK  r`  ra  s    €r?   ÚinnerCancelzEDeferredCancellerTests.test_cancelNestedDeferred.<locals>.innerCancel�	  rb  rA   c                ó2   •— ‰                      d¦  «         d S ©NF)rc   ra  s    €r?   r   z@DeferredCancellerTests.test_cancelNestedDeferred.<locals>.cancel’	  s   ø€ Ø�OŠO˜EÑ"Ô"Ð"Ð"Ð"rA   rÓ  Nc                ó   •— ‰S r<   rK   )rK  r:  s    €r?   rö   zBDeferredCancellerTests.test_cancelNestedDeferred.<locals>.<lambda>˜	  s   ø€  1€ rA   r]   rc  )r!   rR   r    r   r­   r”   rš   ra   rH  rŠ   rß   r   r   )rf   r}  r   rÛ  r:  s   `   @r?   Útest_cancelNestedDeferredz0DeferredCancellerTests.test_cancelNestedDeferredˆ	  s   øø€ ð	)ð 	)ð 	)ð 	)ð 	)ð 	)ð	#ð 	#ð 	#ð 	#ð 	#ð 	#õ %¨{Ð;Ñ;Ô;ˆÝ$¨vÐ6Ñ6Ô6ˆØ	�
Š
�4ÑÔÐØ	�Š�n�n�n�nÑ%Ô%Ð%Ø	�Š‰
Œ
ˆ
Ø	�Š�t”~ t¤}Ñ5Ô5Ð5à×Ò˜Ô0°!Ñ4Ô4Ð4ð Ô"Ð.Ð.Ð.Ø×Ò˜Ô,Ô1µ5Ô3GÑHÔHÐHÐHÐHrA   Nr„   )rK  r²   r4   r²   )rK  r²   r4   rN   )rr   r0   r4   rN   )rH   rI   rJ   r�   r  r”   r—   rš   rQ  rS  rU  rY  r[  r]  rd  rh  rk  rp  rs  rv  rz  r�  rK   rA   r?   rF  rF  ™  s¦  € € € € € ð$ð $ð $ð $ð7ð 7ð 7ð 7ðð ð ð ð%ð %ð %ð %ð$ð $ð $ð $ð
0ð 
0ð 
0ð 
0ðLð Lð Lð Lð"Lð Lð Lð Lð";ð ;ð ;ð ;ð;ð ;ð ;ð ;ð$;ð ;ð ;ð ;ð5ð 5ð 5ð 5ð,Lð Lð Lð Lð*
ð 
ð 
ð 
ð8ð 8ð 8ð 8ð$0ð 0ð 0ð 0ð&Að Að Að Að /ð /ð /ð /ð Ið Ið Ið Ið Ið IrA   rF  c                  ój   — e Zd ZdZdd„Zdd„Zdd„Zdd„Zdd	„Zdd
„Z	dd„Z
dd„Zdd„Zdd„Zdd„ZdS )ÚLogTestsz+
    Test logging of unhandled errors.
    r4   rN   c                óP   — g | _         t          j        | j         j        ¦  «         dS )z<
        Add a custom observer to observer logging.
        N)Úcr-   r�   r`   rŽ   s    r?   r�   zLogTests.setUp¨	  s%   € ð (*ˆŒÝŒ˜œœÑ&Ô&Ð&Ð&Ð&rA   c                óB   — t          j        | j        j        ¦  «         dS )z&
        Remove the observer.
        N)r-   ÚremoveObserverr…  r`   rŽ   s    r?   r  zLogTests.tearDown¯	  s   € õ 	Ô˜4œ6œ=Ñ)Ô)Ð)Ð)Ð)rA   úList[Dict[str, Any]]c                ó$   — d„ | j         D ¦   «         S )Nc                ó"   — g | ]}|d          ¯
|‘ŒS )ÚisErrorrK   )ro  rõ   s     r?   rp  z*LogTests._loggedErrors.<locals>.<listcomp>¶	  s!   € Ð2Ð2Ð2�a Q y¤\Ð2�Ð2Ð2Ð2rA   ©r…  rŽ   s    r?   Ú_loggedErrorszLogTests._loggedErrorsµ	  s   € Ø2Ð2˜4œ6Ð2Ñ2Ô2Ð2rA   c                óô   — |                       ¦   «         }|                      t          |¦  «        d¦  «         |d         d                              t          ¦  «         |                      t          ¦  «         dS )zV
        Check the output of the log observer to see if the error is present.
        rÅ   r]   rX  N)r�  ra   rb   rW  r9  rp   )rf   Úc2s     r?   r/  zLogTests._check¸	  sj   € ð ×ÒÑ!Ô!ˆØ×Ò�˜R™œ !Ñ$Ô$Ð$Ø
ˆ1ŒˆiÔ×ÒÕ/Ñ0Ô0Ð0Ø×ÒÕ0Ñ1Ô1Ð1Ð1Ð1rA   c                ó¾   — t          ¦   «                              d„ ¦  «                             d¦  «         t          j        ¦   «          |                      ¦   «          dS )zÚ
        Verify that when a L{Deferred} with no references to it is fired,
        and its final result (the one not handled by any callback) is an
        exception, that exception will be logged immediately.
        c                ó   — ddz  S r5  rK   r…  s    r?   rö   z(LogTests.test_errorLog.<locals>.<lambda>Ç	  ó
   € ¨¨a©€ rA   r]   N)r!   r    rR   ÚgcÚcollectr/  rŽ   s    r?   Útest_errorLogzLogTests.test_errorLogÁ	  sJ   € õ 	‰
Œ
×ÒÐ/Ð/Ñ0Ô0×9Ò9¸!Ñ<Ô<Ð<Ý
Œ
‰ŒˆØ�Š‰ŒˆˆˆrA   c                óp   — dd„} |¦   «          t          j        ¦   «          |                      ¦   «          dS )zD
        Same as L{test_errorLog}, but with an inner frame.
        r4   rN   c                 óx   — t          ¦   «         } |                      d„ ¦  «         |                      d¦  «         d S )Nc                ó   — ddz  S r5  rK   r…  s    r?   rö   z`LogTests.test_errorLogWithInnerFrameRef.<locals>._subErrorLogWithInnerFrameRef.<locals>.<lambda>Ò	  ó
   €  A¨¡F€ rA   r]   )r!   r    rR   rè  s    r?   Ú_subErrorLogWithInnerFrameRefzNLogTests.test_errorLogWithInnerFrameRef.<locals>._subErrorLogWithInnerFrameRefÐ	  s4   € Ý'™zœzˆAØ�MŠMÐ*Ð*Ñ+Ô+Ð+Ø�JŠJ�q‰MŒMˆMˆMˆMrA   Nr„   ©r“  r”  r/  )rf   rš  s     r?   Útest_errorLogWithInnerFrameRefz'LogTests.test_errorLogWithInnerFrameRefË	  sC   € ð
	ð 	ð 	ð 	ð
 	&Ð%Ñ'Ô'Ð'Ý
Œ
‰ŒˆØ�Š‰ŒˆˆˆrA   c                óp   — dd„} |¦   «          t          j        ¦   «          |                      ¦   «          dS )zQ
        Same as L{test_errorLogWithInnerFrameRef}, plus create a cycle.
        r4   rN   c                 ó�   — t          ¦   «         } | fdd„}|                      |¦  «         | | _        |                      d¦  «         d S )	Nr‚  r;  r)  úDeferred[int]r4   c                ó   — ddz  S r5  rK   )r‚  r)  s     r?   ÚunusedCyclezgLogTests.test_errorLogWithInnerFrameCycle.<locals>._subErrorLogWithInnerFrameCycle.<locals>.unusedCycleá	  s   € Ø˜A‘v�rA   r]   )r‚  r;  r)  rŸ  r4   r;  )r!   r    Ú_drR   )r)  r¡  s     r?   Ú_subErrorLogWithInnerFrameCyclezRLogTests.test_errorLogWithInnerFrameCycle.<locals>._subErrorLogWithInnerFrameCycleÞ	  sU   € Ý'™zœzˆAà78ð ð ð ð ð ð �MŠM˜+Ñ&Ô&Ð&àˆAŒDØ�JŠJ�q‰MŒMˆMˆMˆMrA   Nr„   r›  )rf   r£  s     r?   Ú test_errorLogWithInnerFrameCyclez)LogTests.test_errorLogWithInnerFrameCycleÙ	  sC   € ð
		ð 		ð 		ð 		ð 	(Ð'Ñ)Ô)Ð)Ý
Œ
‰ŒˆØ�Š‰ŒˆˆˆrA   c                ó°  — t          ¦   «                              d„ ¦  «                             d¦  «         t          j        ¦   «          |                      ¦   «          |                      dt          | j        ¦  «        ¦  «         t          j
        | j        d         ¦  «        }|€J ‚d}|                      |                     |¦  «        d|›�¦  «         dS )z�
        Verify that when a L{Deferred} with no references to it is fired,
        the logged message does not contain a repr of the failure object.
        c                ó   — ddz  S r5  rK   r…  s    r?   rö   z.LogTests.test_errorLogNoRepr.<locals>.<lambda>ò	  r’  rA   r]   rÅ   rÂ  Nr€   ú Expected message starting with: )r!   r    rR   r“  r”  r/  ra   rb   r…  r-   r|   rc   r‚   )rf   Úmsgr_  s      r?   Útest_errorLogNoReprzLogTests.test_errorLogNoReprí	  sÂ   € õ
 	‰
Œ
×ÒÐ/Ð/Ñ0Ô0×9Ò9¸!Ñ<Ô<Ð<å
Œ
‰ŒˆØ�Š‰Œˆà×Ò˜�C ¤™KœKÑ(Ô(Ð(ÝÔ# D¤F¨2¤JÑ/Ô/ˆØˆˆˆØ0ˆØ�ŠØ�NŠN˜8Ñ$Ô$Ø;¨xÐ;Ð;ñ	
ô 	
ð 	
ð 	
ð 	
rA   c                ób  — d	d„} |¦   «          t          j        ¦   «          |                      ¦   «          |                      dt	          | j        ¦  «        ¦  «         t          j        | j        d         ¦  «        }|€J ‚d}|                      | 	                    |¦  «        d|›�¦  «         dS )
z³
        Verify that when a L{Deferred} with no references to it is fired,
        the logged message includes debug info if debugging on the deferred
        is enabled.
        r4   rN   c                 ó†   — t          ¦   «         } d| _        |                      d„ ¦  «         |                      d¦  «         d S )NTc                ó   — ddz  S r5  rK   r…  s    r?   rö   z?LogTests.test_errorLogDebugInfo.<locals>.doit.<locals>.<lambda>

  r™  rA   r]   )r!   Údebugr    rR   rè  s    r?   Údoitz-LogTests.test_errorLogDebugInfo.<locals>.doit
  s;   € Ý'™zœzˆAØˆAŒGØ�MŠMÐ*Ð*Ñ+Ô+Ð+Ø�JŠJ�q‰MŒMˆMˆMˆMrA   rÅ   rÂ  Nz
(debug:  Ir§  r„   )
r“  r”  r/  ra   rb   r…  r-   r|   rc   r‚   )rf   r®  r¨  r_  s       r?   Útest_errorLogDebugInfozLogTests.test_errorLogDebugInfo 
  s·   € ð	ð 	ð 	ð 	ð 	ˆ‰ŒˆÝ
Œ
‰ŒˆØ�Š‰Œˆà×Ò˜�C ¤™KœKÑ(Ô(Ð(ÝÔ# D¤F¨2¤JÑ/Ô/ˆØˆˆˆØˆØ�ŠØ�NŠN˜8Ñ$Ô$Ø;¨xÐ;Ð;ñ	
ô 	
ð 	
ð 	
ð 	
rA   c                óî  — t          ¦   «         }|                     d„ ¦  «         |                     d¦  «         g }g }|                     |j        |j        ¦  «         |                      |g ¦  «         |                      t          |¦  «        d¦  «         |d                              t          ¦  «         ~~~t          j
        ¦   «          |                      |                      ¦   «         g ¦  «         dS )z¿
        If one Deferred with an error result is returned from a callback on
        another Deferred, when the first Deferred is garbage collected it does
        not log its error.
        c                óD   — t          j        t          d¦  «        ¦  «        S )NÚzoop)r   r-  rn   r@  s    r?   rö   z3LogTests.test_chainedErrorCleanup.<locals>.<lambda>!
  s   € ¥%¤*­\¸&Ñ-AÔ-AÑ"BÔ"B€ rA   Nr]   r   )r!   r    rR   r­   r`   ra   rb   rW  r¸  r“  r”  r�  )rf   r)  rl  rv   s       r?   Útest_chainedErrorCleanupz!LogTests.test_chainedErrorCleanup
  sß   € õ %™JœJˆØ	�ŠÐBÐBÑCÔCÐCØ	�
Š
�4ÑÔÐð !ˆØ "ˆØ	�Š�w”~ v¤}Ñ5Ô5Ð5Ø×Ò˜ "Ñ%Ô%Ð%Ø×Ò�˜V™œ aÑ(Ô(Ð(ØˆqŒ	�Š•yÑ!Ô!Ð!ð �V˜Qõ 	Œ
‰Œˆà×Ò˜×+Ò+Ñ-Ô-¨rÑ2Ô2Ð2Ð2Ð2rA   c                ó  ‡— t          j        t          d¦  «        ¦  «        }t          ¦   «         Š|€J ‚|                     ˆfd„¦  «         dxŠ}t          j        ¦   «          |                      |                      ¦   «         g ¦  «         dS )z¼
        If a Deferred with a failure result has an errback which chains it to
        another Deferred, the initial failure is cleared by the errback so it is
        not logged.
        zoh noNc                ó   •— ‰S r<   rK   )r]  Úgoods    €r?   rö   z6LogTests.test_errorClearedByChaining.<locals>.<lambda>A
  s   ø€  t€ rA   )	r   r-  r¸  r!   r_   r“  r”  ra   r�  )rf   Úbadr¶  s     @r?   Útest_errorClearedByChainingz$LogTests.test_errorClearedByChaining6
  s‰   ø€ õ ).¬
µ9¸WÑ3EÔ3EÑ(FÔ(FˆÝ)1©¬ˆàˆˆˆØ�ŠÐ+Ð+Ð+Ð+Ñ,Ô,Ð,ð ÐˆˆsÝ
Œ
‰ŒˆØ×Ò˜×+Ò+Ñ-Ô-¨rÑ2Ô2Ð2Ð2Ð2rA   Nr„   )r4   rˆ  )rH   rI   rJ   rj   r�   r  r�  r/  r•  rœ  r¤  r©  r¯  r³  r¸  rK   rA   r?   rƒ  rƒ  £	  sú   € € € € € ðð ð'ð 'ð 'ð 'ð*ð *ð *ð *ð3ð 3ð 3ð 3ð2ð 2ð 2ð 2ðð ð ð ðð ð ð ðð ð ð ð(
ð 
ð 
ð 
ð&
ð 
ð 
ð 
ð43ð 3ð 3ð 3ð83ð 3ð 3ð 3ð 3ð 3rA   rƒ  c                  ó.   — e Zd Zd
d„Zd
d„Zdd„Zd
d„Zd	S )ÚDeferredListEmptyTestsr4   rN   c                ó   — d| _         d S r‘   )ÚcallbackRanrŽ   s    r?   r�   zDeferredListEmptyTests.setUpJ
  s   € ØˆÔÐÐrA   c                óX   — t          g ¦  «        }|                     | j        ¦  «         dS )zTesting empty DeferredList.N)r#   r    Úcb_empty)rf   rÍ   s     r?   ÚtestDeferredListEmptyz,DeferredListEmptyTests.testDeferredListEmptyM
  s)   € å9EÀbÑ9IÔ9IˆØ
�Š�t”}Ñ%Ô%Ð%Ð%Ð%rA   ÚresúList[Tuple[bool, object]]c                ó@   — d| _         |                      g |¦  «         d S rK  )r¼  ra   )rf   rÀ  s     r?   r¾  zDeferredListEmptyTests.cb_emptyR
  s&   € ØˆÔØ×Ò˜˜SÑ!Ô!Ð!Ð!Ð!rA   c                ó<   — |                       | j        d¦  «         d S )NzCallback was never run.)rc   r¼  rŽ   s    r?   r  zDeferredListEmptyTests.tearDownV
  s    € Ø�Š˜Ô(Ð*CÑDÔDÐDÐDÐDrA   Nr„   )rÀ  rÁ  r4   rN   )rH   rI   rJ   r�   r¿  r¾  r  rK   rA   r?   rº  rº  I
  sj   € € € € € ðð ð ð ð&ð &ð &ð &ð
"ð "ð "ð "ðEð Eð Eð Eð Eð ErA   rº  c                  ón   — e Zd Zdd„Zdd„Zdd„Zdd„Zdd	„Zdd
„Zdd„Z	dd„Z
dd„Zdd„Zdd„Zdd„ZdS )ÚOtherPrimitivesTestsrs   r8   r4   rN   c                ó&   — | xj         dz  c_         d S rK  ©Úcounter©rf   rs   s     r?   Ú_incrzOtherPrimitivesTests._incr[
  s   € ØˆŒ˜ÑˆŒˆˆrA   c                ó   — d| _         d S r‘   rÇ  rŽ   s    r?   r�   zOtherPrimitivesTests.setUp^
  s   € ØˆŒˆˆrA   c                ó  ‡
— t          ¦   «         }|                     ¦   «                              | j        ¦  «         |                      |j        ¦  «         |                      | j        d¦  «         |                     ¦   «                              | j        ¦  «         |                      |j        ¦  «         |                      | j        d¦  «         |                     ¦   «          |                      |j        ¦  «         |                      | j        d¦  «         |                     ¦   «          |  	                    |j        ¦  «         |                      | j        d¦  «         |  
                    t          |j        ¦  «         t          ¦   «         }t          ¦   «         }t          ¦   «         }d Š
ddˆ
fd„}|                     |||¬¦  «        }|                      |j        ¦  «         |                      ‰
|¦  «         |                     |¦  «         |                     ¦   «                              | j        ¦  «         |                      |j        ¦  «         |                      | j        d¦  «         |                     |¦  «         |                      ‰
|¦  «         |                      |j        ¦  «         |                      | j        d	¦  «         |                     ¦   «                              |¦  «        }|                     ¦   «          |                      ‰
t&          ¦  «         |                      t)          t&          ‰
¦  «        j        t,          j        ¦  «         |                     ¦   «          |  	                    |j        ¦  «         dd„}dd„}	t1          |                     |¦  «        t          t2                   ¦  «         t1          |                     |	¦  «        t          t2                   ¦  «         d S )Nr]   rÅ   ÚresultValuer8   ÚreturnValuer4   c                ó   •— | Š|S r<   rK   )rÍ  rÎ  rs   s     €r?   Úhelperz-OtherPrimitivesTests.testLock.<locals>.helper|
  s   ø€ à ˆFØÐrA   )rÍ  rÎ  r÷  rŸ  c                 ó*   — t          j        d¦  «        S rý  ©r   r&  rK   rA   r?   r¡  z1OtherPrimitivesTests.testLock.<locals>.returnsIntš
  s   € Ý”= Ñ#Ô#Ð#rA   r;  c               “  ó
   K  — dS rK  rK   rK   rA   r?   ÚreturnsCoroIntz5OtherPrimitivesTests.testLock.<locals>.returnsCoroInt�
  r   rA   r<   )rÍ  r8   rÎ  r8   r4   r8   )r4   rŸ  r¡  )r$   Úacquirer    rÊ  rc   Úlockedra   rÈ  Úreleaser	  r©  r’  Úrunr8   r!   rR   rC  r   r:  r0   r   rß   r   r   r   r;  )rf   ÚlockÚfirstUniqueÚsecondUniqueÚcontrolDeferredrÐ  ÚresultDeferredr)  r¡  rÔ  rs   s             @r?   ÚtestLockzOtherPrimitivesTests.testLocka
  sg  ø€ Ý‰~Œ~ˆØ�Š‰Œ×"Ò" 4¤:Ñ.Ô.Ð.Ø�Š˜œÑ$Ô$Ð$Ø×Ò˜œ qÑ)Ô)Ð)à�Š‰Œ×"Ò" 4¤:Ñ.Ô.Ð.Ø�Š˜œÑ$Ô$Ð$Ø×Ò˜œ qÑ)Ô)Ð)à�Š‰ŒˆØ�Š˜œÑ$Ô$Ð$Ø×Ò˜œ qÑ)Ô)Ð)à�Š‰ŒˆØ×Ò˜œÑ%Ô%Ð%Ø×Ò˜œ qÑ)Ô)Ð)à×Ò�) T¤XÑ.Ô.Ð.å‘h”hˆÝ‘x”xˆå,4©J¬Jˆà#'ˆð	ð 	ð 	ð 	ð 	ð 	ð 	ð
 ŸšØ ¸ð "ñ 
ô 
ˆð 	�Š˜œÑ$Ô$Ð$Ø×Ò˜ Ñ-Ô-Ð-à×"Ò" 6Ñ*Ô*Ð*à�Š‰Œ×"Ò" 4¤:Ñ.Ô.Ð.Ø�Š˜œÑ$Ô$Ð$Ø×Ò˜œ qÑ)Ô)Ð)à× Ò  Ñ.Ô.Ð.Ø×Ò˜ Ñ.Ô.Ð.Ø�Š˜œÑ$Ô$Ð$Ø×Ò˜œ qÑ)Ô)Ð)à�LŠL‰NŒN×"Ò" 6Ñ*Ô*ˆØ	�Š‰
Œ
ˆ
Ø×Ò˜f¥gÑ.Ô.Ð.Ø×Ò��g vÑ.Ô.Ô3µUÔ5IÑJÔJÐJà�Š‰ŒˆØ×Ò˜œÑ%Ô%Ð%ð	$ð 	$ð 	$ð 	$ð	ð 	ð 	ð 	õ 	�D—H’H˜ZÑ(Ô(­(µ3¬-Ñ8Ô8Ð8Ý�D—H’H˜^Ñ,Ô,­hµs¬mÑ<Ô<Ð<Ð<Ð<rA   c                óª   ‡ — dˆ fd„}t          ¦   «         }|                     ¦   «         }|                     |¦  «         |                     ¦   «          dS )zŠ
        When canceling a L{Deferred} from a L{DeferredLock} that already
        has the lock, the cancel should have no effect.
        r2   r0   r4   rN   c                ó2   •— ‰                      d¦  «         d S ©NzUnexpected errback call!©r-  ©r2   rf   s    €r?   ÚfailOnErrbackzHOtherPrimitivesTests.test_cancelLockAfterAcquired.<locals>.failOnErrback©
  ó   ø€ Ø�IŠIÐ0Ñ1Ô1Ð1Ð1Ð1rA   N©r2   r0   r4   rN   )r$   rÕ  r_   r   )rf   rä  rÙ  r)  s   `   r?   Útest_cancelLockAfterAcquiredz1OtherPrimitivesTests.test_cancelLockAfterAcquired£
  s\   ø€ ð	2ð 	2ð 	2ð 	2ð 	2ð 	2õ ‰~Œ~ˆØ�LŠL‰NŒNˆØ	�Š�]Ñ#Ô#Ð#Ø	�Š‰
Œ
ˆ
ˆ
ˆ
rA   c                óÚ   — t          ¦   «         }|                     ¦   «          |                     ¦   «         }|                     ¦   «          |                      |t          j        ¦  «         dS )z×
        When canceling a L{Deferred} from a L{DeferredLock} that does not
        yet have the lock (i.e., the L{Deferred} has not fired), the cancel
        should cause a L{defer.CancelledError} failure.
        N)r$   rÕ  r   ri   r   r   )rf   rÙ  r)  s      r?   Útest_cancelLockBeforeAcquiredz2OtherPrimitivesTests.test_cancelLockBeforeAcquired±
  sS   € õ ‰~Œ~ˆØ�Š‰ŒˆØ�LŠL‰NŒNˆØ	�Š‰
Œ
ˆ
Ø×#Ò# A¥uÔ';Ñ<Ô<Ð<Ð<Ð<rA   c                ó$  ‡‡‡— d}t          |¦  «        }t          ¦   «         Šd Šdˆˆfd„}g }t          ¦   «         }|                     ||¬¦  «        }|                     |j        ¦  «         |                     | j        ¦  «         |                      |g ¦  «         |                      ‰|¦  «         ‰                     d ¦  «         |  	                    | 
                    ¦   «         ¦  «         |                      | j        d¦  «         d	| _        t          dd|z   ¦  «        D ]I}|                     ¦   «                              | j        ¦  «         |                      | j        |¦  «         ŒJg Šdˆfd„}dˆfd„}	|                     ¦   «                              ||	¦  «        }
|
                     ¦   «          |                      ‰dg¦  «         |                     ¦   «                              | j        ¦  «         |                      | j        |¦  «         |                     ¦   «          |                      | j        |dz   ¦  «         t          dd|z   ¦  «        D ]4}|                     ¦   «          |                      | j        |dz   ¦  «         Œ5d S )Nr÷  Úargr8   r4   rÔ  c                ó   •— | Š‰S r<   rK   )rë  rÜ  Ú	helperArgs    €€r?   rÐ  z2OtherPrimitivesTests.testSemaphore.<locals>.helperÅ
  s   ø€ àˆIØ"Ð"rA   )rë  r]   r   rB  rN   c                ó2   •— ‰                      d¦  «         d S r  rÓ   ©rB  r%  s    €r?   r-  z0OtherPrimitivesTests.testSemaphore.<locals>.failÜ
  s   ø€ Ø�NŠN˜5Ñ!Ô!Ð!Ð!Ð!rA   c                ó2   •— ‰                      d¦  «         d S r  rÓ   rï  s    €r?   r&  z3OtherPrimitivesTests.testSemaphore.<locals>.succeedß
  s   ø€ Ø�NŠN˜4Ñ Ô Ð Ð Ð rA   T)rë  r8   r4   rÔ  )rB  r8   r4   rN   )r&   r!   r8   rØ  r    r`   rÊ  ra   rR   r¡   rz  rÈ  ry  rÕ  r­   r   r×  )rf   ÚNÚsemrÐ  rl  ÚuniqueObjectrÝ  Úir-  r&  r)  rÜ  rí  r%  s              @@@r?   ÚtestSemaphorez"OtherPrimitivesTests.testSemaphore½
  s�  øøø€ ØˆÝ Ñ"Ô"ˆå*2©*¬*ˆà ˆ	ð	#ð 	#ð 	#ð 	#ð 	#ð 	#ð 	#ð
 !#ˆÝ‘x”xˆØŸš ¨\˜Ñ:Ô:ˆØ×"Ò" 7¤>Ñ2Ô2Ð2Ø×"Ò" 4¤:Ñ.Ô.Ð.Ø×Ò˜ "Ñ%Ô%Ð%Ø×Ò˜ LÑ1Ô1Ð1Ø× Ò  Ñ&Ô&Ð&Ø×Ò˜'Ÿ+š+™-œ-Ñ(Ô(Ð(Ø×Ò˜œ qÑ)Ô)Ð)àˆŒÝ�q˜!˜a™%‘”ð 	.ð 	.ˆAØ�KŠK‰MŒM×%Ò% d¤jÑ1Ô1Ð1Ø×Ò˜Tœ\¨1Ñ-Ô-Ð-Ð-àˆð	"ð 	"ð 	"ð 	"ð 	"ð 	"ð	!ð 	!ð 	!ð 	!ð 	!ð 	!ð �KŠK‰MŒM×&Ò& t¨WÑ5Ô5ˆØ	�Š‰
Œ
ˆ
Ø×Ò˜ 4 &Ñ)Ô)Ð)à�Š‰Œ×!Ò! $¤*Ñ-Ô-Ð-Ø×Ò˜œ qÑ)Ô)Ð)à�Š‰ŒˆØ×Ò˜œ q¨1¡uÑ-Ô-Ð-å�q˜!˜a™%‘”ð 	2ð 	2ˆAØ�KŠK‰MŒMˆMØ×Ò˜Tœ\¨1¨q©5Ñ1Ô1Ð1Ð1ð	2ð 	2rA   c                óŠ   — |                       t          t          d¦  «         |                       t          t          d¦  «         dS )zz
        If the token count passed to L{DeferredSemaphore} is less than one
        then L{ValueError} is raised.
        r   rÂ  N)r©  rY  r&   rŽ   s    r?   Útest_semaphoreInvalidTokensz0OtherPrimitivesTests.test_semaphoreInvalidTokensð
  s<   € ð
 	×Ò�*Õ&7¸Ñ;Ô;Ð;Ø×Ò�*Õ&7¸Ñ<Ô<Ð<Ð<Ð<rA   c                ó¬   ‡ — dˆ fd„}t          d¦  «        }|                     ¦   «         }|                     |¦  «         |                     ¦   «          dS )	z”
        When canceling a L{Deferred} from a L{DeferredSemaphore} that
        already has the semaphore, the cancel should have no effect.
        r2   r0   r4   rN   c                ó2   •— ‰                      d¦  «         d S rá  râ  rã  s    €r?   rä  zMOtherPrimitivesTests.test_cancelSemaphoreAfterAcquired.<locals>.failOnErrbackþ
  rå  rA   r]   Nræ  )r&   rÕ  r_   r   )rf   rä  rò  r)  s   `   r?   Ú!test_cancelSemaphoreAfterAcquiredz6OtherPrimitivesTests.test_cancelSemaphoreAfterAcquiredø
  s`   ø€ ð	2ð 	2ð 	2ð 	2ð 	2ð 	2õ   Ñ"Ô"ˆØ�KŠK‰MŒMˆØ	�Š�]Ñ#Ô#Ð#Ø	�Š‰
Œ
ˆ
ˆ
ˆ
rA   c                óÜ   — t          d¦  «        }|                     ¦   «          |                     ¦   «         }|                     ¦   «          |                      |t          j        ¦  «         dS )zá
        When canceling a L{Deferred} from a L{DeferredSemaphore} that does
        not yet have the semaphore (i.e., the L{Deferred} has not fired),
        the cancel should cause a L{defer.CancelledError} failure.
        r]   N)r&   rÕ  r   ri   r   r   )rf   rò  r)  s      r?   Ú"test_cancelSemaphoreBeforeAcquiredz7OtherPrimitivesTests.test_cancelSemaphoreBeforeAcquired  sW   € õ   Ñ"Ô"ˆØ�Š‰ŒˆØ�KŠK‰MŒMˆØ	�Š‰
Œ
ˆ
Ø×#Ò# A¥uÔ';Ñ<Ô<Ð<Ð<Ð<rA   c                ó¼  — d\  }}t          ||¦  «        }g }t          |¦  «        D ].}|                     ¦   «                              |j        ¦  «         Œ/|                      t          j        |j        ¦  «         t          |¦  «        D ]J}|                     |¦  «         |  	                    |t          t          |dz   ¦  «        ¦  «        ¦  «         ŒKt          |¦  «        D ]J}|                     ||z   ¦  «         |  	                    |t          t          |¦  «        ¦  «        ¦  «         ŒK|                      t          j        |j        d ¦  «         g }t          |¦  «        D ]e}|                     ¦   «                              |j        ¦  «         |  	                    |t          t          |||z   dz   ¦  «        ¦  «        ¦  «         Œft          ¦   «         }g }t          |¦  «        D ].}|                     ¦   «                              |j        ¦  «         Œ/t          |¦  «        D ]}|                     |¦  «         Œ|  	                    |t          t          |¦  «        ¦  «        ¦  «         t          d¬¦  «        }|                      t          j        |j        d ¦  «         t          d¬¦  «        }|                      t          j        |j        ¦  «         d S )N)rÅ   rÅ   r]   r   )Úsize)Úbacklog)r%   ry  Úgetr    r`   r©  r   ÚQueueUnderflowÚputra   ÚlistÚQueueOverflow)rf   rñ  ÚMÚqueueÚgottenrô  s         r?   Ú	testQueuezOtherPrimitivesTests.testQueue  sƒ  € Ø‰ˆˆ1Ý$1°!°QÑ$7Ô$7ˆàˆå�q‘”ð 	3ð 	3ˆAØ�IŠI‰KŒK×#Ò# F¤MÑ2Ô2Ð2Ð2Ø×Ò�%Ô.°´	Ñ:Ô:Ð:å�q‘”ð 	9ð 	9ˆAØ�IŠI�a‰LŒLˆLØ×Ò˜V¥T­%°°A±©,¬,Ñ%7Ô%7Ñ8Ô8Ð8Ð8Ý�q‘”ð 	5ð 	5ˆAØ�IŠI�a˜!‘eÑÔÐØ×Ò˜V¥T­%°©(¬(¡^¤^Ñ4Ô4Ð4Ð4Ø×Ò�%Ô-¨u¬y¸$Ñ?Ô?Ð?àˆÝ�q‘”ð 	@ð 	@ˆAØ�IŠI‰KŒK×#Ò# F¤MÑ2Ô2Ð2Ø×Ò˜V¥T­%°°1°q±5¸1±9Ñ*=Ô*=Ñ%>Ô%>Ñ?Ô?Ð?Ð?å‘”ˆØˆÝ�q‘”ð 	3ð 	3ˆAØ�IŠI‰KŒK×#Ò# F¤MÑ2Ô2Ð2Ð2Ý�q‘”ð 	ð 	ˆAØ�IŠI�a‰LŒLˆLˆLØ×Ò˜¥¥e¨A¡h¤h¡¤Ñ0Ô0Ð0å 1Ð%Ñ%Ô%ˆØ×Ò�%Ô-¨u¬y¸$Ñ?Ô?Ð?å aÐ(Ñ(Ô(ˆØ×Ò�%Ô.°´	Ñ:Ô:Ð:Ð:Ð:rA   c                óÔ   ‡ — dˆ fd„}t          ¦   «         }|                     ¦   «         }|                     |¦  «         |                     d¦  «         |                     ¦   «          dS )z‹
        When canceling a L{Deferred} from a L{DeferredQueue} that already has
        a result, the cancel should have no effect.
        r2   r0   r4   rN   c                ó2   •— ‰                      d¦  «         d S rá  râ  rã  s    €r?   rä  zOOtherPrimitivesTests.test_cancelQueueAfterSynchronousGet.<locals>.failOnErrback=  rå  rA   Nræ  )r%   r   r_   r  r   )rf   rä  r  r)  s   `   r?   Ú#test_cancelQueueAfterSynchronousGetz8OtherPrimitivesTests.test_cancelQueueAfterSynchronousGet7  sk   ø€ ð	2ð 	2ð 	2ð 	2ð 	2ð 	2õ &3¡_¤_ˆØ�IŠI‰KŒKˆØ	�Š�]Ñ#Ô#Ð#Ø�	Š	�$‰ŒˆØ	�Š‰
Œ
ˆ
ˆ
ˆ
rA   c                ól  ‡ ‡— t          ¦   «         Š‰                     ¦   «         }|                     ¦   «          ‰                      |t          j        ¦  «         dˆˆ fd„}|                     |¦  «         g }|                     |j        ¦  «         ‰                      t          |¦  «        d¦  «         dS )	a  
        When canceling a L{Deferred} from a L{DeferredQueue} that does not
        have a result (i.e., the L{Deferred} has not fired), the cancel
        causes a L{defer.CancelledError} failure. If the queue has a result
        later on, it doesn't try to fire the deferred.
        Úignorer8   r4   rÔ  c                óˆ   •— ‰                      d ¦  «         ‰                     ¦   «                              ‰j        d ¦  «        S r<   )r  r   r    rq   )r  r  rf   s    €€r?   r¼   z9OtherPrimitivesTests.test_cancelQueueAfterGet.<locals>.cbR  s4   ø€ ð �IŠI�d‰OŒOˆOØ—9’9‘;”;×*Ò*¨4¬=¸$Ñ?Ô?Ð?rA   r]   N)r  r8   r4   rÔ  )
r%   r   r   ri   r   r   r    r`   ra   rb   )rf   r)  r¼   Údoner  s   `   @r?   Útest_cancelQueueAfterGetz-OtherPrimitivesTests.test_cancelQueueAfterGetF  s»   øø€ õ &3¡_¤_ˆØ�IŠI‰KŒKˆØ	�Š‰
Œ
ˆ
Ø×#Ò# A¥uÔ';Ñ<Ô<Ð<ð	@ð 	@ð 	@ð 	@ð 	@ð 	@ð 	@ð 	
�Š�bÑÔÐØˆØ	�Š�d”kÑ"Ô"Ð"Ø×Ò�˜T™œ AÑ&Ô&Ð&Ð&Ð&rA   Nr  r„   )rH   rI   rJ   rÊ  r�   rÞ  rç  ré  rõ  r÷  rú  rü  r  r  r  rK   rA   r?   rÅ  rÅ  Z
  s  € € € € € ðð ð ð ðð ð ð ð@=ð @=ð @=ð @=ðDð ð ð ð
=ð 
=ð 
=ð 
=ð12ð 12ð 12ð 12ðf=ð =ð =ð =ðð ð ð ð
=ð 
=ð 
=ð 
=ð#;ð #;ð #;ð #;ðJð ð ð ð'ð 'ð 'ð 'ð 'ð 'rA   rÅ  c                  óZ   — e Zd ZdZdd„Zdd„Zdd„Zdd„Zdd	„Zdd
„Z	dd„Z
dd„Zdd„ZdS )ÚDeferredFilesystemLockTestsz8
    Test the behavior of L{DeferredFilesystemLock}
    r4   rN   c                ó†   — t          ¦   «         | _        t          |                      ¦   «         | j        ¬¦  «        | _        d S )N)Ú	scheduler)r,   Úclockr"   ÚmktemprÙ  rŽ   s    r?   r�   z!DeferredFilesystemLockTests.setUpc  s/   € Ý‘W”WˆŒ
Ý*¨4¯;ª;©=¬=ÀDÄJÐOÑOÔOˆŒ	ˆ	ˆ	rA   rÔ  c                ó8   — | j                              d¬¦  «        S )zI
        Test that the lock can be acquired when no lock is held
        r]   ©Útimeout)rÙ  ÚdeferUntilLockedrŽ   s    r?   Útest_waitUntilLockedWithNoLockz:DeferredFilesystemLockTests.test_waitUntilLockedWithNoLockg  s   € ð Œy×)Ò)°!Ð)Ñ4Ô4Ð4rA   c                ó  — |                       | j                             ¦   «         ¦  «         | j                             d¬¦  «        }|                      |t          j        ¦  «         | j                             dgdz  ¦  «         |S )zs
        Test that the lock can not be acquired when the lock is held
        for longer than the timeout.
        g      @r  r]   r‡  )rc   rÙ  r  ÚassertFailurer   ÚTimeoutErrorr  Úpumpr>  s     r?   Ú%test_waitUntilLockedWithTimeoutLockedzADeferredFilesystemLockTests.test_waitUntilLockedWithTimeoutLockedm  sr   € ð
 	�Š˜œ	ŸšÑ(Ô(Ñ)Ô)Ð)àŒI×&Ò&¨sÐ&Ñ3Ô3ˆØ×Ò˜1�eÔ0Ñ1Ô1Ð1àŒ
�Š˜˜˜b™Ñ!Ô!Ð!àˆrA   c                óR  ‡ — d	ˆ fd„}‰                       ‰ j                             ¦   «         ¦  «         ‰ j                             d‰ j        j        ¦  «         ‰ j                             d¬¦  «        }|                     |¦  «         ‰ j                             dgdz  ¦  «         |S )
z|
        Test that a lock can be acquired while a lock is held
        but the lock is unlocked before our timeout.
        r2   r0   r4   rN   c                óp   •— |                       t          j        ¦  «         ‰                     d¦  «         d S )NzShould not have timed out)rW  r   r  r-  rã  s    €r?   Ú	onTimeoutzVDeferredFilesystemLockTests.test_waitUntilLockedWithTimeoutUnlocked.<locals>.onTimeout�  s1   ø€ Ø�FŠF•5Ô%Ñ&Ô&Ð&Ø�IŠIÐ1Ñ2Ô2Ð2Ð2Ð2rA   r]   r‡  r  ræ  )rc   rÙ  r  Ú	callLaterÚunlockr  r_   r  )rf   r#  r)  s   `  r?   Ú'test_waitUntilLockedWithTimeoutUnlockedzCDeferredFilesystemLockTests.test_waitUntilLockedWithTimeoutUnlocked{  s§   ø€ ð	3ð 	3ð 	3ð 	3ð 	3ð 	3ð 	�Š˜œ	ŸšÑ(Ô(Ñ)Ô)Ð)àŒ
×Ò˜Q ¤	Ô 0Ñ1Ô1Ð1ØŒI×&Ò&¨rÐ&Ñ2Ô2ˆØ	�Š�YÑÔÐàŒ
�Š˜˜˜b™Ñ!Ô!Ð!àˆrA   c                óˆ   — t          |                      ¦   «         ¦  «        }|                      |j        t          ¦  «         dS )zE
        Test that the default scheduler is set up properly.
        N)r"   r  ra   Ú
_schedulerr   ©rf   rÙ  s     r?   Útest_defaultSchedulerz1DeferredFilesystemLockTests.test_defaultScheduler�  s7   € õ & d§k¢k¡m¤mÑ4Ô4ˆà×Ò˜œ­'Ñ2Ô2Ð2Ð2Ð2rA   c                óZ  — | j                               ¦   «          | j                             d| j         j        ¦  «         | j                              ¦   «         }| j                              ¦   «         }|                      |t          j        ¦  «         | j                             d¦  «         |S )z|
        Test that an appropriate exception is raised when attempting
        to use deferUntilLocked concurrently.
        r]   )	rÙ  r  r$  r%  r  r  r   ÚAlreadyTryingToLockErrorÚadvancerF  s      r?   Útest_concurrentUsagez0DeferredFilesystemLockTests.test_concurrentUsage—  s�   € ð
 	Œ	�ŠÑÔÐØŒ
×Ò˜Q ¤	Ô 0Ñ1Ô1Ð1àŒY×'Ò'Ñ)Ô)ˆØŒY×'Ò'Ñ)Ô)ˆà×Ò˜2�uÔ=Ñ>Ô>Ð>àŒ
×Ò˜1ÑÔÐàˆ	rA   c                ó   ‡ — dˆ fd„}‰ j                               ¦   «          ‰ j                             d‰ j         j        ¦  «         ‰ j                              ¦   «         }|                     |¦  «         ‰ j                             d¦  «         |S )zO
        Test that a DeferredFilesystemLock can be used multiple times
        r  r8   r4   rÔ  c                ól   •— ‰j                              ¦   «          ‰j                              ¦   «         }|S r<   )rÙ  r%  r  )r  r)  rf   s     €r?   ÚlockAquiredzDDeferredFilesystemLockTests.test_multipleUsages.<locals>.lockAquired­  s/   ø€ ØŒI×ÒÑÔÐØ”	×*Ò*Ñ,Ô,ˆAØˆHrA   r]   )r  r8   r4   rÔ  )rÙ  r  r$  r%  r  r    r-  )rf   r1  r)  s   `  r?   Útest_multipleUsagesz/DeferredFilesystemLockTests.test_multipleUsages¨  s’   ø€ ð
	ð 	ð 	ð 	ð 	ð 	ð
 	Œ	�ŠÑÔÐØŒ
×Ò˜Q ¤	Ô 0Ñ1Ô1Ð1àŒI×&Ò&Ñ(Ô(ˆØ	�Š�kÑ"Ô"Ð"àŒ
×Ò˜1ÑÔÐàˆrA   c                ó~  — | j                               ¦   «          | j                              ¦   «         }| j         j        }|€J ‚|                     ¦   «          |                      |                     ¦   «         ¦  «         |                      | j         j        ¦  «         |                      |t          j	        ¦  «         dS )z°
        When cancelling a L{Deferred} returned by
        L{DeferredFilesystemLock.deferUntilLocked}, the
        L{DeferredFilesystemLock._tryLockCall} is cancelled.
        N)
rÙ  r  Ú_tryLockCallr   r	  Úactiver¡   r  r   r   )rf   rL   ÚtryLockCalls      r?   Útest_cancelDeferUntilLockedz7DeferredFilesystemLockTests.test_cancelDeferUntilLocked¼  s§   € ð 	Œ	�ŠÑÔÐØ”9×-Ò-Ñ/Ô/ˆØ”iÔ,ˆØÐ&Ð&Ð&Ø�ŠÑÔÐØ×Ò˜×+Ò+Ñ-Ô-Ñ.Ô.Ð.Ø×Ò˜$œ)Ô0Ñ1Ô1Ð1Ø×Ò˜X¥uÔ';Ñ<Ô<Ð<Ð<Ð<rA   c                ó‚  — | j                               ¦   «          | j                              d¬¦  «        }| j         j        }|€J ‚|                     ¦   «          |                      |                     ¦   «         ¦  «         |                      | j         j        ¦  «         |                      |t          j	        ¦  «         dS )z®
        When cancel a L{Deferred} returned by
        L{DeferredFilesystemLock.deferUntilLocked}, if the timeout is
        set, the timeout call will be cancelled.
        r]   r  N)
rÙ  r  Ú_timeoutCallr   r	  r5  r¡   r  r   r   )rf   rL   ÚtimeoutCalls      r?   Ú&test_cancelDeferUntilLockedWithTimeoutzBDeferredFilesystemLockTests.test_cancelDeferUntilLockedWithTimeoutË  s¬   € ð 	Œ	�ŠÑÔÐØ”9×-Ò-°aÐ-Ñ8Ô8ˆØ”iÔ,ˆØÐ&Ð&Ð&Ø�ŠÑÔÐØ×Ò˜×+Ò+Ñ-Ô-Ñ.Ô.Ð.Ø×Ò˜$œ)Ô0Ñ1Ô1Ð1Ø×Ò˜X¥uÔ';Ñ<Ô<Ð<Ð<Ð<rA   Nr„   )r4   rÔ  )rH   rI   rJ   rj   r�   r  r   r&  r*  r.  r2  r7  r;  rK   rA   r?   r  r  ^  sÖ   € € € € € ðð ðPð Pð Pð Pð5ð 5ð 5ð 5ðð ð ð ðð ð ð ð(3ð 3ð 3ð 3ðð ð ð ð"ð ð ð ð(=ð =ð =ð =ð=ð =ð =ð =ð =ð =rA   r  Úvr8   ÚtÚfloatr²   c                ó   — dS )zj
    Private function to be used to pass as an alternate onTimeoutCancel value
    to timeoutDeferred
    Ú
OVERRIDDENrK   )r<  r=  s     r?   Ú_overrideFuncrA  Û  s	   € ð
 ˆ<rA   c                  ó¢   — e Zd ZdZdd„Zdd„Zdd„Zdd„Zdd„Zdd	„Z	dd
„Z
dd„Zdd„Zdd„Zdd„Zdd„Zdd„Zdd„Zdd„Zdd„Zdd„Zdd„ZdS )ÚDeferredAddTimeoutTestsz7
    Tests for the function L{Deferred.addTimeout}
    r4   rN   c                ó  — t          ¦   «         }|                     dt          ¦   «         ¦  «         |                     d„ ¦  «         |                     d¦  «         |                      d|                      |¦  «        ¦  «         dS )zu
        L{Deferred.addTimeout} returns its own L{Deferred} so it
        can be called in a callback chain.
        r„  c                ó   — dS )Nr  rK   r6  s    r?   rö   z?DeferredAddTimeoutTests.test_timeoutChainable.<locals>.<lambda>ï  s   €  € rA   Nr  )r!   Ú
addTimeoutr,   r    rR   ra   r  r>  s     r?   Útest_timeoutChainablez-DeferredAddTimeoutTests.test_timeoutChainableè  sw   € õ
 %™JœJˆØ	�Š�Q�™œÑ Ô Ð Ø	�ŠÐ&Ð&Ñ'Ô'Ð'Ø	�
Š
�4ÑÔÐØ×Ò˜ ×!5Ò!5°aÑ!8Ô!8Ñ9Ô9Ð9Ð9Ð9rA   c                óœ  ‡‡— t          ¦   «         }t          ¦   «         }|                     d|¦  «         t          ¦   «         ŠdŠd	ˆˆfd„}|                     |¦  «         |                     d¦  «         |                      d‰¦  «         |                      ‰d¦  «         |                     d¦  «         |                      ‰¦  «         dS )
zÊ
        The L{Deferred} callbacks with the result if it succeeds before
        the timeout. No cancellation happens after the callback either,
        which could also cancel inner deferreds.
        r‡  Nrl  r²   r4   rÔ  c                ó   •— | Š‰S r<   rK   ©rl  ÚdCallbackedÚinnerDeferreds    €€r?   Ú
onCallbackzKDeferredAddTimeoutTests.test_successResultBeforeTimeout.<locals>.onCallback  ó   ø€ à!ˆKØ Ð rA   rˆ  ©rl  r²   r4   rÔ  )	r,   r!   rF  r    rR   ÚassertIsNotra   r-  r  ©rf   r  r)  rM  rK  rL  s       @@r?   Útest_successResultBeforeTimeoutz7DeferredAddTimeoutTests.test_successResultBeforeTimeoutó  sá   øø€ õ ‘”ˆÝ#™:œ:ˆØ	�Š�R˜ÑÔÐõ )1©
¬
ˆØ%)ˆð	!ð 	!ð 	!ð 	!ð 	!ð 	!ð 	!ð
 	
�Š�jÑ!Ô!Ð!Ø	�
Š
�9ÑÔÐð 	×Ò˜˜{Ñ+Ô+Ð+Ø×Ò˜ iÑ0Ô0Ð0ð 	�Š�bÑÔÐØ×Ò˜MÑ*Ô*Ð*Ð*Ð*rA   c                óª  ‡‡— t          ¦   «         }t          ¦   «         }|                     d|t          ¬¦  «         t          ¦   «         ŠdŠd
ˆˆfd„}|                     |¦  «         |                     d¦  «         |                      d‰¦  «         |                      ‰d¦  «         |                     d	¦  «         |  	                    ‰¦  «         dS )a  
        The L{Deferred} callbacks with the result if it succeeds before
        the timeout, even if a custom C{onTimeoutCancel} function is provided.
        No cancellation happens after the callback either, which could also
        cancel inner deferreds.
        r‡  ©ÚonTimeoutCancelNrl  r²   r4   rÔ  c                ó   •— | Š‰S r<   rK   rJ  s    €€r?   rM  zQDeferredAddTimeoutTests.test_successResultBeforeTimeoutCustom.<locals>.onCallback$  rN  rA   rˆ  rO  )
r,   r!   rF  rA  r    rR   rP  ra   r-  r  rQ  s       @@r?   Ú%test_successResultBeforeTimeoutCustomz=DeferredAddTimeoutTests.test_successResultBeforeTimeoutCustom  så   øø€ õ ‘”ˆÝ#™:œ:ˆØ	�Š�R˜µˆÑ>Ô>Ð>õ )1©
¬
ˆØ%)ˆð	!ð 	!ð 	!ð 	!ð 	!ð 	!ð 	!ð
 	
�Š�jÑ!Ô!Ð!Ø	�
Š
�9ÑÔÐð 	×Ò˜˜{Ñ+Ô+Ð+Ø×Ò˜ iÑ0Ô0Ð0ð 	�Š�bÑÔÐØ×Ò˜MÑ*Ô*Ð*Ð*Ð*rA   c                óÖ  ‡‡— t          ¦   «         }t          ¦   «         }|                     d|¦  «         t          ¦   «         ŠdŠt          d¦  «        }d
ˆˆfd„}|                     |¦  «         |                     |¦  «         ‰€J ‚|                      ‰t          ¦  «         |                      ‰j	        |¦  «         | 
                    d	¦  «         |                      ‰¦  «         dS )zÆ
        The L{Deferred} errbacks with the failure if it fails before the
        timeout. No cancellation happens after the errback either, which
        could also cancel inner deferreds.
        r‡  Nr-  r2   r0   r4   rÔ  c                ó   •— | Š‰S r<   rK   ©r2   Ú
dErrbackedrL  s    €€r?   Ú	onErrbackzDDeferredAddTimeoutTests.test_failureBeforeTimeout.<locals>.onErrbackF  ó   ø€ àˆJØ Ð rA   rˆ  ©r2   r0   r4   rÔ  )r,   r!   rF  rY  r_   r®   r:  r0   rq   re   r-  r  ©rf   r  r)  rr   r\  r[  rL  s        @@r?   Útest_failureBeforeTimeoutz1DeferredAddTimeoutTests.test_failureBeforeTimeout6  sû   øø€ õ ‘”ˆÝ$™JœJˆØ	�Š�R˜ÑÔÐõ )1©
¬
ˆØ(,ˆ
Ý˜6Ñ"Ô"ˆð	!ð 	!ð 	!ð 	!ð 	!ð 	!ð 	!ð
 	
�Š�YÑÔÐØ	�	Š	�%ÑÔÐð Ð%Ð%Ð%Ø×Ò˜j­'Ñ2Ô2Ð2Ø�Š�jÔ&¨Ñ.Ô.Ð.ð 	�Š�bÑÔÐØ×Ò˜MÑ*Ô*Ð*Ð*Ð*rA   c                óä  ‡‡— t          ¦   «         }t          ¦   «         }|                     d|t          ¬¦  «         t          ¦   «         ŠdŠt	          d¦  «        }dˆˆfd	„}|                     |¦  «         |                     |¦  «         ‰€J ‚|                      ‰t          ¦  «         |  	                    ‰j
        |¦  «         |                     d
¦  «         |                      ‰¦  «         dS )a  
        The L{Deferred} errbacks with the failure if it fails before the
        timeout, even if using a custom C{onTimeoutCancel} function.
        No cancellation happens after the errback either, which could also
        cancel inner deferreds.
        r‡  rT  Nr-  r2   r0   r4   rÔ  c                ó   •— | Š‰S r<   rK   rZ  s    €€r?   r\  zJDeferredAddTimeoutTests.test_failureBeforeTimeoutCustom.<locals>.onErrbackj  r]  rA   rˆ  r^  )r,   r!   rF  rA  rY  r_   r®   r:  r0   rq   re   r-  r  r_  s        @@r?   Útest_failureBeforeTimeoutCustomz7DeferredAddTimeoutTests.test_failureBeforeTimeoutCustomY  sÿ   øø€ õ ‘”ˆÝ$™JœJˆØ	�Š�R˜µˆÑ>Ô>Ð>õ )1©
¬
ˆØ(,ˆ
Ý˜6Ñ"Ô"ˆð	!ð 	!ð 	!ð 	!ð 	!ð 	!ð 	!ð
 	
�Š�YÑÔÐØ	�	Š	�%ÑÔÐð Ð%Ð%Ð%Ø×Ò˜j­'Ñ2Ô2Ð2Ø�Š�jÔ&¨Ñ.Ô.Ð.ð 	�Š�bÑÔÐØ×Ò˜MÑ*Ô*Ð*Ð*Ð*rA   c                óþ   — t          ¦   «         }t          ¦   «         }|                     d|¦  «         |                      |¦  «         |                     d¦  «         |                      |t          j        ¦  «         dS )zŒ
        The L{Deferred} by default errbacks with a L{defer.TimeoutError}
        if it times out before callbacking or errbacking.
        r‡  rˆ  N)r,   r!   rF  r  r-  r  r   r  ©rf   r  r)  s      r?   Útest_timedOutz%DeferredAddTimeoutTests.test_timedOut}  so   € õ
 ‘”ˆÝ$™JœJˆØ	�Š�R˜ÑÔÐØ×Ò˜AÑÔÐà�Š�bÑÔÐà×Ò˜Q¥Ô 2Ñ3Ô3Ð3Ð3Ð3rA   c                ó  — t          ¦   «         }t          ¦   «         }|                     d|t          ¬¦  «         |                      |¦  «         |                     d¦  «         |                      d|                      |¦  «        ¦  «         dS )a1  
        If a custom C{onTimeoutCancel] function is provided, the
        L{Deferred} returns the custom function's return value if the
        L{Deferred} times out before callbacking or errbacking.
        The custom C{onTimeoutCancel} function can return a result instead of
        a failure.
        r‡  rT  rˆ  r@  N©r,   r!   rF  rA  r  r-  ra   r  re  s      r?   Útest_timedOutCustomz+DeferredAddTimeoutTests.test_timedOutCustom‹  s~   € õ ‘”ˆÝ$™JœJˆØ	�Š�R˜µˆÑ>Ô>Ð>Ø×Ò˜AÑÔÐà�Š�bÑÔÐà×Ò˜ t×';Ò';¸AÑ'>Ô'>Ñ?Ô?Ð?Ð?Ð?rA   c                ó  — t          ¦   «         }t          d„ ¦  «        }|                     d|¦  «         |                      |¦  «         |                     d¦  «         |                      |                      |¦  «        d¦  «         dS )z×
        If a cancellation function is provided when the L{Deferred} is
        initialized, the L{Deferred} returns the cancellation value's
        non-failure return value when the L{Deferred} times out.
        c                ó,   — |                       d¦  «        S )NúI was cancelled!rQ   rŒ  s    r?   rö   zLDeferredAddTimeoutTests.test_timedOutProvidedCancelSuccess.<locals>.<lambda>£  s   € ¨a¯jªjÐ9KÑ.LÔ.L€ rA   r‡  rˆ  rl  N)r,   r!   rF  r  r-  ra   r  re  s      r?   Ú"test_timedOutProvidedCancelSuccessz:DeferredAddTimeoutTests.test_timedOutProvidedCancelSuccessœ  sƒ   € õ ‘”ˆÝ#Ð$LÐ$LÑMÔMˆØ	�Š�R˜ÑÔÐØ×Ò˜AÑÔÐà�Š�bÑÔÐà×Ò˜×-Ò-¨aÑ0Ô0Ð2DÑEÔEÐEÐEÐErA   c                óR  ‡— t          ¦   «         }t          d¦  «        Št          ˆfd„¦  «        }|                     d|¦  «         |                      |¦  «         |                     d¦  «         |                      |t          ¦  «        }|                      |j        ‰¦  «         dS )zÛ
        If a cancellation function is provided when the L{Deferred} is
        initialized, the L{Deferred} returns the cancellation value's
        non-L{CanceledError} failure when the L{Deferred} times out.
        úwhat!c                ó.   •— |                       ‰¦  «        S r<   )r®   )r…  rr   s    €r?   rö   zLDeferredAddTimeoutTests.test_timedOutProvidedCancelFailure.<locals>.<lambda>³  s   ø€ ¨q¯yªy¸Ñ/?Ô/?€ rA   r‡  rˆ  N)	r,   rY  r!   rF  r  r-  r  rq   re   )rf   r  r)  r2   rr   s       @r?   Ú"test_timedOutProvidedCancelFailurez:DeferredAddTimeoutTests.test_timedOutProvidedCancelFailure«  s�   ø€ õ ‘”ˆÝ˜7Ñ#Ô#ˆÝ$Ð%?Ð%?Ð%?Ð%?Ñ@Ô@ˆØ	�Š�R˜ÑÔÐØ×Ò˜AÑÔÐà�Š�bÑÔÐà× Ò  ¥JÑ/Ô/ˆØ�Š�a”g˜uÑ%Ô%Ð%Ð%Ð%rA   c                óÊ  ‡‡— t          ¦   «         }t          ¦   «         }|                     d|¦  «         t          ¦   «         ŠdŠd	ˆˆfd„}|                     |¦  «         |                     ¦   «          ‰€J ‚|                      ‰t          ¦  «         |                      ‰j        t          j
        ¦  «         |                     d¦  «         |                      ‰¦  «         dS )
a-  
        If the L{Deferred} is manually cancelled before the timeout, it
        is not re-cancelled (no L{AlreadyCancelled} error, and also no
        canceling of inner deferreds), and the default C{onTimeoutCancel}
        function is not called, preserving the original L{CancelledError}.
        r‡  Nr2   r0   r4   rÔ  c                ó   •— | Š‰S r<   rK   ©r2   Ú	dCanceledrL  s    €€r?   r\  zCDeferredAddTimeoutTests.test_cancelBeforeTimeout.<locals>.onErrbackÌ  ó   ø€ àˆIØ Ð rA   rˆ  r^  )r,   r!   rF  r_   r   r:  r0   rq   rß   r   r   r-  r  ©rf   r  r)  r\  ru  rL  s       @@r?   Útest_cancelBeforeTimeoutz0DeferredAddTimeoutTests.test_cancelBeforeTimeout¼  së   øø€ õ ‘”ˆÝ$™JœJˆØ	�Š�R˜ÑÔÐõ )1©
¬
ˆØˆ	ð	!ð 	!ð 	!ð 	!ð 	!ð 	!ð 	!ð
 	
�Š�YÑÔÐØ	�Š‰
Œ
ˆ
ð Ð$Ð$Ð$Ø×Ò˜i­Ñ1Ô1Ð1Ø�Š�i”n¥eÔ&:Ñ;Ô;Ð;ð 	�Š�bÑÔÐØ×Ò˜MÑ*Ô*Ð*Ð*Ð*rA   c                óØ  ‡‡— t          ¦   «         }t          ¦   «         }|                     d|t          ¬¦  «         t          ¦   «         ŠdŠd
ˆˆfd„}|                     |¦  «         |                     ¦   «          ‰€J ‚|                      ‰t          ¦  «         |                      ‰j	        t          j        ¦  «         |                     d	¦  «         |                      ‰¦  «         dS )a,  
        If the L{Deferred} is manually cancelled before the timeout, it
        is not re-cancelled (no L{AlreadyCancelled} error, and also no
        canceling of inner deferreds), and the custom C{onTimeoutCancel}
        function is not called, preserving the original L{CancelledError}.
        r‡  rT  Nr2   r0   r4   rÔ  c                ó   •— | Š‰S r<   rK   rt  s    €€r?   r\  zIDeferredAddTimeoutTests.test_cancelBeforeTimeoutCustom.<locals>.onErrbackï  rv  rA   rˆ  r^  )r,   r!   rF  rA  r_   r   r:  r0   rq   rß   r   r   r-  r  rw  s       @@r?   Útest_cancelBeforeTimeoutCustomz6DeferredAddTimeoutTests.test_cancelBeforeTimeoutCustomß  sï   øø€ õ ‘”ˆÝ$™JœJˆØ	�Š�R˜µˆÑ>Ô>Ð>õ )1©
¬
ˆØˆ	ð	!ð 	!ð 	!ð 	!ð 	!ð 	!ð 	!ð
 	
�Š�YÑÔÐØ	�Š‰
Œ
ˆ
ð Ð$Ð$Ð$Ø×Ò˜i­Ñ1Ô1Ð1Ø�Š�i”n¥eÔ&:Ñ;Ô;Ð;ð 	�Š�bÑÔÐØ×Ò˜MÑ*Ô*Ð*Ð*Ð*rA   c                ó"  — t          ¦   «         }t          d„ ¦  «        }|                     d|t          ¬¦  «         |                      |¦  «         |                     d¦  «         |                      d|                      |¦  «        ¦  «         dS )zu
        A custom translation function can handle a L{Deferred} with a
        custom cancellation function.
        c                óF   — |                       t          d¦  «        ¦  «        S )Nro  )r®   rY  rŒ  s    r?   rö   zVDeferredAddTimeoutTests.test_providedCancelCalledBeforeTimeoutCustom.<locals>.<lambda>  s   € ¨q¯yªy½ÀGÑ9LÔ9LÑ/MÔ/M€ rA   r‡  rT  rˆ  r@  Nrh  re  s      r?   Ú,test_providedCancelCalledBeforeTimeoutCustomzDDeferredAddTimeoutTests.test_providedCancelCalledBeforeTimeoutCustom  s†   € õ
 ‘”ˆÝ$Ð%MÐ%MÑNÔNˆØ	�Š�R˜µˆÑ>Ô>Ð>Ø×Ò˜AÑÔÐà�Š�bÑÔÐà×Ò˜ t×';Ò';¸AÑ'>Ô'>Ñ?Ô?Ð?Ð?Ð?rA   c                ó˜  ‡— t          ¦   «         }t          ¦   «         }dŠdˆfd„}|                     |¦  «         |                     d|¦  «         |                     d¦  «         ‰€J ‚|                      ‰t          ¦  «         |                      ‰j        t          j	        ¦  «         |  
                    |t          j        ¦  «         dS )	a  
        An errback added before a timeout is added errbacks with a
        L{defer.CancelledError} when the timeout fires.  If the
        errback returns the L{defer.CancelledError}, it is translated
        to a L{defer.TimeoutError} by the timeout implementation.
        Nr2   r0   r4   c                ó   •— | Š| S r<   rK   ©r2   r[  s    €r?   r®   zGDeferredAddTimeoutTests.test_errbackAddedBeforeTimeout.<locals>.errback  ó   ø€ àˆJØˆHrA   r‡  rˆ  ©r2   r0   r4   r0   )r,   r!   r_   rF  r-  r:  r0   re   r   r   r  r  ©rf   r  r)  r®   r[  s       @r?   Útest_errbackAddedBeforeTimeoutz6DeferredAddTimeoutTests.test_errbackAddedBeforeTimeout  sÑ   ø€ õ ‘”ˆÝ$™JœJˆàˆ
ð	ð 	ð 	ð 	ð 	ð 	ð
 	
�Š�WÑÔÐØ	�Š�R˜ÑÔÐà�Š�bÑÔÐàÐ%Ð%Ð%Ø×Ò˜j­'Ñ2Ô2Ð2Ø×Ò˜jÔ.µÔ0DÑEÔEÐEà×Ò˜Q¥Ô 2Ñ3Ô3Ð3Ð3Ð3rA   c                ó‚  ‡— t          ¦   «         }t          ¦   «         }dŠd	ˆfd„}|                     |¦  «         |                     d|¦  «         |                     d¦  «         ‰€J ‚|                      ‰t          ¦  «         |                      ‰j        t          j	        ¦  «         |  
                    |¦  «         dS )
zñ
        An errback added before a timeout is added errbacks with a
        L{defer.CancelledError} when the timeout fires.  If the
        errback suppresses the L{defer.CancelledError}, the deferred
        successfully completes.
        Nr2   r0   r4   rN   c                óJ   •— | Š|                       t          j        ¦  «         d S r<   )rW  r   r   r�  s    €r?   r®   z]DeferredAddTimeoutTests.test_errbackAddedBeforeTimeoutSuppressesCancellation.<locals>.errback8  s#   ø€ àˆJØ�FŠF•5Ô'Ñ(Ô(Ð(Ð(Ð(rA   r‡  rˆ  ræ  )r,   r!   r_   rF  r-  r:  r0   re   r   r   r  r„  s       @r?   Ú4test_errbackAddedBeforeTimeoutSuppressesCancellationzLDeferredAddTimeoutTests.test_errbackAddedBeforeTimeoutSuppressesCancellation,  sÌ   ø€ õ ‘”ˆÝ$™JœJˆàˆ
ð	)ð 	)ð 	)ð 	)ð 	)ð 	)ð
 	
�Š�WÑÔÐØ	�Š�R˜ÑÔÐà�Š�bÑÔÐàÐ%Ð%Ð%Ø×Ò˜j­'Ñ2Ô2Ð2Ø×Ò˜jÔ.µÔ0DÑEÔEÐEà×Ò˜QÑÔÐÐÐrA   c                ó¶  ‡— t          ¦   «         }t          ¦   «         }dŠd	ˆfd„}|                     |¦  «         |                     d|t          ¦  «         |                     d¦  «         ‰€J ‚|                      ‰t          ¦  «         |                      ‰j        t          j
        ¦  «         |                      d|                      |¦  «        ¦  «         dS )
a  
        An errback added before a timeout is added with a custom
        timeout function errbacks with a L{defer.CancelledError} when
        the timeout fires.  The timeout function runs if the errback
        returns the L{defer.CancelledError}.
        Nr2   r0   r4   c                ó   •— | Š| S r<   rK   r�  s    €r?   r®   zMDeferredAddTimeoutTests.test_errbackAddedBeforeTimeoutCustom.<locals>.errbackT  r‚  rA   r‡  rˆ  r@  rƒ  ©r,   r!   r_   rF  rA  r-  r:  r0   re   r   r   ra   r  r„  s       @r?   Ú$test_errbackAddedBeforeTimeoutCustomz<DeferredAddTimeoutTests.test_errbackAddedBeforeTimeoutCustomH  sÞ   ø€ õ ‘”ˆÝ$™JœJˆàˆ
ð	ð 	ð 	ð 	ð 	ð 	ð
 	
�Š�WÑÔÐØ	�Š�R˜¥Ñ.Ô.Ð.à�Š�bÑÔÐàÐ%Ð%Ð%Ø×Ò˜j­'Ñ2Ô2Ð2Ø×Ò˜jÔ.µÔ0DÑEÔEÐEà×Ò˜ t×';Ò';¸AÑ'>Ô'>Ñ?Ô?Ð?Ð?Ð?rA   c                ó¶  ‡— t          ¦   «         }t          ¦   «         }dŠd
ˆfd„}|                     |¦  «         |                     d|t          ¦  «         |                     d¦  «         ‰€J ‚|                      ‰t          ¦  «         |                      ‰j        t          j
        ¦  «         |                      d	|                      |¦  «        ¦  «         dS )a  
        An errback added before a timeout is added with a custom
        timeout function errbacks with a L{defer.CancelledError} when
        the timeout fires.  The timeout function runs if the errback
        suppresses the L{defer.CancelledError}.
        Nr2   r0   r4   rN   c                ó   •— | Šd S r<   rK   r�  s    €r?   r®   zcDeferredAddTimeoutTests.test_errbackAddedBeforeTimeoutSuppressesCancellationCustom.<locals>.errbackp  s   ø€ àˆJˆJˆJrA   r‡  rˆ  r@  ræ  r‹  r„  s       @r?   Ú:test_errbackAddedBeforeTimeoutSuppressesCancellationCustomzRDeferredAddTimeoutTests.test_errbackAddedBeforeTimeoutSuppressesCancellationCustomd  sÞ   ø€ õ ‘”ˆÝ$™JœJˆàˆ
ð	ð 	ð 	ð 	ð 	ð 	ð 	
�Š�WÑÔÐØ	�Š�R˜¥Ñ.Ô.Ð.à�Š�bÑÔÐàÐ%Ð%Ð%Ø×Ò˜j­'Ñ2Ô2Ð2Ø×Ò˜jÔ.µÔ0DÑEÔEÐEà×Ò˜ t×';Ò';¸AÑ'>Ô'>Ñ?Ô?Ð?Ð?Ð?rA   c                ó\  ‡‡— t          ¦   «         }dŠt          ˆfd„¦  «        }dŠd
ˆfd„}|                     |¦  «         |                     d|¦  «         |                     d	¦  «         |                      ‰‰¦  «         |                      ‰|                      |¦  «        ¦  «         dS )a*  
        Given a deferred with a cancellation function that resumes the
        callback chain, a callback that is added to the deferred
        before a timeout is added to runs when the timeout fires.  The
        deferred completes successfully, without a
        L{defer.TimeoutError}.
        r%  c                ó.   •— |                       ‰¦  «        S r<   rQ   ©r)  r%  s    €r?   rö   zSDeferredAddTimeoutTests.test_callbackAddedToCancelerBeforeTimeout.<locals>.<lambda>‰  ó   ø€ ¨a¯jªj¸Ñ.AÔ.A€ rA   Nre   r²   r4   c                ó   •— | Š| S r<   rK   ©re   rK  s    €r?   rR   zSDeferredAddTimeoutTests.test_callbackAddedToCancelerBeforeTimeout.<locals>.callback�  ó   ø€ àˆKØˆLrA   r‡  rˆ  ©re   r²   r4   r²   )r,   r!   r    rF  r-  ra   rq   r  ©rf   r  r)  rR   rK  r%  s       @@r?   Ú)test_callbackAddedToCancelerBeforeTimeoutzADeferredAddTimeoutTests.test_callbackAddedToCancelerBeforeTimeout  sÆ   øø€ õ ‘”ˆØˆÝ#Ð$AÐ$AÐ$AÐ$AÑBÔBˆàˆð	ð 	ð 	ð 	ð 	ð 	ð
 	
�Š�hÑÔÐØ	�Š�R˜ÑÔÐà�Š�bÑÔÐà×Ò˜ gÑ.Ô.Ð.à�Š�g˜t×3Ò3°AÑ6Ô6Ñ7Ô7Ð7Ð7Ð7rA   c                ój  ‡‡— t          ¦   «         }dŠt          ˆfd„¦  «        }dŠdˆfd„}|                     |¦  «         |                     d|t          ¬	¦  «         |                     d
¦  «         |                      ‰‰¦  «         |                      d|                      |¦  «        ¦  «         dS )ad  
        Given a deferred with a cancellation function that resumes the
        callback chain, a callback that is added to the deferred
        before a timeout is added to runs when the timeout fires.  The
        deferred completes successfully, without a
        L{defer.TimeoutError}.  The timeout's custom timeout function
        also runs.
        r%  c                ó.   •— |                       ‰¦  «        S r<   rQ   r’  s    €r?   rö   zYDeferredAddTimeoutTests.test_callbackAddedToCancelerBeforeTimeoutCustom.<locals>.<lambda>¦  r“  rA   Nre   r²   r4   c                ó   •— | Š| S r<   rK   r•  s    €r?   rR   zYDeferredAddTimeoutTests.test_callbackAddedToCancelerBeforeTimeoutCustom.<locals>.callbackª  r–  rA   r‡  rT  rˆ  r@  r—  )r,   r!   r    rF  rA  r-  ra   r  r˜  s       @@r?   Ú/test_callbackAddedToCancelerBeforeTimeoutCustomzGDeferredAddTimeoutTests.test_callbackAddedToCancelerBeforeTimeoutCustom›  sÌ   øø€ õ ‘”ˆØˆÝ#Ð$AÐ$AÐ$AÐ$AÑBÔBˆàˆð	ð 	ð 	ð 	ð 	ð 	ð
 	
�Š�hÑÔÐØ	�Š�R˜µˆÑ>Ô>Ð>à�Š�bÑÔÐà×Ò˜ gÑ.Ô.Ð.à×Ò˜ t×';Ò';¸AÑ'>Ô'>Ñ?Ô?Ð?Ð?Ð?rA   Nr„   )rH   rI   rJ   rj   rG  rR  rW  r`  rc  rf  ri  rm  rq  rx  r{  r~  r…  rˆ  rŒ  r�  r™  r�  rK   rA   r?   rC  rC  ã  s¦  € € € € € ðð ð	:ð 	:ð 	:ð 	:ð+ð +ð +ð +ðB +ð  +ð  +ð  +ðD!+ð !+ð !+ð !+ðF"+ð "+ð "+ð "+ðH4ð 4ð 4ð 4ð@ð @ð @ð @ð"Fð Fð Fð Fð&ð &ð &ð &ð"!+ð !+ð !+ð !+ðF!+ð !+ð !+ð !+ðF@ð @ð @ð @ð4ð 4ð 4ð 4ð8 ð  ð  ð  ð8@ð @ð @ð @ð8@ð @ð @ð @ð68ð 8ð 8ð 8ð8@ð @ð @ð @ð @ð @rA   rC  c                  ó2   — e Zd ZdZd	d„Zd	d„Zd	d„Zd	d„ZdS )
ÚEnsureDeferredTestsz&
    Tests for L{ensureDeferred}.
    r4   rN   c                ól   — t          ¦   «         }t          |¦  «        }|                      ||¦  «         dS )zK
        L{ensureDeferred} will pass through a Deferred unchanged.
        N)r!   r*   rq   rF  s      r?   Útest_passesThroughDeferredsz/EnsureDeferredTests.test_passesThroughDeferreds¾  s4   € õ &™ZœZˆÝ˜BÑÔˆØ�Š�b˜"ÑÔÐÐÐrA   c                ó”   — |                       t          j        ¦  «        5  t          d¦  «         ddd¦  «         dS # 1 swxY w Y   dS )zr
        Passing L{ensureDeferred} a non-coroutine and a non-Deferred will
        raise a L{ValueError}.
        Ú	somethingN)r©  r   rª  r*   rŽ   s    r?   Ú'test_willNotAllowNonDeferredOrCoroutinez;EnsureDeferredTests.test_willNotAllowNonDeferredOrCoroutineÆ  s�   € ð
 ×Ò�uÔ7Ñ8Ô8ð 	(ð 	(Ý˜;Ñ'Ô'Ð'ð	(ð 	(ð 	(ñ 	(ô 	(ð 	(ð 	(ð 	(ð 	(ð 	(ð 	(ð 	(øøøð 	(ð 	(ð 	(ð 	(ð 	(ð 	(s    =½AÁAc                óL  — dd„} |¦   «         }|                       |t          j        ¦  «         t          |¦  «        }t	          |t
          t                   ¦  «         |                       |t
          ¦  «         |                      |¦  «        }|                      |d¦  «         dS )zM
        L{ensureDeferred} will turn a coroutine into a L{Deferred}.
        r4   r²   c               “  óB   K  — t          j        d¦  «        } | ƒ d {V —†}|S ©NrF  rÒ  ©r)  rÀ  s     r?   rØ  z=EnsureDeferredTests.test_ensureDeferredCoroutine.<locals>.runÓ  s+   è è € Ý”˜eÑ$Ô$ˆAØ�'�'�'�'�'�'ˆCØˆJrA   rF  N)r4   r²   )	r:  ÚtypesÚCoroutineTyper*   r   r!   r²   r  ra   ©rf   rØ  rB  r)  rÀ  s        r?   Útest_ensureDeferredCoroutinez0EnsureDeferredTests.test_ensureDeferredCoroutineÎ  ó¦   € ð
	ð 	ð 	ð 	ð ˆC‰EŒEˆØ×Ò˜a¥Ô!4Ñ5Ô5Ð5õ ˜1ÑÔˆÝ�A•x¥”}Ñ%Ô%Ð%Ø×Ò˜a¥Ñ*Ô*Ð*ð ×"Ò" 1Ñ%Ô%ˆØ×Ò˜˜eÑ$Ô$Ð$Ð$Ð$rA   c                óL  — dd„} |¦   «         }|                       |t          j        ¦  «         t          |¦  «        }t	          |t
          t                   ¦  «         |                       |t
          ¦  «         |                      |¦  «        }|                      |d¦  «         dS )zX
        L{ensureDeferred} will turn a yield-from coroutine into a L{Deferred}.
        r4   ú#Generator[Deferred[str], None, str]c               3  óh   K  — t          j        d¦  «        } t          t          | E d {V —†¦  «        }|S r§  )r   r&  r   r²   r¨  s     r?   rØ  z=EnsureDeferredTests.test_ensureDeferredGenerator.<locals>.runê  s5   è è € Ý”˜eÑ$Ô$ˆAÝ•s¨˜\˜\˜\˜\˜\˜\Ñ+Ô+ˆCØˆJrA   rF  N)r4   r¯  )	r:  r©  ÚGeneratorTyper*   r   r!   r²   r  ra   r«  s        r?   Útest_ensureDeferredGeneratorz0EnsureDeferredTests.test_ensureDeferredGeneratorå  r­  rA   Nr„   )rH   rI   rJ   rj   r¡  r¤  r¬  r²  rK   rA   r?   rŸ  rŸ  ¹  sn   € € € € € ðð ðð ð ð ð(ð (ð (ð (ð%ð %ð %ð %ð.%ð %ð %ð %ð %ð %rA   rŸ  c                  ó   — e Zd ZdZdd„ZdS )ÚTimeoutErrorTestsz1
    L{twisted.internet.defer} timeout code.
    r4   rN   c                ó˜  — t          ¦   «         }t          j        |¦  «         |                      |t          j        ¦  «         |                      | j        g¦  «        }|                      t          |¦  «        d¦  «         |  	                    |d         d         t          ¦  «         |                      |d         d         d¦  «         dS )zB
        L{twisted.internet.defer.timeout} is deprecated.
        r]   r   rG  rH  z~twisted.internet.defer.timeout was deprecated in Twisted 17.1.0; please use twisted.internet.defer.Deferred.addTimeout insteadN)r!   r   r  r  r  rI  Útest_deprecatedTimeoutra   rb   rq   rJ  )rf   rL   ÚwarningsShowns      r?   r¶  z(TimeoutErrorTests.test_deprecatedTimeout  sÁ   € õ &.¡Z¤ZˆÝŒ�hÑÔÐØ×Ò˜8¥UÔ%7Ñ8Ô8Ð8Ø×*Ò*¨DÔ,GÐ+HÑIÔIˆØ×Ò�˜]Ñ+Ô+¨QÑ/Ô/Ð/Ø�Š�m AÔ& zÔ2Õ4FÑGÔGÐGØ×ÒØ˜!Ô˜YÔ'ðMñ	
ô 	
ð 	
ð 	
ð 	
rA   Nr„   )rH   rI   rJ   rj   r¶  rK   rA   r?   r´  r´  ý  s2   € € € € € ðð ð
ð 
ð 
ð 
ð 
ð 
rA   r´  Úloopr   c                ób   — |                       | j        ¦  «         |                      ¦   «          dS )zú
    Tickle an asyncio event loop to call all of the things scheduled with
    call_soon, inasmuch as this can be done via the public API.

    @param loop: The asyncio event loop to flush the previously-called
        C{call_soon} entries from.
    N)Ú	call_soonÚstopÚrun_forever©r¸  s    r?   ÚcallAllSoonCallsr¾    s0   € ð 	‡N‚N�4”9ÑÔÐØ×ÒÑÔÐÐÐrA   c                  óN   — e Zd Zdd„Zdd„Zdd„Zdd„Zdd„Zdd	„Zdd
„Z	dd„Z
dS )ÚDeferredFutureAdapterTestsr4   r   c                óV   — t          ¦   «         }|                      |j        ¦  «         |S )zU
        Create a new event loop that will be closed at the end of the test.
        )Ú_new_event_loopr‹   ÚcloserÉ  s     r?   ÚnewLoopz"DeferredFutureAdapterTests.newLoop   s(   € õ !Ñ"Ô"ˆØ�Š˜œÑ%Ô%Ð%ØˆrA   rN   c                ó®  — t          ¦   «         }|                      ¦   «         }|                     |¦  «        }|                      |                     ¦   «         d¦  «         |                     d¦  «         t          |¦  «         |                      |                      |¦  «        d¦  «         |                      |                     ¦   «         d¦  «         dS )zw
        L{Deferred.asFuture} returns a L{asyncio.Future} which fires when
        the given L{Deferred} does.
        Fr÷  N)	r!   rÄ  ÚasFuturera   r  rR   r¾  r  rs   )rf   r)  r¸  ÚaFutures       r?   Útest_asFuturez(DeferredFutureAdapterTests.test_asFuture(  s°   € õ
 $™:œ:ˆØ�|Š|‰~Œ~ˆØ—*’*˜TÑ"Ô"ˆØ×Ò˜Ÿš™œ¨Ñ/Ô/Ð/Ø	�
Š
�2‰ŒˆÝ˜ÑÔÐØ×Ò˜×-Ò-¨aÑ0Ô0°$Ñ7Ô7Ð7Ø×Ò˜ŸšÑ)Ô)¨2Ñ.Ô.Ð.Ð.Ð.rA   c                óŠ  ‡— dŠdˆfd„}t          |¦  «        }|                      ¦   «         }|                     |¦  «        }|                     ¦   «          t	          |¦  «         |                      ‰¦  «         |                      |                      |¦  «        d¦  «         |                      t          |j
        ¦  «         dS )	z‡
        L{Deferred.asFuture} returns a L{asyncio.Future} which, when
        cancelled, will cancel the original L{Deferred}.
        FÚdprimer  r4   rN   c                ó   •— dŠd S r  rK   )rÊ  rù  s    €r?   ÚcancelerzFDeferredFutureAdapterTests.test_asFutureCancelFuture.<locals>.canceler>  s   ø€ àˆFˆFˆFrA   N©rÊ  r  r4   rN   )r!   rÄ  rÆ  r   r¾  rc   ra   r  r©  r   rs   )rf   rÌ  r)  r¸  rÇ  rù  s        @r?   Útest_asFutureCancelFuturez4DeferredFutureAdapterTests.test_asFutureCancelFuture6  sÇ   ø€ ð ˆð	ð 	ð 	ð 	ð 	ð 	õ % XÑ.Ô.ˆØ�|Š|‰~Œ~ˆØ—*’*˜TÑ"Ô"ˆØ�ŠÑÔÐÝ˜ÑÔÐØ�Š˜ÑÔÐØ×Ò˜×-Ò-¨aÑ0Ô0°$Ñ7Ô7Ð7Ø×Ò�.¨'¬.Ñ9Ô9Ð9Ð9Ð9rA   c                óV  — dd„}t          |¦  «        }|                      ¦   «         }|                     |¦  «        }|                     ¦   «          t	          |¦  «         |                      |                      |¦  «        d¦  «         |                      t          |j	        ¦  «         dS )zÒ
        While Futures don't support succeeding in response to cancellation,
        Deferreds do; if a Deferred is coerced into a success by a Future
        cancellation, that should just be ignored.
        rÊ  r  r4   rN   c                ó0   — |                       d¦  «         d S )Nrù  rQ   )rÊ  s    r?   rÌ  zGDeferredFutureAdapterTests.test_asFutureSuccessCancel.<locals>.cancelerR  s   € Ø�OŠO˜AÑÔÐÐÐrA   NrÍ  )
r!   rÄ  rÆ  r   r¾  ra   r  r©  r   rs   )rf   rÌ  r)  r¸  rÇ  s        r?   Útest_asFutureSuccessCancelz5DeferredFutureAdapterTests.test_asFutureSuccessCancelK  s£   € ð	ð 	ð 	ð 	õ % XÑ.Ô.ˆØ�|Š|‰~Œ~ˆØ—*’*˜TÑ"Ô"ˆØ�ŠÑÔÐÝ˜ÑÔÐØ×Ò˜×-Ò-¨aÑ0Ô0°$Ñ7Ô7Ð7Ø×Ò�.¨'¬.Ñ9Ô9Ð9Ð9Ð9rA   c                óP  — t          ¦   «         }t          t          ¦   «         ¦  «        }|                      ¦   «         }|                     |¦  «        }t          |¦  «         |                     |¦  «         t          |¦  «         |                      t          |j        ¦  «         dS )z€
        L{Deferred.asFuture} makes a L{asyncio.Future} fire with an
        exception when the given L{Deferred} does.
        N)	r!   r0   r9  rÄ  rÆ  r¾  r®   r©  rs   )rf   r)  Ú
theFailurer¸  Úfutures        r?   Útest_asFutureFailurez/DeferredFutureAdapterTests.test_asFutureFailure]  sŒ   € õ
 %™JœJˆÝÕ.Ñ0Ô0Ñ1Ô1ˆ
Ø�|Š|‰~Œ~ˆØ—’˜DÑ!Ô!ˆÝ˜ÑÔÐØ	�	Š	�*ÑÔÐÝ˜ÑÔÐØ×ÒÕ+¨V¬]Ñ;Ô;Ð;Ð;Ð;rA   c                ó:  — |                       ¦   «         }t          |¬¦  «        }t          j        |¦  «        }|                      |¦  «         |                     d¦  «         t          |¦  «         |                      |                      |¦  «        d¦  «         dS )zx
        L{Deferred.fromFuture} returns a L{Deferred} that fires
        when the given L{asyncio.Future} does.
        r½  rP  N)	rÄ  r   r!   Ú
fromFuturer  Ú
set_resultr¾  ra   r  )rf   r¸  rÇ  r)  s       r?   Útest_fromFuturez*DeferredFutureAdapterTests.test_fromFuturek  s‘   € ð
 �|Š|‰~Œ~ˆÝ%¨4Ð0Ñ0Ô0ˆÝÔ Ñ(Ô(ˆØ×Ò˜AÑÔÐØ×Ò˜1ÑÔÐÝ˜ÑÔÐØ×Ò˜×-Ò-¨aÑ0Ô0°!Ñ4Ô4Ð4Ð4Ð4rA   c                óV  — |                       ¦   «         }t          |¬¦  «        }t          j        |¦  «        }|                     ¦   «          t          |¦  «         |                      t          |j        ¦  «         |  	                    |¦  «         
                    t          ¦  «         dS )z¢
        L{Deferred.fromFuture} makes a L{Deferred} fire with
        an L{asyncio.CancelledError} when the given
        L{asyncio.Future} is cancelled.
        r½  N)rÄ  r   r!   r×  r   r¾  r©  r   rs   r  rW  ©rf   r¸  Ú	cancelledr)  s       r?   Útest_fromFutureFutureCancelledz9DeferredFutureAdapterTests.test_fromFutureFutureCancelledx  s’   € ð �|Š|‰~Œ~ˆÝ"(¨dÐ"3Ñ"3Ô"3ˆ	ÝÔ 	Ñ*Ô*ˆØ×ÒÑÔÐÝ˜ÑÔÐØ×Ò�.¨)Ô*:Ñ;Ô;Ð;Ø×Ò˜QÑÔ×$Ò$¥^Ñ4Ô4Ð4Ð4Ð4rA   c                ó¦  — |                       ¦   «         }t          |¬¦  «        }t          j        |¦  «        }|                     ¦   «          t          |¦  «         |                      |                     ¦   «         d¦  «         |                      t          |j
        ¦  «         |                      |¦  «                             t          ¦  «         dS )zŽ
        L{Deferred.fromFuture} makes a L{Deferred} which, when
        cancelled, cancels the L{asyncio.Future} it was created from.
        r½  TN)rÄ  r   r!   r×  r   r¾  ra   rÜ  r©  r   rs   r  rW  rÛ  s       r?   Ú test_fromFutureDeferredCancelledz;DeferredFutureAdapterTests.test_fromFutureDeferredCancelled†  s¯   € ð
 �|Š|‰~Œ~ˆÝ"(¨dÐ"3Ñ"3Ô"3ˆ	ÝÔ 	Ñ*Ô*ˆØ	�Š‰
Œ
ˆ
Ý˜ÑÔÐØ×Ò˜×,Ò,Ñ.Ô.°Ñ5Ô5Ð5Ø×Ò�.¨)Ô*:Ñ;Ô;Ð;Ø×Ò˜QÑÔ×$Ò$¥^Ñ4Ô4Ð4Ð4Ð4rA   N)r4   r   r„   )rH   rI   rJ   rÄ  rÈ  rÎ  rÑ  rÕ  rÙ  rÝ  rß  rK   rA   r?   rÀ  rÀ    s´   € € € € € ðð ð ð ð/ð /ð /ð /ð:ð :ð :ð :ð*:ð :ð :ð :ð$<ð <ð <ð <ð5ð 5ð 5ð 5ð5ð 5ð 5ð 5ð5ð 5ð 5ð 5ð 5ð 5rA   rÀ  c                  ón   — e Zd Zd
d„Zd
d„Zed
d„¦   «         Zed
d„¦   «         Zed
d„¦   «         Zd
d„Z	d	S )ÚCoroutineContextVarsTestsr4   rN   c                ót  ‡ ‡‡‡‡‡— t          ¦   «         Št          j        d¦  «        Š‰                     d¦  «         t	          ¦   «         Š‰                     ˆfd„¦  «         t	          ¦   «         Š‰                     ˆfd„¦  «         ‰                     d„ ¦  «         t          j        dˆˆfd„¦   «         Št          ‰t          g t          d	         f         ¦  «         t          j        dˆˆˆˆ ˆˆfd„¦   «         }t          |t          g t          t          d                  f         ¦  «         ‰                     d¦  «          |¦   «         }‰                     d¦  «         ‰                     d¦  «         ‰                     d¦  «         ‰                      ‰                      |¦  «        d¦  «         d	S )z§
        When an inlineCallbacks function is called, the context is taken from
        when it was first called. When it resumes, the same context is applied.
        Útestvarr]   c                ó.   •— ‰                      d¦  «        S rö  ©Úset©r7  Úvars    €r?   rö   zDCoroutineContextVarsTests.test_withInlineCallbacks.<locals>.<lambda>¢  ó   ø€ ¨s¯wªw°q©z¬z€ rA   c                ó.   •— ‰                      d¦  «        S ©Né   rå  rç  s    €r?   rö   zDCoroutineContextVarsTests.test_withInlineCallbacks.<locals>.<lambda>¥  ó   ø€ ¸¿ºÀ¹
¼
€ rA   c                ó   — ddz  S r5  rK   r6  s    r?   rö   zDCoroutineContextVarsTests.test_withInlineCallbacks.<locals>.<lambda>¦  ó
   € ¸¸A¹€ rA   r4   ú#Generator[Deferred[Any], Any, None]c               3  ó’   •K  — t          ¦   «         } ‰                     d| j        d¦  «         | V — ‰                     d¦  «         d S ©Nr]   Tr÷  ©r!   r$  rR   ræ  ©r)  r  rè  s    €€r?   ÚyieldingDeferredzLCoroutineContextVarsTests.test_withInlineCallbacks.<locals>.yieldingDeferred¨  sD   øè è € å'™zœzˆAØ�OŠO˜A˜qœz¨4Ñ0Ô0Ð0ØˆGˆGˆGØ�GŠG�A‰JŒJˆJˆJˆJrA   Nú,Generator[Deferred[Any], Any, Literal[True]]c               3  ó   •K  — ‰                      ‰                     ¦   «         d¦  «         t          j        d¦  «        V — ‰                      ‰                     ¦   «         d¦  «         ‰                      d‰j        d¦  «         ‰V — ‰                      ‰                     ¦   «         d¦  «         ‰                      d‰j        d¦  «         	 ‰V — t          d¦  «        ‚# t          $ r+ ‰                      ‰                     ¦   «         d¦  «         Y nw xY w ‰¦   «         V — ‰                      ‰                     ¦   «         d¦  «         dS )NrÅ   r]   Tú???? should have failed©ra   r   r   r&  r$  rR   r¸  )r  ÚmutatingDeferredÚmutatingDeferredThatFailsrf   rè  rõ  s   €€€€€€r?   ÚtestFunctionzHCoroutineContextVarsTests.test_withInlineCallbacks.<locals>.testFunction²  s`  øè è € ð ×Ò˜SŸWšW™YœY¨Ñ*Ô*Ð*õ ”- Ñ"Ô"Ð"Ð"Ð"ð ×Ò˜SŸWšW™YœY¨Ñ*Ô*Ð*ð �OŠO˜AÐ/Ô8¸$Ñ?Ô?Ð?Ø"Ð"Ð"Ð"ð ×Ò˜SŸWšW™YœY¨Ñ*Ô*Ð*ð �OŠO˜AÐ8ÔAÀ4ÑHÔHÐHð;Ø/Ð/Ð/Ð/õ  Ð 9Ñ:Ô:Ð:øõ ð /ð /ð /Ø× Ò  §¢¡¤¨AÑ.Ô.Ð.Ð.Ð.ð/øøøð #Ð"Ñ$Ô$Ð$Ð$Ð$Ø×Ò˜SŸWšW™YœY¨Ñ*Ô*Ð*à�4s   ÃC" Ã"2DÄDTrÅ   ©r4   rð  )r4   rö  )r,   ÚcontextvarsÚ
ContextVarræ  r!   r    r   ÚinlineCallbacksr   r	   r   r-  ra   r  )rf   rü  r)  r  rú  rû  rè  rõ  s   `  @@@@@r?   Útest_withInlineCallbacksz2CoroutineContextVarsTests.test_withInlineCallbacks–  sÙ  øøøøøø€ õ
 ‘”ˆå+6Ô+AÀ)Ñ+LÔ+LˆØ�Š�‰
Œ
ˆ
õ ,4©:¬:ÐØ×$Ò$Ð%9Ð%9Ð%9Ð%9Ñ:Ô:Ð:å3;±:´:Ð!Ø!×-Ò-Ð.BÐ.BÐ.BÐ.BÑCÔCÐCØ!×-Ò-¨o¨oÑ>Ô>Ð>å	Ô	ð	ð 	ð 	ð 	ð 	ð 	ñ 
Ô	ð	õ 	Ð$¥h¨rµ8¸D´>Ð/AÔ&BÑCÔCÐCõ 
Ô	ð"	ð "	ð "	ð "	ð "	ð "	ð "	ð "	ð "	ð "	ñ 
Ô	ð"	õH 	�L¥(¨2­x½À¼Ô/FÐ+FÔ"GÑHÔHÐHà�Š�‰
Œ
ˆ
ØˆL‰NŒNˆð 	�Š�aÑÔÐð 	�Š�aÑÔÐð 	�Š�aÑÔÐà×Ò˜×-Ò-¨aÑ0Ô0°$Ñ7Ô7Ð7Ð7Ð7rA   c                ó  ‡ ‡‡— t          ¦   «         Št          j        d¦  «        Št          j        dˆˆ ˆfd„¦   «         }‰                     d¦  «          |¦   «         }‰                     d¦  «         ‰                      |¦  «         dS )	z”
        When an inlineCallbacks function resumes, we should be able to reset() a
        contextvar that was set when it was first called.
        rã  r4   rð  c               3  ó\  •K  — ‰                      d¦  «        } t          ¦   «         }‰                     d|j        d¦  «         |V — ‰                     ‰                     ¦   «         d¦  «         ‰                     | ¦  «         ‰                     ‰                     ¦   «         d¦  «         d S )Nr÷  r]   TrÅ   )ræ  r!   r$  rR   ra   r   Úreset)Útokenr)  r  rf   rè  s     €€€r?   rõ  zQCoroutineContextVarsTests.test_resetWithInlineCallbacks.<locals>.yieldingDeferredð  s˜   øè è € ð —G’G˜A‘J”JˆEõ  (™zœzˆAØ�OŠO˜A˜qœz¨4Ñ0Ô0Ð0ØˆGˆGˆGØ×Ò˜SŸWšW™YœY¨Ñ*Ô*Ð*à�IŠI�eÑÔÐà×Ò˜SŸWšW™YœY¨Ñ*Ô*Ð*Ð*Ð*rA   rÅ   r]   Nrý  )r,   rþ  rÿ  r   r   ræ  r-  r  )rf   rõ  r)  r  rè  s   `  @@r?   Útest_resetWithInlineCallbacksz7CoroutineContextVarsTests.test_resetWithInlineCallbacksç  s£   øøø€ õ
 ‘”ˆå+6Ô+AÀ)Ñ+LÔ+Lˆå	Ô	ð	+ð 	+ð 	+ð 	+ð 	+ð 	+ð 	+ñ 
Ô	ð	+ð 	�Š�‰
Œ
ˆ
ØÐÑÔˆð 	�Š�aÑÔÐØ×Ò˜QÑÔÐÐÐrA   c              ƒ  óð  ‡K  — t          ¦   «         Šd}‰4 ƒd{V —† |                      ‰j        ¦  «         ‰                     ¦   «         }|                     ˆfd„¦  «         |                      ‰j        ¦  «         |                      |j        ¦  «         ddd¦  «        ƒd{V —† n# 1 ƒd{V —†swxY w Y   |                      |j        ¦  «         |ƒ d{V —† |                      ‰j        ¦  «         dS )zQ
        L{DeferredLock} can be used as an asynchronous context manager.
        Nc                ó,   •— ‰                      ¦   «         S r<   ©r×  )r7  rÙ  s    €r?   rö   z>CoroutineContextVarsTests.test_asyncWithLock.<locals>.<lambda>  s   ø€  D§L¢L¡N¤N€ rA   )r$   rc   rÖ  rÕ  r    r	  rù  )rf   r)  rÙ  s     @r?   Útest_asyncWithLockz,CoroutineContextVarsTests.test_asyncWithLock  sv  øè è € õ
 ‰~Œ~ˆØˆØð 	'ð 	'ð 	'ð 	'ð 	'ð 	'ð 	'ð 	'Ø�OŠO˜DœKÑ(Ô(Ð(Ø—’‘”ˆAØ�MŠMÐ2Ð2Ð2Ð2Ñ3Ô3Ð3Ø�OŠO˜DœKÑ(Ô(Ð(Ø×Ò˜QœXÑ&Ô&Ð&ð	'ð 	'ð 	'ñ 	'ô 	'ð 	'ð 	'ð 	'ð 	'ð 	'ð 	'ð 	'ð 	'ð 	'ð 	'ð 	'ð 	'ð 	'ð 	'ð 	'ð 	'ð 	'ð 	'øøøð 	'ð 	'ð 	'ð 	'ð 	�Š˜œÑ!Ô!Ð!ØˆˆˆˆˆˆˆØ×Ò˜œÑ%Ô%Ð%Ð%Ð%s   œA;B)Â)
B3Â6B3c              ƒ  óŠ  ‡K  — t          d¦  «        Š‰4 ƒd{V —† |                      ‰j        d¦  «         ‰4 ƒd{V —† |                      ‰j        d¦  «         ‰                     ¦   «         }‰                     ¦   «         }|                      ‰j        d¦  «         |                      |j        ¦  «         |                      |j        ¦  «         ddd¦  «        ƒd{V —† n# 1 ƒd{V —†swxY w Y   |                      ‰j        d¦  «         |                      |j        ¦  «         |                     ˆfd„¦  «         |                     ˆfd„¦  «         |ƒ d{V —† |ƒ d{V —† |                      ‰j        d¦  «         ddd¦  «        ƒd{V —† n# 1 ƒd{V —†swxY w Y   |                      ‰j        d¦  «         dS )z^
        L{DeferredSemaphore} can be used as an asynchronous context
        manager.
        r÷  NrÅ   r]   r   c                ó,   •— ‰                      ¦   «         S r<   r	  ©r7  rò  s    €r?   rö   zCCoroutineContextVarsTests.test_asyncWithSemaphore.<locals>.<lambda>+  ó   ø€  S§[¢[¡]¤]€ rA   c                ó,   •— ‰                      ¦   «         S r<   r	  r  s    €r?   rö   zCCoroutineContextVarsTests.test_asyncWithSemaphore.<locals>.<lambda>,  r  rA   )r&   ra   ÚtokensrÕ  rc   rù  r	  r    )rf   ré   rù   rò  s      @r?   Útest_asyncWithSemaphorez1CoroutineContextVarsTests.test_asyncWithSemaphore  sÌ  øè è € õ   Ñ"Ô"ˆàð 	,ð 	,ð 	,ð 	,ð 	,ð 	,ð 	,ð 	,Ø×Ò˜SœZ¨Ñ+Ô+Ð+Øð ,ð ,ð ,ð ,ð ,ð ,ð ,ð ,Ø× Ò  ¤¨QÑ/Ô/Ð/Ø—[’[‘]”]�Ø—[’[‘]”]�Ø× Ò  ¤¨QÑ/Ô/Ð/Ø—’ ¤	Ñ*Ô*Ð*Ø× Ò  ¤Ñ+Ô+Ð+ð,ð ,ð ,ñ ,ô ,ð ,ð ,ð ,ð ,ð ,ð ,ð ,ð ,ð ,ð ,ð ,ð ,ð ,ð ,ð ,ð ,ð ,ð ,øøøð ,ð ,ð ,ð ,ð ×Ò˜SœZ¨Ñ+Ô+Ð+Ø�OŠO˜BœIÑ&Ô&Ð&Ø�NŠNÐ2Ð2Ð2Ð2Ñ3Ô3Ð3Ø�NŠNÐ2Ð2Ð2Ð2Ñ3Ô3Ð3ØˆHˆHˆHˆHˆHˆHˆHØˆHˆHˆHˆHˆHˆHˆHØ×Ò˜SœZ¨Ñ+Ô+Ð+ð	,ð 	,ð 	,ñ 	,ô 	,ð 	,ð 	,ð 	,ð 	,ð 	,ð 	,ð 	,ð 	,ð 	,ð 	,ð 	,ð 	,ð 	,ð 	,ð 	,ð 	,ð 	,ð 	,øøøð 	,ð 	,ð 	,ð 	,ð  	×Ò˜œ QÑ'Ô'Ð'Ð'Ð's6   ›$F¿BC$ÃFÃ$
C.	Ã.FÃ1C.	Ã2BFÆ
F!Æ$F!c              ƒ  óH  K  — t          ¦   «         }|                      t          d¦  «        5  |4 ƒd{V —† |                      |j        ¦  «         t          d¦  «        ‚# 1 ƒd{V —†swxY w Y   	 ddd¦  «         n# 1 swxY w Y   |                      |j        ¦  «         dS )zw
        C{DeferredLock} correctly propagates exceptions when
        used as an asynchronous context manager.
        zsome specific exceptionN)r$   ÚassertRaisesRegexr¸  rc   rÖ  r	  r)  s     r?   Útest_asyncWithLockExceptionz5CoroutineContextVarsTests.test_asyncWithLockException2  s7  è è € õ ‰~Œ~ˆØ×#Ò#¥IÐ/HÑIÔIð 	;ð 	;Øð ;ð ;ð ;ð ;ð ;ð ;ð ;ð ;Ø—’ ¤Ñ,Ô,Ð,ÝÐ 9Ñ:Ô:Ð:ð;ð ;ð ;ð ;ð ;ð ;ð ;ð ;ð ;ð ;øøøð ;ð ;ð ;ð ;ð ;ð	;ð 	;ð 	;ñ 	;ô 	;ð 	;ð 	;ð 	;ð 	;ð 	;ð 	;øøøð 	;ð 	;ð 	;ð 	;ð 	×Ò˜œÑ%Ô%Ð%Ð%Ð%s.   ¬	A=µ*AÁ
A)	Á)A=Á,A)	Á-A=Á=BÂBc                ó�  ‡ ‡‡‡‡‡— t          ¦   «         Št          j        d¦  «        Š‰                     d¦  «         t	          ¦   «         Š‰                     ˆfd„¦  «         t	          ¦   «         Š‰                     ˆfd„¦  «         ‰                     d„ ¦  «         dˆˆfd„Šdˆˆˆˆˆ ˆfd
„}‰                     d¦  «         t           |¦   «         ¦  «        }‰                     d¦  «         ‰                     d¦  «         ‰                     d¦  «         ‰                      ‰  	                    |¦  «        d¦  «         dS )z—
        When a coroutine is called, the context is taken from when it was first
        called. When it resumes, the same context is applied.
        rã  r]   c                ó.   •— ‰                      d¦  «        S rö  rå  rç  s    €r?   rö   zJCoroutineContextVarsTests.test_contextvarsWithAsyncAwait.<locals>.<lambda>K  ré  rA   c                ó.   •— ‰                      d¦  «        S rë  rå  rç  s    €r?   rö   zJCoroutineContextVarsTests.test_contextvarsWithAsyncAwait.<locals>.<lambda>N  rí  rA   c                ó   — ddz  S r5  rK   r6  s    r?   rö   zJCoroutineContextVarsTests.test_contextvarsWithAsyncAwait.<locals>.<lambda>O  rï  rA   r4   rN   c               “  óš   •K  — t          ¦   «         } ‰                     d| j        d¦  «         | ƒ d {V —† ‰                     d¦  «         d S rò  ró  rô  s    €€r?   ÚasyncFuncAwaitingDeferredz[CoroutineContextVarsTests.test_contextvarsWithAsyncAwait.<locals>.asyncFuncAwaitingDeferredQ  sL   øè è € Ý (¡
¤
ˆAØ�OŠO˜A˜qœz¨4Ñ0Ô0Ð0ØˆGˆGˆGˆGˆGˆGˆGØ�GŠG�A‰JŒJˆJˆJˆJrA   rÇ   c               “  óÀ  •K  — ‰                      ‰                     ¦   «         d¦  «         t          j        d¦  «        ƒ d {V —† ‰                      ‰                     ¦   «         d¦  «         ‰                     d‰j        d¦  «         ‰ƒ d {V —† ‰                      ‰                     ¦   «         d¦  «         ‰                     d‰j        d¦  «         	 ‰ƒ d {V —† t          d¦  «        ‚# t          $ r+ ‰                      ‰                     ¦   «         d¦  «         Y nw xY w ‰ ¦   «         ƒ d {V —† ‰                      ‰                     ¦   «         d¦  «         dS )NrÅ   r]   r   Trø  r÷  rù  )r  r  rú  rû  rf   rè  s   €€€€€€r?   rü  zNCoroutineContextVarsTests.test_contextvarsWithAsyncAwait.<locals>.testFunctionX  sŽ  øè è € à×Ò˜SŸWšW™YœY¨Ñ*Ô*Ð*õ ”- Ñ"Ô"Ð"Ð"Ð"Ð"Ð"Ð"Ð"ð ×Ò˜SŸWšW™YœY¨Ñ*Ô*Ð*ð �OŠO˜AÐ/Ô8¸$Ñ?Ô?Ð?Ø"Ð"Ð"Ð"Ð"Ð"Ð"Ð"ð ×Ò˜SŸWšW™YœY¨Ñ*Ô*Ð*ð �OŠO˜AÐ8ÔAÀ4ÑHÔHÐHð;Ø/Ð/Ð/Ð/Ð/Ð/Ð/Ð/õ  Ð 9Ñ:Ô:Ð:øõ ð /ð /ð /Ø× Ò  §¢¡¤¨AÑ.Ô.Ð.Ð.Ð.ð/øøøð ,Ð+Ñ-Ô-Ð-Ð-Ð-Ð-Ð-Ð-Ð-Ø×Ò˜SŸWšW™YœY¨Ñ*Ô*Ð*à�4s   ÃC. Ã.2D#Ä"D#rÅ   TNr„   )r4   rÇ   )
r,   rþ  rÿ  ræ  r!   r    r*   r-  ra   r  )rf   rü  r)  r  r  rú  rû  rè  s   `  @@@@@r?   Útest_contextvarsWithAsyncAwaitz8CoroutineContextVarsTests.test_contextvarsWithAsyncAwait?  s  øøøøøø€ õ
 ‘”ˆå+6Ô+AÀ)Ñ+LÔ+LˆØ�Š�‰
Œ
ˆ
õ ,4©:¬:ÐØ×$Ò$Ð%9Ð%9Ð%9Ð%9Ñ:Ô:Ð:å4<±J´JÐ!Ø!×-Ò-Ð.BÐ.BÐ.BÐ.BÑCÔCÐCØ!×-Ò-¨o¨oÑ>Ô>Ð>ð	ð 	ð 	ð 	ð 	ð 	ð 	ð!	ð !	ð !	ð !	ð !	ð !	ð !	ð !	ð !	ð !	ð !	ðH 	�Š�‰
Œ
ˆ
Ý˜<˜<™>œ>Ñ*Ô*ˆð 	�Š�aÑÔÐð 	�Š�aÑÔÐð 	�Š�aÑÔÐà×Ò˜×-Ò-¨aÑ0Ô0°$Ñ7Ô7Ð7Ð7Ð7rA   Nr„   )
rH   rI   rJ   r  r  rD   r
  r  r  r  rK   rA   r?   rá  rá  •  s¿   € € € € € ðO8ð O8ð O8ð O8ðb ð  ð  ð  ð@ ð&ð &ð &ñ Ôð&ð  ð(ð (ð (ñ Ôð(ð2 ð
&ð 
&ð 
&ñ Ôð
&ðI8ð I8ð I8ð I8ð I8ð I8rA   rá  c                  óL   — e Zd Zdd„Z ej        ed¦  «        dd„¦   «         ZdS )ÚInlineCallbackTestsr4   rN   c                óŒ   — d„ dd| j         dt          g}|D ]-}|                      t          j        t          j        |¦  «         Œ.dS )r¤  c                ó   — | S r<   rK   r…  s    r?   rö   zIInlineCallbackTests.test_fromCoroutineRequiresCoroutine.<locals>.<lambda>“  r¦  rA   r]   TNr§  r«  s      r?   r¨  z7InlineCallbackTests.test_fromCoroutineRequiresCoroutineŒ  r®  rA   r¯  c                ó~  — t          ¦   «         }t          j        |¦  «        }dd„}t          j         ||¦  «        ¦  «        }|                      ||                      |¦  «        ¦  «         t          j        |¦  «        }~~|                       |¦   «         ¦  «         |                       |¦   «         ¦  «         dS )zÂ
        Tests that there is no circular dependency when using
        L{Deferred.fromCoroutine}, so that the machinery gets cleaned up
        immediately rather than waiting for a GC.
        rÛ  r   r4   c              “  ó
   K  — | S r<   rK   )rÛ  s    r?   r   zCInlineCallbackTests.test_coroutineNoCircularReference.<locals>.func¯  s   è è € ØˆHrA   N)rÛ  r   r4   r   )ræ  r²  r³  r!   r=   ra   r  r¡   )rf   ÚobjÚ
objWeakRefr   ÚfuncDÚfuncDWeakRefs         r?   Ú!test_coroutineNoCircularReferencez5InlineCallbackTests.test_coroutineNoCircularReference£  sÁ   € õ ™œˆÝ”[ Ñ%Ô%ˆ
ð	ð 	ð 	ð 	õ Ô& t t¨C¡y¤yÑ1Ô1ˆØ×Ò˜˜d×2Ò2°5Ñ9Ô9Ñ:Ô:Ð:å”{ 5Ñ)Ô)ˆð Øð 	×Ò˜*˜*™,œ,Ñ'Ô'Ð'Ø×Ò˜,˜,™.œ.Ñ)Ô)Ð)Ð)Ð)rA   Nr„   )rH   rI   rJ   r¨  rÇ  rÈ  r.   r'  rK   rA   r?   r  r  ‹  s\   € € € € € ðWð Wð Wð Wð. €V„]�5Ð9Ñ:Ô:ð*ð *ð *ñ ;Ô:ð*ð *ð *rA   r  )r2   r3   r4   r5   )rL   rM   r4   rN   )rÍ  r;  r4   rÎ  )r<  r8   r=  r>  r4   r²   )r¸  r   r4   rN   )crj   Ú
__future__r   rþ  rB   r“  rK  ri  r©  r1   rÇ  rU  r²  Úasyncior   r   r   r   rÂ  Útypingr   r	   r
   r   r   r   r   r   r   r   r   r   r   r   r   r   Úhamcrestr   r   r   Ú
hypothesisr   Úhypothesis.strategiesr   Útyping_extensionsr   Útwisted.internetr   r   Útwisted.internet.deferr    r!   r"   r#   r$   r%   r&   r'   r(   r)   r*   r+   Útwisted.internet.taskr,   Útwisted.pythonr-   Útwisted.python.compatr.   Útwisted.python.failurer0   Útwisted.trialrD   r¸  rF   rT   rU   rX   r^   rl   ÚSynchronousTestCaser†   r±  rÕ  r×  rî  r  rF  rƒ  rº  rÅ  r  rA  rC  rŸ  r´  r¾  rÀ  rá  r  rK   rA   r?   ú<module>r7     s"  ððð ð #Ð "Ð "Ð "Ð "Ð "à Ð Ð Ð Ø Ð Ð Ð Ø 	€	€	€	Ø 	€	€	€	Ø Ð Ð Ð Ø €€€Ø Ð Ð Ð Ø €€€Ø €€€ðð ð ð ð ð ð ð ð ð ð ð ðð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð& 2Ð 1Ð 1Ð 1Ð 1Ð 1Ð 1Ð 1Ð 1Ð 1Ø Ð Ð Ð Ð Ð Ø *Ð *Ð *Ð *Ð *Ð *Ø )Ð )Ð )Ð )Ð )Ð )à +Ð +Ð +Ð +Ð +Ð +Ð +Ð +ðð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð ð (Ð 'Ð 'Ð 'Ð 'Ð 'Ø Ð Ð Ð Ð Ð Ø 'Ð 'Ð 'Ð 'Ð 'Ð 'Ø *Ð *Ð *Ð *Ð *Ð *Ø "Ð "Ð "Ð "Ð "Ð "ðð ð ð ð	ð 	ð 	ð 	ð 	�9ñ 	ô 	ð 	ð)ð )ð )ð )ð ˆg�m¨9Ð5Ñ5Ô5€ð4ð 4ð 4ð 4ð 4ñ 4ô 4ð 4ð,*Mð *Mð *Mð *Mð *M�Ô!ñ *Mô *Mð *MðZ@9ð @9ð @9ð @9ð @9�HÔ0Ð2Gñ @9ô @9ð @9ðF4ð ð ð ð ñ ô ð ðð ð ð ð&~7ð ~7ð ~7ð ~7ð ~7�Ô,ñ ~7ô ~7ð ~7ðB;$ð ;$ð ;$ð ;$ð ;$�hÔ2ñ ;$ô ;$ð ;$ð|L$ð L$ð L$ð L$ð L$˜Ô5ñ L$ô L$ð L$ð^GIð GIð GIð GIð GI˜XÔ9ñ GIô GIð GIðTc3ð c3ð c3ð c3ð c3ˆxÔ+ñ c3ô c3ð c3ðLEð Eð Eð Eð E˜XÔ9ñ Eô Eð Eð"A'ð A'ð A'ð A'ð A'˜8Ô7Ð9Nñ A'ô A'ð A'ðHz=ð z=ð z=ð z=ð z= (Ô"3ñ z=ô z=ð z=ðzð ð ð ðS@ð S@ð S@ð S@ð S@˜hÔ:ñ S@ô S@ð S@ðlA%ð A%ð A%ð A%ð A%˜(Ô+ñ A%ô A%ð A%ðH
ð 
ð 
ð 
ð 
˜Ô)Ð+@ñ 
ô 
ð 
ð,	ð 	ð 	ð 	ðs5ð s5ð s5ð s5ð s5 Ô!2ñ s5ô s5ð s5ðls8ð s8ð s8ð s8ð s8 Ô 1ñ s8ô s8ð s8ðl3*ð 3*ð 3*ð 3*ð 3*˜(Ô6ñ 3*ô 3*ð 3*ð 3*ð 3*rA   