YfdZddlZddlZddlZddlmZddlmZm Z m Z m Z m Z ddl mZmZddlmZmZmZmZmZmZmZddlmZddlmZmZd Zd Zd%d e edfd efd Z d%d e edfd dfdZ!Gdde"Z#GddeZ$GddeZ%GddeZ&GddeZ'GddeZ(Gdde"Z)Gdde"Z*Gdd e"Z+Gd!d"eZ,Gd#d$eZ-dS)&z0 Tests for L{twisted.internet.inlineCallbacks}. N)Enum)Any GeneratorListSetUnion)reactortask)CancelledErrorDeferredFailurefailinlineCallbacks returnValuesucceed)_PYPY)SynchronousTestCaseTestCasecXt}tjd|j||SNr)r r callLatercallback)valueds U/var/www/html/env/lib/python3.11/site-packages/twisted/internet/test/test_inlinecb.pygetValueViaDeferredrs' A aU+++ Hc0Kt|d{VSNr)rs rgetValueViaCoror!#s&$U++ + + + + + ++rmsgreturncb t|#t$rt}YnwxYw|S)z6 Make a L{Failure} of a divide-by-zero error. )ZeroDivisionError BaseExceptionr )r"fs rgetDivisionFailurer('sB$$$  II Hs ,,cNKtdd{Vt|)z> Make a coroutine that throws a divide-by-zero error. rN)rr%)r"s rgetDivisionFailureCoror*2s6 g & &&&&&&&& C  rceZdZdZdS)TerminalExceptionz[ Just a specific exception type for use in inlineCallbacks tests in this file. N__name__ __module__ __qualname____doc__rrr,r,:s  Drr,ceZdZdZdZdZdZdZdZdZ dZ d Z d Z d Z d Zd ZdZdZdZdZejedddZdS) BasicTestsar This test suite tests basic use cases of L{inlineCallbacks}. For more complex tests see e.g. StackedInlineCallbacksTests. Note that it is important to directly call addCallbacks and other functions exposed as an API, because both L{inlineCallbacks} and L{Deferred} may be optimized in ways that are only exercised in particular situations. cntfd}|jdS)z Test that a normal inlineCallbacks works. Tests yielding a deferred which callbacks, as well as a deferred errbacks. Also ensures returning a final value works. c3KtdV}|d tdVn:#t$r-}t |dYd}~nd}~wwxYwdSNhiOMGWOOSH)r assertEqualr(r%strxeselfs r _genBasicsz)BasicTests.testBasics.._genBasicsUs)$////A   Q % % % 0(//////$ 0 0 0  Q//////// 07s> A5#A00A5r:r addCallbackr;r@rAs` r testBasicszBasicTests.testBasicsNsI       z||''(8'BBBrcntfd}|jdS)zS C{inlineCallbacks} can yield a coroutine and catch its exception. c3KtdV}|d tdVdS#t$r=}t |dt dYd}~dSd}~wwxYwr7)r!r;r*r%r<rr=s rrAz.BasicTests.testBasicsAsync.._genBasicshs%d++++A   Q % % % %,U3333333$ % % %  Q///G$$$$$$$$$ %s? B 2BBr:rBrDs` rtestBasicsAsynczBasicTests.testBasicsAsynccsI  % % % %  %z||''(8'BBBrchtd}||tS)z Ensure that a generator that produces an exception signals a Failure condition on result deferred by converting the exception to a L{Failure}. c36KtdVddz dS)Nr8rr r2rr_genProduceExceptionz>BasicTests.testProducesException.._genProduceException}s'%d++ + + + EEEEr)r assertFailurer%)r@rLs rtestProducesExceptionz BasicTests.testProducesExceptionvs@     !!"6"6"8"8:KLLLrchtd}||jdS)z9Test that a generator which never yields results in None.c3 KdSrr2r2rr _genNothingz+BasicTests.testNothing.._genNothings  rNrB)r@rQs r testNothingzBasicTests.testNothings>     {}}(()94@@@rchtd}||jdS)z Create a Deferred Generator which yields a Deferred which fails and handles the exception which results. Assert that the Deferred Generator does not errback its Deferred. c3jK ttdVdS#t$rYdSwxYw)NHandled Terminal Failure)rr,r2rr_genHandledTerminalFailurezIBasicTests.testHandledTerminalFailure.._genHandledTerminalFailuresQ ,-GHHIIIIIII$    s $ 22NrB)r@rVs rtestHandledTerminalFailurez%BasicTests.testHandledTerminalFailuresA      *)++778H$OOOrctd}t}||}|td||jdS)z~ Just like testHandledTerminalFailure, only with a Deferred which fires asynchronously with an error. c36K |VdS#t$rYdSwxYwrr,rs r_genHandledTerminalAsyncFailurezSBasicTests.testHandledTerminalAsyncFailure.._genHandledTerminalAsyncFailures: $    s  rUN)rr errbackr,rCr;)r@r\rdeferredGeneratorResultDeferreds rtestHandledTerminalAsyncFailurez*BasicTests.testHandledTerminalAsyncFailuresn      JJ*I*I!*L*L' #$>??@@@.::4;KTRRRrctfdtfd}t|}td||jdS)z Just like testHandledCoroAsyncFailure, only with a Deferred which fires asynchronously with an error and is wrapped in coroutine. cKd{VSrr2r[srcoroz4BasicTests.testHandledCoroAsyncFailure..coros777777Nrc3HK VdS#t$rYdSwxYwrrZ)rbsrfunctionz8BasicTests.testHandledCoroAsyncFailure..functionsA dff $    s  !!rUN)r rr]r,rCr;)r@rdinlineResultDeferredrbrs @@rtestHandledCoroAsyncFailurez&BasicTests.testHandledCoroAsyncFailures JJ             JJ'xzz #$>??@@@#//0@$GGGrchtd}||jdS)zj Make sure we don't blow the stack when yielding immediately available deferreds. c3PKtdD]}tdVdSNirKr)rangerr>s r_genStackUsagez1BasicTests.testStackUsage.._genStackUsages54[[ ! !ajj    1rrrB)r@rls rtestStackUsagezBasicTests.testStackUsages@      ~++D,._genStackUsage2s+4[[  1rrrB)r@rps rtestStackUsage2zBasicTests.testStackUsage2s@        ,,T-=qAAArcld}t|}||jdS)z Ensure that yielding a non-deferred passes it back as the result of the yield expression. @return: A L{twisted.internet.Deferred} @rtype: L{twisted.internet.Deferred} c3KdVdSNr2r2rr_testz.BasicTests.testYieldNonDeferred.._testsGGG1rrurB)r@rvs rtestYieldNonDeferredzBasicTests.testYieldNonDeferreds?    &&uww""4#3Q777rcld}t|}||jdS)z9Ensure a standard python return results in a None result.c3KdVdSrtr2r2rr _noReturnz/BasicTests.testReturnNoValue.._noReturnsGGG FrNrB)r@rzs rtestReturnNoValuezBasicTests.testReturnNoValues?   $I.. y{{&&t'7>>>rcltd}|}|}|dt||t |dd|d|dd||jdS)z?C{returnValue} is now deprecated but continues to be available.c30KdVtddS)Nrurr2rr_returnz5BasicTests.testReturnValueDeprecated.._returnsGGG NNNNNrrKrcategory._noYields1rrNrrr< assertRaises TypeErrorr@rs rtest_nonGeneratorReturnz"BasicTests.test_nonGeneratorReturnsS    #8,, 'T->->y(-S-S)T)TUUUUUrc d}t|}|dt|t|dS)z Ensure that C{TypeError} with a message about L{inlineCallbacks} is raised when a non-generator calls L{returnValue}. c$tddSrtrr2rrrz9BasicTests.test_nonGeneratorReturnValue.._noYield(s NNNNNrrNrrs rtest_nonGeneratorReturnValuez'BasicTests.test_nonGeneratorReturnValue"sS    #8,, 'T->->y(-S-S)T)TUUUUUrcdtjtfdtfd}|}d||}|}|dt||t|dd| d|dd| d|| d || d |d S) z When one inlineCallbacks calls another, the internal L{_DefGen_Return} flow control exception raised by calling L{defer.returnValue} doesn't leak into tracebacks captured in the caller. c3XKtjdVtddS)zG This is the inner function using returnValue. rz"actual-value-not-used-for-the-testN)r deferLaterrclocksr_returnszEBasicTests.test_internalDefGenReturnValueDoesntLeak.._returns7s6 /%++ + + + < = = = = =rc3K Vtd#t$rtjcYSwxYw)Nzboom returnValuer, traceback format_excrsr_raiseszDBasicTests.test_internalDefGenReturnValueDoesntLeak.._raises?s] .hjj   '(:;;;$ . . . +----- . AArrKrrr_DefGen_ReturnBDuring handling of the above exception, another exception occurredz1test_inlinecb.TerminalException: boom returnValueN) r ClockradvancesuccessResultOfrr;rrrr assertNotIn)r@rrtbrrrs @@r(test_internalDefGenReturnValueDoesntLeakz3BasicTests.test_internalDefGenReturnValueDoesntLeak/sO    > > > >  >  . . . .  . GII a  ! !! $ $%%'' CMM*** ((1+j*ABBB J QK "   )2...  PRT    I2NNNNNrcdtjtfdtfd}|}d||}|d||d||d|dS)a When one inlineCallbacks calls another, the internal L{StopIteration} flow control exception generated when the inner generator returns doesn't leak into tracebacks captured in the caller. This is similar to C{test_internalDefGenReturnValueDoesntLeak} but the inner function uses the "normal" return statemement rather than the C{returnValue} helper. c3:KtjdVdS)Nrr~)r rrsrrzABasicTests.test_internalStopIterationDoesntLeak.._returnshs$/%++ + + +1rc3K Vtd#t$rtjcYSwxYw)Nzboom normal returnrrsrrz@BasicTests.test_internalStopIterationDoesntLeak.._raisesms] .hjj   '(<===$ . . . +----- .rr StopIterationrz3test_inlinecb.TerminalException: boom normal returnN)r rrrrrr)r@rrrrrs @@r$test_internalStopIterationDoesntLeakz/BasicTests.test_internalStopIterationDoesntLeak\s          . . . .  . GII a  ! !! $ $ "---  PRT    KRPPPPPrzGC works differently on PyPy.r#Nct}tj|}tdtdtfd}||}||||tj|}~~||||dS)a When using L{defer.inlineCallbacks}, after the function exits, it will not keep references to the function itself or the arguments. This ensures that the machinery gets deallocated immediately rather than waiting for a GC, on CPython. The GC on PyPy works differently (del doesn't immediately deallocate the object), so we skip the test. ar#c3K|V|Srr2rs rfuncz@BasicTests.test_inlineCallbacksNoCircularReference..funcsGGGHrN)setweakrefrefrrr;r assertIsNone)r@obj objWeakRefrfuncD funcDWeakRefs r'test_inlineCallbacksNoCircularReferencez2BasicTests.test_inlineCallbacksNoCircularReferences[%%  C C      S  d22599:::{5))    **,,''' ,,..)))))rr#N)r.r/r0r1rErHrNrRrWr_rfrmrqrwr{rrrrrpyunitskipIfrrr2rrr4r4CsgCCC*CCC& M M MAAAPPP SSS$HHH. A A A B B B888" ? ? ?222( V V V V V V+O+O+OZ$Q$Q$QLV]59::!*!*!*;:!*!*!*rr4ceZdZdZdZdS)StopIterationReturnTestsz On Python 3.4 and newer generator functions may use the C{return} statement with a value, which is attached to the L{StopIteration} exception that is raised. L{inlineCallbacks} will use this value when it fires the C{callback}. cdti}td|t}|d|}|d|||ddS)z If the C{return} statement has a value it is propagated back to the L{Deferred} that the C{inlineCallbacks} function returned. rz> @inlineCallbacks def f(d): yield d return 14 r'N)rexecr rr;r)r@environd1d2s rtest_returnWithValuez-StopIterationReturnTests.test_returnWithValues %o6     ZZ WS\"   D --b11266666rN)r.r/r0r1rr2rrrrs-77777rrcNeZdZdZdZdZdZdZdZdZ dZ d Z d Z d Z d S) StackedInlineCallbacksTestsz We have an optimization that invokes generators directly when an inlineCallbacks-decorated function yields value directly to yield of another inlineCallbacks-decorated function. c|D]E\}}t|tr||0||FdS)z Given a list of L{Deferred}, value tuples, invokes each L{Deferred} with the corresponding value. Depending on whether value is an exception, either callback or errback is called. N) isinstance Exceptionr]r)r@ deferredListrr>s rrunCallbacksOnDeferredsz3StackedInlineCallbacksTests.runCallbacksOnDeferredssU !  DAq!Y''  !  1   rcJggtfdtfdtfd}|d}||||d|gddS)z Tests the case when a chain of L{inlineCallbacks} calls end up yielding and blocking on a L{Deferred}. c3Kd|ft}||f|V}|dz }d|f|SNf1 enterrKf1 exitappendr r>rr expectationss rf1zIStackedInlineCallbacksTests.test_nonCalledDeferredSingleYield..f1o   Q 0 0 0 A   A ' ' 'A FA   A / / /Hrc3Kd|f|V}|dz }d|f|SNf2 enterf2 exitrr>rrs rf2zIStackedInlineCallbacksTests.test_nonCalledDeferredSingleYield..f2V   Q 0 0 0bee A FA   A / / /Hrc3Kd|f|V}|dz }d|f|SNf3 enterf3 exitrr>rrs rf3zIStackedInlineCallbacksTests.test_nonCalledDeferredSingleYield..f3rrrKrrKrrKrrKrrrrrrNrrr;rr@rresrrrrs @@@@r!test_nonCalledDeferredSingleYieldz=StackedInlineCallbacksTests.test_nonCalledDeferredSingleYields                           bee $$\222 --c22A666      rc0ggtfdfdtfd}|d}||||d|gddS)z Tests the case when a chain of L{inlineCallbacks} mixed with coroutine calls end up yielding and blocking on a L{Deferred}. c3Kd|ft}||f|V}|dz }d|ft|dSrrr rrs rrzMStackedInlineCallbacksTests.test_nonCalledDeferredSingleYieldCoro..f1y   Q 0 0 0 A   A ' ' 'A FA   A / / / NNNNNrcKd|f|d{V}|dz }d|f|Srrrs rrzMStackedInlineCallbacksTests.test_nonCalledDeferredSingleYieldCoro..f2(s^   Q 0 0 0bee A FA   A / / /Hrc3Kd|f|V}|dz }d|ft|dSrrrrs rrzMStackedInlineCallbacksTests.test_nonCalledDeferredSingleYieldCoro..f31s`   Q 0 0 0bee A FA   A / / / NNNNNrrKrrNrrs @@@@r%test_nonCalledDeferredSingleYieldCorozAStackedInlineCallbacksTests.test_nonCalledDeferredSingleYieldCoros                        bee $$\222 --c22A666      rcZggtfdtfdtfd}|d}D]\}}|||||d|gddS)z Tests the case when a chain of L{inlineCallbacks} calls end up yielding and blocking on a L{Deferred}. In this case the same decorated function is yielded multiple times. c3Kd|ft}||f|V}|dz }d|f|Srrrs rrzLStackedInlineCallbacksTests.test_nonCalledDeferredMultipleYields..f1Vrrc3Kd|f|V}|V}|V}|dz }d|f|Srrrs rrzLStackedInlineCallbacksTests.test_nonCalledDeferredMultipleYields..f2bx   Q 0 0 0bee Abee Abee A FA   A / / /Hrc3Kd|f|V}|V}|V}|dz }d|f|Srrrs rrzLStackedInlineCallbacksTests.test_nonCalledDeferredMultipleYields..f3nrrrKrrrrrrr)rr )rr)rr~)rr~)rr~)r)rr )rr)rr)r )r )rr )rr )r )rr )r )rr)rr)r)rrNrrr;r r@rrrr>rrrrs @@@@r$test_nonCalledDeferredMultipleYieldsz@StackedInlineCallbacksTests.test_nonCalledDeferredMultipleYieldsKs                          bee   DAq JJqMMMM --c22B777          rc@ggtfdfdtfd}|d}D]\}}|||||d|gddS)z Tests the case when a chain of L{inlineCallbacks} calls mixed with async function calls end up yielding and blocking on a L{Deferred}. In this case the same decorated function is yielded multiple times. c3Kd|ft}||f|V}|dz }d|ft|dSrrrs rrzPStackedInlineCallbacksTests.test_nonCalledDeferredMultipleYieldsCoro..f1rrcKd|f|d{V}|d{V}|d{V}|dz }d|f|Srrrs rrzPStackedInlineCallbacksTests.test_nonCalledDeferredMultipleYieldsCoro..f2s   Q 0 0 0bee Abee Abee A FA   A / / /Hrc3Kd|f|V}|V}|V}|dz }d|ft|dSrrrs rrzPStackedInlineCallbacksTests.test_nonCalledDeferredMultipleYieldsCoro..f3s   Q 0 0 0bee Abee Abee A FA   A / / / NNNNNrrKrrNrrs @@@@r(test_nonCalledDeferredMultipleYieldsCorozDStackedInlineCallbacksTests.test_nonCalledDeferredMultipleYieldsCoros                        bee   DAq JJqMMMM --c22B777          rcgtfdfdtfd}|||dd|gddS)a Tests the case when a L{Deferred} produced from L{inlineCallbacks} gets a callback added via L{addCallback} and then yielded in a function decorated with L{inlineCallbacks}. In this case the initial L{Deferred} already has a value. c3zKd|f|V}|dz }d|f|Srrr>rs rrzQStackedInlineCallbacksTests.test_intermediateAddCallbacksAndNoWaiting..f1sN   Q 0 0 0A FA   A / / /Hrcnd|f|dz }d|f|Srrrs rrzQStackedInlineCallbacksTests.test_intermediateAddCallbacksAndNoWaiting..f2A   Q 0 0 0 FA   A / / /Hrc3Kd|f|}||V}|dz }d|f|SrrrCr>rrrrs rrzQStackedInlineCallbacksTests.test_intermediateAddCallbacksAndNoWaiting..f3 m   Q 0 0 01A MM"   A FA   A / / /HrrKrrrrrrrrN)rr;r)r@rrrrs @@@r)test_intermediateAddCallbacksAndNoWaitingzEStackedInlineCallbacksTests.test_intermediateAddCallbacksAndNoWaitings                      --bbee44a888      rc0ggtfdfdtfd}|d}||||d|gddS)a4 Tests the case when a L{Deferred} produced from L{inlineCallbacks} gets a callback added via L{addCallback} and then yielded in a function decorated with L{inlineCallbacks}. In this case the initial L{Deferred} does not have a value and blocks entire callback chain. c3Kd|ft}||f|V}|dz }d|f|Srrrs rrz]StackedInlineCallbacksTests.test_intermediateAddCallbacksAndWithWaitingFirstYield..f10rrcnd|f|dz }d|f|Srrrs rrz]StackedInlineCallbacksTests.test_intermediateAddCallbacksAndWithWaitingFirstYield..f2<rrc3Kd|f|}||V}|dz }d|f|Srrrs rrz]StackedInlineCallbacksTests.test_intermediateAddCallbacksAndWithWaitingFirstYield..f3Br rrKrr!Nrrs @@@@r5test_intermediateAddCallbacksAndWithWaitingFirstYieldzQStackedInlineCallbacksTests.test_intermediateAddCallbacksAndWithWaitingFirstYield$s                       bee $$\222 --c22A666      rc0ggtfdfdtfd}|d}||||d|gddS)a Tests the case when a L{Deferred} produced from L{inlineCallbacks} gets a callback added via L{addCallback} and then yielded in a function decorated with L{inlineCallbacks}. In this case the initial L{Deferred} does not have a value and blocks the entire callback chain. Additionally, a subsequent L{Deferred} blocks the entire callback chain again. c3Kd|ft}||f|V}|dz }d|f|Srrrs rrz^StackedInlineCallbacksTests.test_intermediateAddCallbacksAndWithWaitingSecondYield..f1lrrcnd|f|dz }d|f|Srrrs rrz^StackedInlineCallbacksTests.test_intermediateAddCallbacksAndWithWaitingSecondYield..f2xrrc3Kd|f|V}|}||V}|dz }d|f|Srrrs rrz^StackedInlineCallbacksTests.test_intermediateAddCallbacksAndWithWaitingSecondYield..f3~s~   Q 0 0 0bee A1A MM"   A FA   A / / /HrrKr )rrrrr)rr )rru)rr Nrrs @@@@r6test_intermediateAddCallbacksAndWithWaitingSecondYieldzRStackedInlineCallbacksTests.test_intermediateAddCallbacksAndWithWaitingSecondYield^s                       bee $$\222 --c22A666      rcRggGddttfdtfd}|d}|dgddS) z Tests the case when a function decorated with L{inlineCallbacks} yields a L{Deferred} that results in a failure. ceZdZdS)iStackedInlineCallbacksTests.test_raisesExceptionFromDeferredWithWaitingFirstCallback..MyExceptionNr.r/r0r2rr MyExceptionr0 Drr2c3Kd|ft}|f|V}d|f|SNrrrr>rr2rrs rrz`StackedInlineCallbacksTests.test_raisesExceptionFromDeferredWithWaitingFirstCallback..f2o   Q 0 0 0 A   KKMM 2 3 3 3A   A / / /Hrc3Kd|f5|V}dddn #1swxYwY|dz }d|f|Srrr)r>r2rrr@s rrz`StackedInlineCallbacksTests.test_raisesExceptionFromDeferredWithWaitingFirstCallback..f3s   Q 0 0 0"";//  "Q%%KK               FA   A / / /HsA  AArKru)rr)rruNrrrr;r)r@rrr2rrrs` @@@@r8test_raisesExceptionFromDeferredWithWaitingFirstCallbackzTStackedInlineCallbacksTests.test_raisesExceptionFromDeferredWithWaitingFirstCallbacks        )                      bee $$\222 --c22A666          rc|ggGddttfdtfdtfd}|d}|dgdd S) a  Tests the case when a function decorated with L{inlineCallbacks} blocks on a L{Deferred} produced by another function decorated with L{inlineCallbacks}. Once that unblocks, a L{Deferred} that results in an failure is yielded. ceZdZdS)jStackedInlineCallbacksTests.test_raisesExceptionFromDeferredWithWaitingSecondCallback..MyExceptionNr1r2rrr2r>r3rr2c3Kd|ft}||f|V}|dz }d|f|Srrrs rrzaStackedInlineCallbacksTests.test_raisesExceptionFromDeferredWithWaitingSecondCallback..f1rrc3Kd|ft}|f|V}d|f|Sr5rr6s rrzaStackedInlineCallbacksTests.test_raisesExceptionFromDeferredWithWaitingSecondCallback..f2r7rc3Kd|f|V}5|V}dddn #1swxYwY|dz }d|f|Srr9)r>r2rrrr@s rrzaStackedInlineCallbacksTests.test_raisesExceptionFromDeferredWithWaitingSecondCallback..f3s   Q 0 0 0bee A"";//  "Q%%KK               FA   A / / /HsAAArKr~)rrrr")rr~Nr:)r@rrr2rrrrs` @@@@@r9test_raisesExceptionFromDeferredWithWaitingSecondCallbackzUStackedInlineCallbacksTests.test_raisesExceptionFromDeferredWithWaitingSecondCallbacksM       )                               bee $$\222 --c22A666      rN)r.r/r0r1rrrrrr#r(r-r;rBr2rrrrs   8 8 8 t7 7 7 rR R R hQ Q Q f0 0 0 d8 8 8 t= = = ~0 0 0 dA A A A A rrc*eZdZdZdZdZdZdZdS)NonLocalExitTestsa It's possible for L{returnValue} to be (accidentally) invoked at a stack level below the L{inlineCallbacks}-decorated function which it is exiting. If this happens, L{returnValue} should report useful errors. If L{returnValue} is invoked from a function not decorated by L{inlineCallbacks}, it will emit a warning if it causes an L{inlineCallbacks} function further up the stack to exit. c$tddS)z This method mistakenly invokes L{returnValue}, despite the fact that it is not decorated with L{inlineCallbacks}. rKNrr@s rmistakenMethodz NonLocalExitTests.mistakenMethods Arc||dg||jg}|t|d||ddt||ddt|d|dd||dddd S) ac Flush the current warnings and assert that we have been told that C{mistakenMethod} was invoked, and that the result from the Deferred that was fired (appended to the given list) is C{mistakenMethod}'s result. The warning should indicate that an inlineCallbacks function called 'inline' was made to exit. rK)offendingFunctionsrrrrrzreturnValue() in 'mistakenMethod' causing 'inline' to exit: returnValue should only be invoked by functions decorated with inlineCallbacksN)r;rrGrrr)r@ resultListrs rassertMistakenMethodWarningz-NonLocalExitTests.assertMistakenMethodWarning%s aS)))%%$:M9N%OO X*** !Z02DEEE !Z02DEEE J QK "     QK "      rctfd}|}g}||j|dS)z L{returnValue} will emit a non-local exit warning in the simplest case, where the offending function is invoked immediately. c3ZKtddVdS)NrrrGrrFsrinlinezANonLocalExitTests.test_returnValueNonLocalWarning..inlineCs1    ! ! ! NNNGGGGGrN)rrCrrK)r@rOrresultss` rtest_returnValueNonLocalWarningz1NonLocalExitTests.test_returnValueNonLocalWarning=sh        FHH gn%%% ((11111rcttfd}|}g}||j|gd|dS)z L{returnValue} will emit a non-local warning in the case where the L{inlineCallbacks}-decorated function has already yielded a Deferred and therefore moved its generator function along. c3ZKVtddS)NrrN)causer@srrOzBNonLocalExitTests.test_returnValueNonLocalDeferred..inlineVs1KKK    ! ! ! NNNNNrrKN)r rrCrr;rrK)r@rOeffectrPrTs` @r test_returnValueNonLocalDeferredz2NonLocalExitTests.test_returnValueNonLocalDeferredNs           7>*** "%%% q ((11111rN)r.r/r0r1rGrKrQrVr2rrrDrDsZ   0222"22222rrDc.eZdZdZdZdZdZddZdS) ForwardTraceBackTestsc6tdtfd}|}||}|}|d||d||d|dS)z Chained inlineCallbacks are forwarding the traceback information from generator to generator. A first simple test with a couple of inline callbacks. c3,KdVtdNzforcing generator Error Markerrr2rrerroringz>ForwardTraceBackTests.test_forwardTracebacks..erroringm % % % %N++ +rc3$KVdSrr2r^srcallingz=ForwardTraceBackTests.test_forwardTracebacks..callingr(**     r in erroring in callingr\N)rfailureResultOf getTracebackr)r@rbrr'rr^s @rtest_forwardTracebacksz,ForwardTraceBackTests.test_forwardTracebackses  , ,  ,        GII   # # ^^   mR((( lB''' nb)))))rcldtfd}|}|jfd}|S)z Chained inlineCallback and coroutine are forwarding the traceback information from coroutine to generator. cNKtdd{Vtd)Nrr\)rrr2rrr^zBForwardTraceBackTests.test_forwardTracebacksCoro..errorings4%g.. . . . . . . .N++ +rc3$KVdSrr2rasrrbzAForwardTraceBackTests.test_forwardTracebacksCoro..callingrcrc|}d|d|d|dS)Nrdrer\)rgr)r'rr@s rcheckz?ForwardTraceBackTests.test_forwardTracebacksCoro..checksT!!B MM- , , , MM, + + + MM." - - - - -r)r addErrback)r@rbrrmr^s` @rtest_forwardTracebacksCoroz0ForwardTraceBackTests.test_forwardTracebacksCoro}sq  , , ,        GII  . . . .  . rcVtdtfdtfdtfd}|}||}|}|d||d||d||d||d ||d ||d|d S) a Several Chained inlineCallbacks gives information about all generators. A wider test with a 4 chained inline callbacks. Application stack-trace should be reported, and implementation details like "throwExceptionIntoGenerator" symbols are omitted from the stack. Note that the previous test is testing the simple case, and this one is testing the deep recursion case. That case needs specific code in failure.py to accomodate to stack breakage introduced by throwExceptionIntoGenerator. Hence we keep the two tests in order to sort out which code we might have regression in. c3,KdVtdr[r]r2rrr^zDForwardTraceBackTests.test_forwardLotsOfTracebacks..erroringr_rc3$KVdSrr2rasrcalling3zDForwardTraceBackTests.test_forwardLotsOfTracebacks..calling3rcrc3$KVdSrr2rssrcalling2zDForwardTraceBackTests.test_forwardLotsOfTracebacks..calling2rcrc3$KVdSrr2rvsrrbzCForwardTraceBackTests.test_forwardLotsOfTracebacks..callingrcrrdre in calling2 in calling3throwExceptionIntoGeneratorr\Nrrfrgrrr@rbrr'rrvrsr^s @@@rtest_forwardLotsOfTracebacksz2ForwardTraceBackTests.test_forwardLotsOfTracebackss]&  , ,  ,                      GII   # # ^^   mR((( lB''' mR((( mR((( 6;;; nb))) mQ^^%5%566666rc<tdfdtfdtfd}|}||}|}|d||d||d||d||d ||d ||d|d S) z Several chained inlineCallbacks mixed with coroutines gives information about all generators. A wider test with a 4 chained inline callbacks. c3,KdVtdr[r]r2rrr^zHForwardTraceBackTests.test_forwardLotsOfTracebacksCoro..erroringr_rc,Kd{VdSrr2rasrrszHForwardTraceBackTests.test_forwardLotsOfTracebacksCoro..calling3s+(**         rc3$KVdSrr2rusrrvzHForwardTraceBackTests.test_forwardLotsOfTracebacksCoro..calling2rcrc3$KVdSrr2rxsrrbzGForwardTraceBackTests.test_forwardLotsOfTracebacksCoro..callingrcrrdreryrzr{r\Nr|r}s @@@r test_forwardLotsOfTracebacksCoroz6ForwardTraceBackTests.test_forwardLotsOfTracebacksCorosQ  , ,  ,                    GII   # # ^^   mR((( lB''' mR((( mR((( 6;;; nb))) mQ^^%5%566666rr#Ncptd}t} |n$#t$r|YnwxYwdt dt ttdffd}t|| |}tj | }| t|d|d|dd | d |dd| d |dd|d|d d | d |d d| d |d ddS)z L{defer.inlineCallbacks} that receives tracebacks from a regular Deferred and re-raise tracebacks into their deferred should not lose their tracebacks. r"rr#Nc3K|VdS)aJ This is never called. It is only used as the decorated function. The resulting function is never called in this test. This is used to make sure that if we wrap an already failed deferred, inlineCallbacks will not add any extra traceback frames. Nr2r[s riczDForwardTraceBackTests.test_reraiseTracebacksFromDeferred..icsGGGGGrr  test_inlinecbrrr(zraise ZeroDivisionError(msg)"test_reraiseTracebacksFromDeferredzf.raiseException())r(r raiseExceptionr&r]objectrrrrfr extract_tbgetTracebackObjectr;rr)r@r'rr newFailurers rrz8ForwardTraceBackTests.test_reraiseTracebacksFromDeferreds u % %$JJ           IIKKKKK  & YsC~6     ))!,,  !*"?"?"A"A B B R!$$$ or!uQx000 -r!uQx888 7AqBBB or!uQx000 =r!uQxHHH -r!uQx88888s4AAr)r.r/r0rhror~rrr2rrrXrXdsf***02-7-7-7^!7!7!7F"9"9"9"9"9"9rrXceZdZdZdS)UntranslatedErrorzL Untranslated exception type when testing an exception translation. Nr-r2rrrr rrceZdZdZdS)TranslatedErrorzJ Translated exception type when testing an exception translation. Nr-r2rrrrrrrceZdZdZdZdS)DontFailz Sample exception type. cHt|||_dSr)r__init__ actualValue)r@actuals rrzDontFail.__init__s$4   !rN)r.r/r0r1rr2rrrrs-"""""rrceZdZdZdZdZdS)CancellationTestsStackedTyperrKrN)r.r/r0 NOT_STACKEDSTACKED_INLINECB STACKED_COROr2rrrr#sKLLLrrc&eZdZdZdZdZedZdZed+dZ dZ d,d Z d-d Z d Z d ZdZdZdZd-dZdZdZdZdZdZd-dZdZdZdZdZdZd-dZdZdZ d Z!d!Z"d"Z#d-d#Z$d$Z%d%Z&d&Z'd'Z(d(Z)d.d*Z*dS)/CancellationTestsa! Tests for cancellation of L{Deferred}s returned by L{inlineCallbacks}. For each of these tests, let: - C{G} be a generator decorated with C{inlineCallbacks} - C{D} be a L{Deferred} returned by C{G} - C{C} be a L{Deferred} awaited by C{G} with C{yield} cg|_dS)z> Set up the list of outstanding L{Deferred}s. N)deferredsOutstandingrFs rsetUpzCancellationTests.setUp2s%'!!!rcN|jr||jdSdS)zG If any L{Deferred}s are still outstanding, fire them. N)rdeferredGottenrFs rtearDownzCancellationTests.tearDown8sB' "    ! ! !' " " " " "rc#"K|V}|Srr2)r@getChildDeferredr>s rstackedInlineCBz!CancellationTests.stackedInlineCB?s""$$ $ $rc&K|d{VSrr2)r@rs r stackedCorozCancellationTests.stackedCoroDs'%%'''''''''rNc#ZK||j} |tjkr |V}nE|r|V|tjkr||V}n||V}n8#t $rtt$r}|j dz }Yd}~nd}~wwxYw|dzS)z Generator for testing cascade cancelling cases. @param getChildDeferred: Some callable returning L{Deferred} that we awaiting (with C{yield}) NrrK) getDeferredrrrrrrrrr)r@ stackTyper firstDeferredr>dfs rsampleInlineCBz CancellationTests.sampleInlineCBGs  ##/  #8DDD**,,,, ('''' < MMM"../?@@@@AA"223CDDDDA  $ $ $!## # # # #"AAAAAA #1u sA"A00!B% B  B%ch|jt|jdS)z A sample function that returns a L{Deferred} that can be fired on demand, by L{CancellationTests.deferredGotten}. @return: L{Deferred} that can be fired on demand. )rrr rFs rrzCancellationTests.getDeferredas- !((444(,,rc`|jd|dS)z Fire the L{Deferred} returned from the least-recent call to L{CancellationTests.getDeferred}. @param result: result object to be used when firing the L{Deferred}. rN)rpopr)r@results rrz CancellationTests.deferredGottenks/ !%%a((11&99999rFc2dgfd}d}|rt}||||}|d|r|d||dt ddS) z When C{D} cancelled, C{C} will be immediately cancelled too. @param stackType: defines test stacking scenario @param cancelOnSecondDeferred: if True, tests cancellation on the second yield in inlineCallbacks FAILUREcXt}fd}|||S)NcB|td<|Sr)rmr )rchildResultHolders r_ebzTCancellationTests.doCascadeCancellingOnCancel..getChildDeferred.._ebs'-||N'C'C!!$ rr rn)rrrs rrzGCancellationTests.doCascadeCancellingOnCancel..getChildDeferreds> A      LL   HrNrrrcdSrr2)rs rz?CancellationTests.doCascadeCancellingOnCancel..sDrrKrzno cascade cancelling occurs)r rrnrcancelr;r )r@rcancelOnSecondDeferredrrrrs @rdoCascadeCancellingOnCancelz-CancellationTests.doCascadeCancellingOnCancelts'K      ! '$JJM   -'    (()))  &  " "1 % % %    a  *     rcD|tjdSr)rrrrFs r(test_CascadeCancellingOnCancelNotStackedz:CancellationTests.test_CascadeCancellingOnCancelNotStacked  (()E)QRRRRRrcD|tjdSrrrrrFs r-test_CascadeCancellingOnCancelStackedInlineCbz?CancellationTests.test_CascadeCancellingOnCancelStackedInlineCb  (()E)VWWWWWrcH|tjddSNT)rrrFs r=test_CascadeCancellingOnCancelStackedInlineCbOnSecondDeferredzOCancellationTests.test_CascadeCancellingOnCancelStackedInlineCbOnSecondDeferred2 (( ( 9RV )     rcD|tjdSrrrrrFs r)test_CascadeCancellingOnCancelStackedCoroz;CancellationTests.test_CascadeCancellingOnCancelStackedCoro  (()E)RSSSSSrcH|tjddSrrrFs r9test_CascadeCancellingOnCancelStackedCoroOnSecondDeferredzKCancellationTests.test_CascadeCancellingOnCancelStackedCoroOnSecondDeferred1 (( ( 5d )     rcd}|rt}|||}|r|d||t ||jdS)a When C{D} cancelled, CancelledError from C{C} will be errbacked through C{D}. @param stackType: defines test stacking scenario @param cancelOnSecondDeferred: if True, tests cancellation on the second yield in inlineCallbacks N)rrrK)r rrrrr rfr)r@rrrrs rdoErrbackCancelledErrorOnCancelz1CancellationTests.doErrbackCancelledErrorOnCancels ! '$JJM   )=  Q Q  &  " "1 % % %   .$*>*>q*A*A*PQQQQQrcD|tjdSr)rrrrFs r"test_ErrbackCancelledErrorOnCancelz4CancellationTests.test_ErrbackCancelledErrorOnCancels  ,,-I-UVVVVVrcD|tjdSrrrrrFs r1test_ErrbackCancelledErrorOnCancelStackedInlineCbzCCancellationTests.test_ErrbackCancelledErrorOnCancelStackedInlineCbs* ,, ( 9     rcH|tjddSrrrFs rAtest_ErrbackCancelledErrorOnCancelStackedInlineCbOnSecondDeferredzSCancellationTests.test_ErrbackCancelledErrorOnCancelStackedInlineCbOnSecondDeferreds2 ,, ( 9RV -     rcD|tjdSrrrrrFs r-test_ErrbackCancelledErrorOnCancelStackedCoroz?CancellationTests.test_ErrbackCancelledErrorOnCancelStackedCoros  ,,-I-VWWWWWrcH|tjddSrrrFs r=test_ErrbackCancelledErrorOnCancelStackedCoroOnSecondDeferredzOCancellationTests.test_ErrbackCancelledErrorOnCancelStackedCoroOnSecondDeferreds1 ,, ( 5d -     rcBd}d}|rt}t||fd||}|r|d||t ||jdS)z When C{D} is cancelled, and C raises a particular type of error, C{G} may catch that error at the point of yielding and translate it into a different error which may be received by application code. cH|tdSr)r]rits rrz;CancellationTests.doErrorToErrorTranslation..cancels! JJ(** + + + + +rNcSrr2rsrrz=CancellationTests.doErrorToErrorTranslation..QrrrK)r rrrrrrfr)r@rrrrrrs @rdoErrorToErrorTranslationz+CancellationTests.doErrorToErrorTranslations , , , ! '$JJM V     &YYY)=     &  " "1 % % %   /4+?+?+B+B+QRRRRRrcD|tjdSr)rrrrFs rtest_ErrorToErrorTranslationz.CancellationTests.test_ErrorToErrorTranslations  &&'C'OPPPPPrcD|tjdSrrrrrFs r+test_ErrorToErrorTranslationStackedInlineCbz=CancellationTests.test_ErrorToErrorTranslationStackedInlineCbs  &&'C'TUUUUUrcH|tjddSrrrFs r;test_ErrorToErrorTranslationStackedInlineCbOnSecondDeferredzMCancellationTests.test_ErrorToErrorTranslationStackedInlineCbOnSecondDeferreds2 && ( 9RV '     rcD|tjdSrrrrrFs r'test_ErrorToErrorTranslationStackedCoroz9CancellationTests.test_ErrorToErrorTranslationStackedCoros  &&'C'PQQQQQrcH|tjddSrrrFs r7test_ErrorToErrorTranslationStackedCoroOnSecondDeferredzICancellationTests.test_ErrorToErrorTranslationStackedCoroOnSecondDeferreds1 && ( 5d '     rcBd}d}|rt}t||fd||}g}||j|r|d|||dgdS)z When C{D} is cancelled, and C{C} raises a particular type of error, C{G} may catch that error at the point of yielding and translate it into a result value which may be received by application code. cJ|tddS)Ni)r]rrs rrz=CancellationTests.doErrorToSuccessTranslation..cancels JJx~~ & & & & &rNcSrr2rsrrz?CancellationTests.doErrorToSuccessTranslation..rrrrKi)r rrCrrr assertEquals)r@rrrrrrPrs @rdoErrorToSuccessTranslationz-CancellationTests.doErrorToSuccessTranslations ' ' ' ! '$JJM V     &YYY)=    gn%%%  &  " "1 % % %   'D6*****rcD|tjdSr)rrrrFs rtest_ErrorToSuccessTranslationz0CancellationTests.test_ErrorToSuccessTranslationrrcD|tjdSrrrrrFs r-test_ErrorToSuccessTranslationStackedInlineCbz?CancellationTests.test_ErrorToSuccessTranslationStackedInlineCbrrcH|tjddSrrrFs r=test_ErrorToSuccessTranslationStackedInlineCbOnSecondDeferredzOCancellationTests.test_ErrorToSuccessTranslationStackedInlineCbOnSecondDeferredrrcD|tjdSrrrrrFs r)test_ErrorToSuccessTranslationStackedCoroz;CancellationTests.test_ErrorToSuccessTranslationStackedCoro#rrcH|tjddSrrrFs r9test_ErrorToSuccessTranslationStackedCoroOnSecondDeferredzKCancellationTests.test_ErrorToSuccessTranslationStackedCoroOnSecondDeferred&rrctfdfd}d}|rt}||||}|r|d|||d|||ddS)a" When C{D} is cancelled, it won't reach the callbacks added to it by application code until C{C} reaches the point in its callback chain where C{G} awaits it. Otherwise, application code won't be able to track resource usage that C{D} may be using. c<|tSr)trapr )r moreDeferreds r deferMeMorezACancellationTests.doAsynchronousCancellation..deferMeMore4s KK ' ' ' rcNt}||Srr)rr s rdeferMez=CancellationTests.doAsynchronousCancellation..deferMe8s# A LL % % %HrNrrKii)r rrrassertNoResultr;r)r@rrrrrr r s @@rdoAsynchronousCancellationz,CancellationTests.doAsynchronousCancellation+s zz             ! '$JJM   $      &  " "1 % % %   Ad### --a00$77777rcD|tjdSr)rrrrFs rtest_AsynchronousCancellationz/CancellationTests.test_AsynchronousCancellationJs  ''(D(PQQQQQrcD|tjdSrrrrrFs r,test_AsynchronousCancellationStackedInlineCbz>CancellationTests.test_AsynchronousCancellationStackedInlineCbMs  ''(D(UVVVVVrcH|tjddSrrrFs r.testFuncpsF     HHHHHs  ) r rrrrrr;rrftyper )r@canceller1Callscanceller2Callsrrfailurerrs @@r"test_inlineCallbacksCancelCapturedz4CancellationTests.test_inlineCallbacksCancelCaptured]s3524'(>??'(>??  )HV$4fd$BC          B B E""" "--- "---   2$/// "--- E"""  &&u-- ~666 2$/////r)NNr)Fr)+r.r/r0r1rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr$r2rrrr)s''' """_(((_2---::::% % % % NSSSXXX   TTT   RRRR(WWW      XXX   SSSS,QQQVVV   RRR   ++++0SSSXXX   TTT   8888>RRRWWW   SSS   505050505050rrr).r1runittestrrenumrtypingrrrrrtwisted.internetr r twisted.internet.deferr r r rrrrtwisted.python.compatrtwisted.trial.unittestrrrr!r<r(r*rr,r4rrrDrXrrrrrr2rrr,s 33333333333333********('''''@@@@@@@@   ,,,  E#t),     !!eCI&6!$!!!!        a*a*a*a*a*a*a*a*H 77777x777