+ DfjjRt^RIt^RIt^RIt^RIHt^RIHtH t H t H t H t ^RI HtHt^RIHtHtHtHtHtHtHt^RIHt^RIHtHtRtR tR$R R lltR$R R llt !RR]!4t"!RR]4t#!RR]4t$!RR]4t%!RR]4t&!RR]4t'!RR]!4t(!RR]!4t)!RR]!4t*!R R!]4t+!R"R#]4t,R#)%z0 Tests for L{twisted.internet.inlineCallbacks}. N)Enum)Any GeneratorListSetUnion)reactortask)CancelledErrorDeferredFailurefailinlineCallbacks returnValuesucceed)_PYPY)SynchronousTestCaseTestCasec^\4p\P!^VPV4V#)r r callLatercallback)valueds& E/usr/lib/python3/dist-packages/twisted/internet/test/test_inlinecb.pygetValueViaDeferredrs$ A aU+ Hc4"\V4GRjxL #L5iNr)rs&rgetValueViaCoror!#s$U+ ++ +s cJV^8dQhR\\R3,R\/#msgNreturn)rstrr )formats"r __annotate__r)'s#  E#t),  rcR\V4h \d\4pT#i;i)z. Make a L{Failure} of a divide-by-zero error. )ZeroDivisionError BaseExceptionr )r%fs& rgetDivisionFailurer.'s-$$  I Hs &&cBV^8dQhR\\R3,RR/#r#)rr')r(s"rr)r)2s#!!eCI&6!$!rcJ"\R4GRjxL \V4hL5i)z6 Make a coroutine that throws a divide-by-zero error. rN)rr+)r%s&rgetDivisionFailureCoror12s% g &&& C  ' #!#c]tRt^:tRtRtR#)TerminalExceptionzO Just a specific exception type for use in inlineCallbacks tests in this file. N__name__ __module__ __qualname____firstlineno____doc____static_attributes__r5rrr4r4:s   rr4ca]tRt^CtoRtRtRtRtRtRt Rt Rt R t R t R tR tR tRtRtRtRt]P,!]R4V3RlRl4tRtVtR#) BasicTestsaV 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. c da\V3Rl4pV!4PSPR4#)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. c3<"\R4xpSPVR4\R4xR# \d'pSP\ T4R4Rp?R#Rp?ii;i5i)hiOMGNWOOSH)r assertEqualr.r+r'xeselfs r _genBasics)BasicTests.testBasics.._genBasicsUsc)$//A   Q % 0(//% 0  Q// 0s* A' 3A' A$AA'A$$A'rCr addCallbackrDrHrIsf r testBasicsBasicTests.testBasicsNs4    |''(8(8'BBrc da\V3Rl4pV!4PSPR4#)zC C{inlineCallbacks} can yield a coroutine and catch its exception. c3<"\R4xpSPVR4\R4xR# \d2pSP\ T4R4\ R4Rp?R#Rp?ii;i5i)rArBrCN)r!rDr1r+r'rrEs rrI.BasicTests.testBasicsAsync.._genBasicshsa%d++A   Q % %,U33$ %  Q/G$$ %s* A2 3A2 A/&A*$A2*A//A2rCrKrMsf rtestBasicsAsyncBasicTests.testBasicsAsynccs4  %  %|''(8(8'BBrc P\R4pVPV!4\4#)z Ensure that a generator that produces an exception signals a Failure condition on result deferred by converting the exception to a L{Failure}. c3:"\R4x^^, R#5i)rANr r5rr_genProduceException>BasicTests.testProducesException.._genProduceException}s%d+ + EE)r assertFailurer+)rHrWs& rtestProducesException BasicTests.testProducesExceptionvs0    !!"6"8:KLLrc \\R4pV!4PVPR4#)z9Test that a generator which never yields results in None.c3"R#5i)FNr5r5rr _genNothing+BasicTests.testNothing.._genNothingssNrK)rHr_s& r testNothingBasicTests.testNothings3    }(()9)94@@rc \\R4pV!4PVPR4#)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. c3`"\\R44xR# \dR#i;i5i)Handled Terminal FailureN)r r4r5rr_genHandledTerminalFailureIBasicTests.testHandledTerminalFailure.._genHandledTerminalFailures- ,-GHII$  s.. +.+.NrK)rHrfs& rtestHandledTerminalFailure%BasicTests.testHandledTerminalFailures4     *+778H8H$OOrc \R4p\4pV!V4pVP\R44VP VP R4#)zf Just like testHandledTerminalFailure, only with a Deferred which fires asynchronously with an error. c3<"VxR# \dR#i;i5irr4rs&r_genHandledTerminalAsyncFailureSBasicTests.testHandledTerminalAsyncFailure.._genHandledTerminalAsyncFailures  $  s  reN)rr errbackr4rLrD)rHrnrdeferredGeneratorResultDeferreds& rtestHandledTerminalAsyncFailure*BasicTests.testHandledTerminalAsyncFailuresV     J*I!*L' #$>?@.::4;K;KTRRrc aa\4oV3Rlo\V3Rl4p\4oV!4pSP\R44VP VP R4#)z Just like testHandledCoroAsyncFailure, only with a Deferred which fires asynchronously with an error and is wrapped in coroutine. c$<"SGRjxL #L5irr5rmsrcoro4BasicTests.testHandledCoroAsyncFailure..coros7N7s c3H<"S!4xR# \dR#i;i5irrl)rvsrfunction8BasicTests.testHandledCoroAsyncFailure..functions# f $  s" " ""reN)r rrpr4rLrD)rHryinlineResultDeferredrvrs& @@rtestHandledCoroAsyncFailure&BasicTests.testHandledCoroAsyncFailuresb J      J'z #$>?@#//0@0@$GGrc \\R4pV!4PVP^4#)zR Make sure we don't blow the stack when yielding immediately available deferreds. c3L"\R4Fp\^4xK ^#5ii)rangerrFs r_genStackUsage1BasicTests.testStackUsage.._genStackUsages"4[aj !s"$rK)rHrs& rtestStackUsageBasicTests.testStackUsages4     ++D,<,._genStackUsage2s4[!rYrK)rHrs& rtestStackUsage2BasicTests.testStackUsage2s4      ,,T-=-=qAArc `Rp\V4pV!4PVP^4#)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} c3"^x^#5ir5r5rr_test.BasicTests.testYieldNonDeferred.._tests G rK)rHrs& rtestYieldNonDeferredBasicTests.testYieldNonDeferreds.  &w""4#3#3Q77rc `Rp\V4pV!4PVPR4#)z9Ensure a standard python return results in a None result.c3"^xR#5irNr5r5rr _noReturn/BasicTests.testReturnNoValue.._noReturns G rNrK)rHrs& rtestReturnNoValueBasicTests.testReturnNoValues. $I. {&&t'7'7>>rc >\R4pV!4pVP4pVP^\V44VP \ V^,R,4VP RV^,R,4VPVP^4#)z?C{returnValue} is now deprecated but continues to be available.c3,"^x\^4R#5irrr5rr_return5BasicTests.testReturnValueDeprecated.._returnsG Nscategory._noYieldsrrNrrr' assertRaises TypeErrorrHrs& rtest_nonGeneratorReturn"BasicTests.test_nonGeneratorReturns4  #8, 'T->->y(-S)TUrc  Rp\V4pVPR\VP\V444R#)zw Ensure that C{TypeError} with a message about L{inlineCallbacks} is raised when a non-generator calls L{returnValue}. c\^4R#rrr5rrr9BasicTests.test_nonGeneratorReturnValue.._noYield(s NrrNrrs& rtest_nonGeneratorReturnValue'BasicTests.test_nonGeneratorReturnValue"s4  #8, 'T->->y(-S)TUrc aa\P!4o\V3Rl4o\V3Rl4pV!4pSP^4VP V4pVP 4pVP ^\V44VP\V^,R,4VPRV^,R,4VPRV4VPRV4VPRV4R #) 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. c3X<"\P!S^4x\R4R#5i)z/ This is the inner function using returnValue. z"actual-value-not-used-for-the-testN)r deferLaterrclocksr_returnsEBasicTests.test_internalDefGenReturnValueDoesntLeak.._returns7s" //%+ + < =s'*c3<"S!4x\R4h \d\P!4u#i;i5i)zboom returnValuer4 traceback format_excrsr_raisesDBasicTests.test_internalDefGenReturnValueDoesntLeak.._raises?s< .j '(:;;$ . ++-- .? <?<?rrr_DefGen_ReturnBDuring handling of the above exception, another exception occurredz1test_inlinecb.TerminalException: boom returnValueN) r ClockradvancesuccessResultOfrrDrrrr assertNotIn)rHrrtbrrrs& @@r(test_internalDefGenReturnValueDoesntLeak3BasicTests.test_internalDefGenReturnValueDoesntLeak/s    >  >  .  . I a  ! !! $%%' CM* ((1+j*AB J QK " )2.  PRT  I2Nrc .aa\P!4o\V3Rl4o\V3Rl4pV!4pSP^4VP V4pVP RV4VP RV4VP RV4R#)aa 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. c3B<"\P!S^4x^#5ir)r rrsrrABasicTests.test_internalStopIterationDoesntLeak.._returnshs//%+ +sc3<"S!4x\R4h \d\P!4u#i;i5i)zboom normal returnrrsrr@BasicTests.test_internalStopIterationDoesntLeak.._raisesms< .j '(<==$ . ++-- .r StopIterationrz3test_inlinecb.TerminalException: boom normal returnN)r rrrrrr)rHrrrrrs& @@r$test_internalStopIterationDoesntLeak/BasicTests.test_internalStopIterationDoesntLeak\s       .  . I a  ! !! $ "-  PRT  KRPrzGC works differently on PyPy.c<V^8dQhRR/#r$r&Nr5)r( __classdict__s"rr)BasicTests.__annotate__s!*!*!*rc <\4p\P!V4p\RRl4pV!V4pVP WP V44\P!V4p??VP V!44VP V!44R#)aU 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. c0V^8dQhR\R\/#)r$ar&)r)r(s"rr)HBasicTests.test_inlineCallbacksNoCircularReference..__annotate__s  C C rc3"VxV#5irr5rs&rfunc@BasicTests.test_inlineCallbacksNoCircularReference..funcsGHrN)setweakrefrefrrDr assertIsNone)rHobj objWeakRefrfuncD funcDWeakRefs& r'test_inlineCallbacksNoCircularReference2BasicTests.test_inlineCallbacksNoCircularReferences[[%     S  2259:{{5)    *,' ,.)rr5N)r7r8r9r:r;rNrSr[rarhrrr|rrrrrrrrrpyunitskipIfrrr<__classdictcell__rs@rr>r>CsC*C& MAP S$H. A B8" ?2( V V+OZ$QL ]]59:!*;!*rr>c*a]tRtRtoRtRtRtVtR#)StopIterationReturnTestsiz 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}. c R\/p\RV4\4pVR,!V4pVPR4VP VP V4^4R#)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 rrDr)rHenvirond1d2s& rtest_returnWithValue-StopIterationReturnTests.test_returnWithValues^ %o6   Z S\"  D --b126rr5N)r7r8r9r:r;rr<rrs@rrrs77rrc`a]tRtRtoRtRtRtRtRtRt Rt R t R t R t R tR tVtR#)StackedInlineCallbacksTestsiz We have an optimization that invokes generators directly when an inlineCallbacks-decorated function yields value directly to yield of another inlineCallbacks-decorated function. c VF?wr#\V\4'dVPV4K.VPV4KA R#)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 Exceptionrpr)rH deferredListrrFs&& rrunCallbacksOnDeferreds3StackedInlineCallbacksTests.runCallbacksOnDeferredss3 !DA!Y'' !  1 !rc aaaa.o.o\VV3Rl4o\VV3Rl4o\VV3Rl4pV!^4pVPS4VPVPV4^4VPS.RO4R#)zh Tests the case when a chain of L{inlineCallbacks} calls end up yielding and blocking on a L{Deferred}. c3<"SPRV34\4pSPW34VxpV^, pSPRV34V#5if1 enterf1 exitappendr rFrr expectationss& rf1IStackedInlineCallbacksTests.test_nonCalledDeferredSingleYield..f1V   Q 0 A    'A FA   A /HAAc3<"SPRV34S!V4xpV^, pSPRV34V#5if2 enterf2 exitr rFrrs&rf2IStackedInlineCallbacksTests.test_nonCalledDeferredSingleYield..f2C   Q 0e A FA   A /H.f3rrNr rr'r r'r r$rr!rrrDrrHr#resrrrrs& @@@@r!test_nonCalledDeferredSingleYield=StackedInlineCallbacksTests.test_nonCalledDeferredSingleYields              e $$\2 --c2A6    rc aaaa.o.o\VV3Rl4oVV3Rlo\VV3Rl4pV!^4pVPS4VPVPV4^4VPS.RO4R#)z} Tests the case when a chain of L{inlineCallbacks} mixed with coroutine calls end up yielding and blocking on a L{Deferred}. c3<"SPRV34\4pSPW34VxpV^, pSPRV34\V4R#5ir r Nr r rrs& rrMStackedInlineCallbacksTests.test_nonCalledDeferredSingleYieldCoro..f1X   Q 0 A    'A FA   A / NAA c<"SPRV34S!V4GRjxL pV^, pSPRV34V#L"5irNrrrs&rrMStackedInlineCallbacksTests.test_nonCalledDeferredSingleYieldCoro..f2(sH   Q 0e A FA   A /H sAA#Ac3<"SPRV34S!V4xpV^, pSPRV34\V4R#5ir r!Nr rr"s&rr#MStackedInlineCallbacksTests.test_nonCalledDeferredSingleYieldCoro..f31sE   Q 0e A FA   A / NsAA Nr%r/r0s& @@@@r%test_nonCalledDeferredSingleYieldCoroAStackedInlineCallbacksTests.test_nonCalledDeferredSingleYieldCoros           e $$\2 --c2A6    rc (aaaa.o.o\VV3Rl4o\VV3Rl4o\VV3Rl4pV!^4pSFwr4VPV4K VPVPV4^4VPS.RO4R#)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. c3<"SPRV34\4pSPW34VxpV^, pSPRV34V#5ir r rs& rrLStackedInlineCallbacksTests.test_nonCalledDeferredMultipleYields..f1Vrrc3<"SPRV34S!V4xpS!V4xpS!V4xpV^, pSPRV34V#5irrrs&rrLStackedInlineCallbacksTests.test_nonCalledDeferredMultipleYields..f2bY   Q 0e Ae Ae A FA   A /HAAc3<"SPRV34S!V4xpS!V4xpS!V4xpV^, pSPRV34V#5irrr"s&rr#LStackedInlineCallbacksTests.test_nonCalledDeferredMultipleYields..f3nrIrJNr&r(r)r*r r$r )r rP)r r,)r)rrQ)r rQ)r )r rR)r r.)r r.)r  )r )rrT)r rT)r  )r rU)r  )r rV)r )r)r!rrrDr rHr#r1rrFrrrrs & @@@@r$test_nonCalledDeferredMultipleYields@StackedInlineCallbacksTests.test_nonCalledDeferredMultipleYieldsKs              e DA JJqM! --c2B7    rc aaaa.o.o\VV3Rl4oVV3Rlo\VV3Rl4pV!^4pSFwr4VPV4K VPVPV4^4VPS.RO4R#)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. c3<"SPRV34\4pSPW34VxpV^, pSPRV34\V4R#5ir6r7rs& rrPStackedInlineCallbacksTests.test_nonCalledDeferredMultipleYieldsCoro..f1r9r:c<"SPRV34S!V4GRjxL pS!V4GRjxL pS!V4GRjxL pV^, pSPRV34V#LBL4L&5ir<rrs&rrPStackedInlineCallbacksTests.test_nonCalledDeferredMultipleYieldsCoro..f2sd   Q 0e Ae Ae A FA   A /H s1A+A%A+A'A+A)#A+'A+)A+c3<"SPRV34S!V4xpS!V4xpS!V4xpV^, pSPRV34\V4R#5ir?r@r"s&rr#PStackedInlineCallbacksTests.test_nonCalledDeferredMultipleYieldsCoro..f3s[   Q 0e Ae Ae A FA   A / NsAANrMrZr[s & @@@@r(test_nonCalledDeferredMultipleYieldsCoroDStackedInlineCallbacksTests.test_nonCalledDeferredMultipleYieldsCoros           e DA JJqM! --c2B7    rc aaa.o\V3Rl4oV3Rlo\VVV3Rl4pVPVPV!^44^4VPS.RO4R#)z 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. c3v<"SPRV34VxpV^, pSPRV34V#5ir rrFrs&rrQStackedInlineCallbacksTests.test_intermediateAddCallbacksAndNoWaiting..f1s?   Q 0A FA   A /Hs69cf<SPRV34V^, pSPRV34V#rrris&rrQStackedInlineCallbacksTests.test_intermediateAddCallbacksAndNoWaiting..f25   Q 0 FA   A /Hrc3<"SPRV34S!V4pVPS4VxpV^, pSPRV34V#5irr rLrFrrrrs& rr#QStackedInlineCallbacksTests.test_intermediateAddCallbacksAndNoWaiting..f3 T   Q 01A MM" A FA   A /HAANr&r)r*rr$r+r-)rrDr)rHr#rrrs& @@@r)test_intermediateAddCallbacksAndNoWaitingEStackedInlineCallbacksTests.test_intermediateAddCallbacksAndNoWaitingsl          --be4a8    rc aaaa.o.o\VV3Rl4oV3Rlo\VVV3Rl4pV!^4pVPS4VPVPV4^4VPS.RO4R#)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 entire callback chain. c3<"SPRV34\4pSPW34VxpV^, pSPRV34V#5ir r rs& rr]StackedInlineCallbacksTests.test_intermediateAddCallbacksAndWithWaitingFirstYield..f10rrcf<SPRV34V^, pSPRV34V#rrris&rr]StackedInlineCallbacksTests.test_intermediateAddCallbacksAndWithWaitingFirstYield..f2<rmrc3<"SPRV34S!V4pVPS4VxpV^, pSPRV34V#5irrorps& rr#]StackedInlineCallbacksTests.test_intermediateAddCallbacksAndWithWaitingFirstYield..f3BrrrsNrtr/r0s& @@@@r5test_intermediateAddCallbacksAndWithWaitingFirstYieldQStackedInlineCallbacksTests.test_intermediateAddCallbacksAndWithWaitingFirstYield$s          e $$\2 --c2A6    rc aaaa.o.o\VV3Rl4oV3Rlo\VVV3Rl4pV!^4pVPS4VPVPV4^ 4VPS.RO4R#)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. c3<"SPRV34\4pSPW34VxpV^, pSPRV34V#5ir r rs& rr^StackedInlineCallbacksTests.test_intermediateAddCallbacksAndWithWaitingSecondYield..f1lrrcf<SPRV34V^, pSPRV34V#rrris&rr^StackedInlineCallbacksTests.test_intermediateAddCallbacksAndWithWaitingSecondYield..f2xrmrc3<"SPRV34S!V4xpS!V4pVPS4VxpV^, pSPRV34V#5irrorps& rr#^StackedInlineCallbacksTests.test_intermediateAddCallbacksAndWithWaitingSecondYield..f3~s_   Q 0e A1A MM" A FA   A /HsAAN)r&r)r*rNrO)rrP)rr)r!rSr/r0s& @@@@r6test_intermediateAddCallbacksAndWithWaitingSecondYieldRStackedInlineCallbacksTests.test_intermediateAddCallbacksAndWithWaitingSecondYield^s          e $$\2 --c2A6    rc aaaaa.o.o!RR\4o\VVV3Rl4o\VVVV3Rl4pV!^4pSPS4SPSP V4^4SPS.RO4R#)zr Tests the case when a function decorated with L{inlineCallbacks} yields a L{Deferred} that results in a failure. c]tRtRtRtR#)iStackedInlineCallbacksTests.test_raisesExceptionFromDeferredWithWaitingFirstCallback..MyExceptionir5Nr7r8r9r:r<r5rr MyExceptionr rrc3<"SPRV34\4pSPVS!434VxpSPRV34V#5irr rFrrrrs& rr`StackedInlineCallbacksTests.test_raisesExceptionFromDeferredWithWaitingFirstCallback..f2T   Q 0 A   KM 2 3A   A /Hrsc3<"SPRV34SPS4;_uu_4S!V4xpRRR4V^, pSPRV34V# +'giL.;i5ir Nr!r r)rFrrrrHs&rr#`StackedInlineCallbacksTests.test_raisesExceptionFromDeferredWithWaitingFirstCallback..f3sa   Q 0"";//Q%K0 FA   A /H 0/s-A4 A!&A4! A1 ,A4N)r&r()r!rrrrrDr)rHr#r1rrrrsf @@@@r8test_raisesExceptionFromDeferredWithWaitingFirstCallbackTStackedInlineCallbacksTests.test_raisesExceptionFromDeferredWithWaitingFirstCallbacks    )         e $$\2 --c2A6    rc <aaaaaa.o.o!RR\4o\VV3Rl4o\VVV3Rl4o\VVVVV3Rl4pV!^4pSPS4SPSP V4^4SPS.RO4R#)z 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. c]tRtRtRtR#)jStackedInlineCallbacksTests.test_raisesExceptionFromDeferredWithWaitingSecondCallback..MyExceptionir5Nrr5rrrrrrrc3<"SPRV34\4pSPW34VxpV^, pSPRV34V#5ir r rs& rraStackedInlineCallbacksTests.test_raisesExceptionFromDeferredWithWaitingSecondCallback..f1rrc3<"SPRV34\4pSPVS!434VxpSPRV34V#5irr rs& rraStackedInlineCallbacksTests.test_raisesExceptionFromDeferredWithWaitingSecondCallback..f2rrsc3<"SPRV34S!V4xpSPS4;_uu_4S!V4xpRRR4V^, pSPRV34V# +'giL.;i5irr)rFrrrrrHs&rr#aStackedInlineCallbacksTests.test_raisesExceptionFromDeferredWithWaitingSecondCallback..f3sl   Q 0e A"";//Q%K0 FA   A /H 0/s7A> A+&A>+ A; 6A>N)r&r)r*ru)r!rQr)rHr#r1rrrrrsf @@@@@r9test_raisesExceptionFromDeferredWithWaitingSecondCallbackUStackedInlineCallbacksTests.test_raisesExceptionFromDeferredWithWaitingSecondCallbacks   )              e $$\2 --c2A6    rr5N)r7r8r9r:r;rr2rBr\rervrrrrr<rrs@rrrsM 8 t7 rR hQ f0 d8 t= ~0 dA A rrc<a]tRtRtoRtRtRtRtRtRt Vt R#) NonLocalExitTestsia 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 \^4R#)zs This method mistakenly invokes L{returnValue}, despite the fact that it is not decorated with L{inlineCallbacks}. NrrHs&rmistakenMethod NonLocalExitTests.mistakenMethods Arc VPV^.4VPVP.R7pVP\V4^4VPV^,R,\4VPV^,R,\4VP RV^,R,4VPV^,R,R4R#)a3 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. )offendingFunctionsrrrzreturnValue() in 'mistakenMethod' causing 'inline' to exit: returnValue should only be invoked by functions decorated with inlineCallbacksN)rDrrrrr)rH resultListrs&& rassertMistakenMethodWarning-NonLocalExitTests.assertMistakenMethodWarning%s aS)%%$:M:M9N%O X* !Z02DE !Z02DE J QK "   QK "  rc a\V3Rl4pV!4p.pVPVP4SPV4R#)z~ L{returnValue} will emit a non-local exit warning in the simplest case, where the offending function is invoked immediately. c3N<"SP4\^4^xR#5ir$NrrrsrinlineANonLocalExitTests.test_returnValueNonLocalWarning..inlineCs    ! NG"%N)rrLr r)rHrrresultssf rtest_returnValueNonLocalWarning1NonLocalExitTests.test_returnValueNonLocalWarning=sC     H gnn% ((1rc aa\4o\VV3Rl4pV!4p.pVPVP4SP V.4SP ^4SP V4R#)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. c3N<"SxSP4\^4R#5irr)causerHsrrBNonLocalExitTests.test_returnValueNonLocalDeferred..inlineVsK    ! NrN)r rrLr rDrr)rHreffectrrsf @r test_returnValueNonLocalDeferred2NonLocalExitTests.test_returnValueNonLocalDeferredNsh       7>>* "% q ((1rr5N) r7r8r9r:r;rrrrr<rrs@rrrs# 02"22rrcJa]tRtRtoRtRtRtRtV3RlRltRt Vt R #) ForwardTraceBackTestsidc a\R4o\V3Rl4pV!4pVPV4pVP4pVPRV4VPRV4VPRV4R#)z Chained inlineCallbacks are forwarding the traceback information from generator to generator. A first simple test with a couple of inline callbacks. c3("Rx\R4h5izforcing generator Error Markerrr5rrerroring>ForwardTraceBackTests.test_forwardTracebacks..erroringm% %N+ +c3"<"S!4xR#5irr5rsrcalling=ForwardTraceBackTests.test_forwardTracebacks..callingr*   in erroring in callingrNrfailureResultOf getTracebackr)rHrrr-rrs& @rtest_forwardTracebacks,ForwardTraceBackTests.test_forwardTracebacksesz  ,  ,     I   # ^^  mR( lB' nb)rc faaRo\V3Rl4pV!4pVPV3Rl4pV#)zl Chained inlineCallback and coroutine are forwarding the traceback information from coroutine to generator. cJ"\R4GRjxL \R4hL5i)rNr)rrr5rrrBForwardTraceBackTests.test_forwardTracebacksCoro..errorings#%g. . .N+ + /r2c3"<"S!4xR#5irr5rsrrAForwardTraceBackTests.test_forwardTracebacksCoro..callingrrc<VP4pSPRV4SPRV4SPRV4R#)rrrN)rr)r-rrHs& rcheck?ForwardTraceBackTests.test_forwardTracebacksCoro..checks9!B MM- , MM, + MM." -r)r addErrback)rHrrrrsf @rtest_forwardTracebacksCoro0ForwardTraceBackTests.test_forwardTracebacksCoro}sB  ,     I  .  . rc aaa\R4o\V3Rl4o\V3Rl4o\V3Rl4pV!4pVPV4pVP4pVPRV4VPRV4VPRV4VPRV4VPR V4VPRVP44R #) aE 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("Rx\R4h5irrr5rrrDForwardTraceBackTests.test_forwardLotsOfTracebacks..erroringrrc3"<"S!4xR#5irr5rsrcalling3DForwardTraceBackTests.test_forwardLotsOfTracebacks..calling3rrc3"<"S!4xR#5irr5rsrcalling2DForwardTraceBackTests.test_forwardLotsOfTracebacks..calling2rrc3"<"S!4xR#5irr5rsrrCForwardTraceBackTests.test_forwardLotsOfTracebacks..callingrrrr in calling2 in calling3rNrrHrrr-rrrrs& @@@rtest_forwardLotsOfTracebacks2ForwardTraceBackTests.test_forwardLotsOfTracebackss&  ,  ,             I   # ^^  mR( lB' mR( mR( nb) mQ^^%56rc aaa\R4oV3Rlo\V3Rl4o\V3Rl4pV!4pVPV4pVP4pVPRV4VPRV4VPRV4VPRV4VPR V4VPRVP44R #) z Several chained inlineCallbacks mixed with coroutines gives information about all generators. A wider test with a 4 chained inline callbacks. c3("Rx\R4h5irrr5rrrHForwardTraceBackTests.test_forwardLotsOfTracebacksCoro..erroringrrc2<"S!4GRjxL R#L5irr5rsrrHForwardTraceBackTests.test_forwardLotsOfTracebacksCoro..calling3s*  s c3"<"S!4xR#5irr5rsrrHForwardTraceBackTests.test_forwardLotsOfTracebacksCoro..calling2rrc3"<"S!4xR#5irr5rsrrGForwardTraceBackTests.test_forwardLotsOfTracebacksCoro..callingrrrrrrrNrrs& @@@r test_forwardLotsOfTracebacksCoro6ForwardTraceBackTests.test_forwardLotsOfTracebacksCoros  ,  ,          I   # ^^  mR( lB' mR( mR( nb) mQ^^%56rc<V^8dQhRR/#rr5)r(rs"rr)"ForwardTraceBackTests.__annotate__s"9"9D"9rc \R4p\4pVP4RRlp\ V4VP V4p\P!VP44pVP\V4^4VPRV^,^,4VPRV^,^,4VPRV^,^,4VPRV^,^,4VPRV^,^,4VPRV^,^,4R # \dTP 4ELAi;i) z L{defer.inlineCallbacks} that receives tracebacks from a regular Deferred and re-raise tracebacks into their deferred should not lose their tracebacks. r%cTV^8dQhR\R\\\R3,/#)r$rr&N)objectrr)r(s"rr)NForwardTraceBackTests.test_reraiseTracebacksFromDeferred..__annotate__s%  & YsC~6 rc3"VxR#5i)z 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. Nr5rms&ricDForwardTraceBackTests.test_reraiseTracebacksFromDeferred..ics Gr test_inlinecbr.zraise ZeroDivisionError(msg)"test_reraiseTracebacksFromDeferredzf.raiseException()N) r.r raiseExceptionr,rprrr extract_tbgetTracebackObjectrDrr)rHr-rr  newFailurers& rr 8ForwardTraceBackTests.test_reraiseTracebacksFromDeferreds u %$J      ))!,  ! !*"?"?"A B R!$ or!uQx0 -r!uQx8 7AqB or!uQx0 =r!uQxH -r!uQx83  IIK sE E)(E)r5N) r7r8r9r:rrrrr r<rrs@rrrds%*02,7\ 7D"9"9rrc]tRtRtRtRtR#)UntranslatedErrori zD Untranslated exception type when testing an exception translation. r5Nr6r5rrrr rrc]tRtRtRtRtR#)TranslatedErrorizB Translated exception type when testing an exception translation. r5Nr6r5rrrrrrrc*a]tRtRtoRtRtRtVtR#)DontFailiz Sample exception type. c<\PV4WnR#r)r__init__ actualValue)rHactuals&&rrDontFail.__init__s4 !r)rN)r7r8r9r:r;rr<rrs@rrrs""rrc"]tRtRt^t^t^tRtR#)CancellationTestsStackedTypei!r5N)r7r8r9r: NOT_STACKEDSTACKED_INLINECB STACKED_COROr<r5rrrr!sKLrrcDa]tRtRtoRtRtRt]R4tRt ]R,Rl4t R t R-R lt R.R lt R tR tRtRtRtR.RltRtRtRtRtRtR.RltRtRtRtRtRtR.RltRt Rt!R t"R!t#R"t$R.R#lt%R$t&R%t'R&t(R't)R(t*V3R)lR*lt+R+t,Vt-R#)/CancellationTestsi'a  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} c .VnR#)z. Set up the list of outstanding L{Deferred}s. NdeferredsOutstandingrs&rsetUpCancellationTests.setUp0s %'!rc NVP'dVP4K$R#)z7 If any L{Deferred}s are still outstanding, fire them. N)r'deferredGottenrs&rtearDownCancellationTests.tearDown6s!'''    !(rc# "V!4xpV#5irr5)rHgetChildDeferredrFs&& rstackedInlineCB!CancellationTests.stackedInlineCB=s"$ $s c,"V!4GRjxL #L5irr5)rHr/s&&r stackedCoroCancellationTests.stackedCoroBs%''''s Nc# "Vf VPpV\P8XdV!4xpV^,#V'dVxV\P8XdVP V4xpV^,#VP V4xpV^,# \ d \4h\d&pTP^, pRp?T^,#Rp?ii;i5i)z Generator for testing cascade cancelling cases. @param getChildDeferred: Some callable returning L{Deferred} that we awaiting (with C{yield}) N) getDeferredrr r!r3r0rrrr)rH stackTyper/ firstDeferredrFdfs&&&& rsampleInlineCB CancellationTests.sampleInlineCBEs  ##//  #8DDD*,,1u !'' < M MM"../?@@A1u #223CDDA 1u ! $!# # #"A1u  #sPCB CB,B/ C8B CC3C4C CCCc nVPP\44VPR,#)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. )r'r r rs&rr6CancellationTests.getDeferred_s+ !!((4((,,rc ZVPP^4PV4R#)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}. N)r'popr)rHresults&&rr+ CancellationTests.deferredGottenis# !!%%a(11&9rc aR.oV3RlpRpV'd \4pVPVVVR7pVPR4V'dVP^4VP 4VP S^,\ R4R#)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 FAILUREcJ<\4pV3RlpVPV4V#)c8<VP\4S^&V#r)rr )rAchildResultHolders&r_ebTCancellationTests.doCascadeCancellingOnCancel..getChildDeferred.._ebs'-||N'C!!$ rr r)rrHrGs rr/GCancellationTests.doCascadeCancellingOnCancel..getChildDeferred}s" A  LL HrNr/r7r8cR#rr5)rAs&r?CancellationTests.doCascadeCancellingOnCancel..sDrzno cascade cancelling occurs)r r:rrcancelrDr )rHr7cancelOnSecondDeferredr/r8rrGs&&& @rdoCascadeCancellingOnCancel-CancellationTests.doCascadeCancellingOnCancelrs'K  !$JM   -'   ()   " "1 %    a  * rcDVP\P4R#r)rRrr rs&r(test_CascadeCancellingOnCancelNotStacked:CancellationTests.test_CascadeCancellingOnCancelNotStacked (()E)Q)QRrcDVP\P4R#rrRrr!rs&r-test_CascadeCancellingOnCancelStackedInlineCb?CancellationTests.test_CascadeCancellingOnCancelStackedInlineCb (()E)V)VWrcHVP\PRR7R#T)rQNrYrs&r=test_CascadeCancellingOnCancelStackedInlineCbOnSecondDeferredOCancellationTests.test_CascadeCancellingOnCancelStackedInlineCbOnSecondDeferred! (( ( 9 9RV ) rcDVP\P4R#rrRrr"rs&r)test_CascadeCancellingOnCancelStackedCoro;CancellationTests.test_CascadeCancellingOnCancelStackedCoro (()E)R)RSrcHVP\PRR7R#r^rcrs&r9test_CascadeCancellingOnCancelStackedCoroOnSecondDeferredKCancellationTests.test_CascadeCancellingOnCancelStackedCoroOnSecondDeferred  (( ( 5 5d ) rc RpV'd \4pVPWR7pV'dVP^4VP4VP \ VP V4P4R#)z 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)r7r8)r r:rrPrr rr )rHr7rQr8rs&&& rdoErrbackCancelledErrorOnCancel1CancellationTests.doErrbackCancelledErrorOnCancelsa !$JM   )  Q   " "1 %   .$*>*>q*A*P*PQrcDVP\P4R#r)rlrr rs&r"test_ErrbackCancelledErrorOnCancel4CancellationTests.test_ErrbackCancelledErrorOnCancels ,,-I-U-UVrcDVP\P4R#rrlrr!rs&r1test_ErrbackCancelledErrorOnCancelStackedInlineCbCCancellationTests.test_ErrbackCancelledErrorOnCancelStackedInlineCbs ,, ( 9 9 rcHVP\PRR7R#r^rrrs&rAtest_ErrbackCancelledErrorOnCancelStackedInlineCbOnSecondDeferredSCancellationTests.test_ErrbackCancelledErrorOnCancelStackedInlineCbOnSecondDeferreds! ,, ( 9 9RV - rcDVP\P4R#rrlrr"rs&r-test_ErrbackCancelledErrorOnCancelStackedCoro?CancellationTests.test_ErrbackCancelledErrorOnCancelStackedCoros ,,-I-V-VWrcHVP\PRR7R#r^ryrs&r=test_ErrbackCancelledErrorOnCancelStackedCoroOnSecondDeferredOCancellationTests.test_ErrbackCancelledErrorOnCancelStackedCoroOnSecondDeferreds  ,, ( 5 5d - rc *aRpRpV'd \4p\V4oVPV3RlWR7pV'dVP^4VP4VP \ VP V4P4R#)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. c8VP\44R#r)rprits&rrP;CancellationTests.doErrorToErrorTranslation..cancels JJ(* +rNc<S#rr5rsrrN=CancellationTests.doErrorToErrorTranslation..QrrL)r r:rrPrrrr )rHr7rQrPr8rrs&&& @rdoErrorToErrorTranslation+CancellationTests.doErrorToErrorTranslationsz , !$JM V    &)     " "1 %   /4+?+?+B+Q+QRrcDVP\P4R#r)rrr rs&rtest_ErrorToErrorTranslation.CancellationTests.test_ErrorToErrorTranslations &&'C'O'OPrcDVP\P4R#rrrr!rs&r+test_ErrorToErrorTranslationStackedInlineCb=CancellationTests.test_ErrorToErrorTranslationStackedInlineCbs &&'C'T'TUrcHVP\PRR7R#r^rrs&r;test_ErrorToErrorTranslationStackedInlineCbOnSecondDeferredMCancellationTests.test_ErrorToErrorTranslationStackedInlineCbOnSecondDeferreds! && ( 9 9RV ' rcDVP\P4R#rrrr"rs&r'test_ErrorToErrorTranslationStackedCoro9CancellationTests.test_ErrorToErrorTranslationStackedCoros &&'C'P'PQrcHVP\PRR7R#r^rrs&r7test_ErrorToErrorTranslationStackedCoroOnSecondDeferredICancellationTests.test_ErrorToErrorTranslationStackedCoroOnSecondDeferreds  && ( 5 5d ' rc ,aRpRpV'd \4p\V4oVPV3RlWR7p.pVPVP4V'dVP ^4VP 4VP VR.4R#)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. c:VP\R44R#)iN)rprrs&rrP=CancellationTests.doErrorToSuccessTranslation..cancels JJx~ &rNc<S#rr5rsrrN?CancellationTests.doErrorToSuccessTranslation.. rrrLi)r r:rLr rrP assertEquals)rHr7rQrPr8rrrs&&& @rdoErrorToSuccessTranslation-CancellationTests.doErrorToSuccessTranslations ' !$JM V    &)   gnn%   " "1 %   'D6*rcDVP\P4R#r)rrr rs&rtest_ErrorToSuccessTranslation0CancellationTests.test_ErrorToSuccessTranslationrWrcDVP\P4R#rrrr!rs&r-test_ErrorToSuccessTranslationStackedInlineCb?CancellationTests.test_ErrorToSuccessTranslationStackedInlineCbr\rcHVP\PRR7R#r^rrs&r=test_ErrorToSuccessTranslationStackedInlineCbOnSecondDeferredOCancellationTests.test_ErrorToSuccessTranslationStackedInlineCbOnSecondDeferredrarcDVP\P4R#rrrr"rs&r)test_ErrorToSuccessTranslationStackedCoro;CancellationTests.test_ErrorToSuccessTranslationStackedCoro!rfrcHVP\PRR7R#r^rrs&r9test_ErrorToSuccessTranslationStackedCoroOnSecondDeferredKCancellationTests.test_ErrorToSuccessTranslationStackedCoroOnSecondDeferred$rjrc \aa\4oV3RloV3RlpRpV'd \4pVPW1VR7pV'dVP^4VP4VP V4SPR4VP VP V4R4R#)z 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. c2<VP\4S#r)trapr )rA moreDeferreds&r deferMeMoreACancellationTests.doAsynchronousCancellation..deferMeMore2s KK ' rc><\4pVPS4V#rrJ)rrs rdeferMe=CancellationTests.doAsynchronousCancellation..deferMe6s A LL %HrNrLii)r r:rrPassertNoResultrDr)rHr7rQrr8rrrs&&& @@rdoAsynchronousCancellation,CancellationTests.doAsynchronousCancellation)s z     !$JM   $     " "1 %   Ad# --a0$7rcDVP\P4R#r)rrr rs&rtest_AsynchronousCancellation/CancellationTests.test_AsynchronousCancellationHs ''(D(P(PQrcDVP\P4R#rrrr!rs&r,test_AsynchronousCancellationStackedInlineCb>CancellationTests.test_AsynchronousCancellationStackedInlineCbKs ''(D(U(UVrcHVP\PRR7R#r^rrs&r.__annotate__os$  )HV$4fd$BC rc3D<"SxSxR# \dLi;i5irr)rrsrtestFuncFCancellationTests.test_inlineCallbacksCancelCaptured..testFuncns* H  s     N) r r rrrDrPrtyper )rHcanceller1Callscanceller2Callsrrfailurerrs& @@r"test_inlineCallbacksCancelCaptured4CancellationTests.test_inlineCallbacksCancelCaptured[s3524'(>(>?'(>(>?       B B E" "- "-   2$/ "- E"  &&u- ~6 2$/rr&)NNr)F).r7r8r9r:r;r(r,rr0r3r:r6r+rRrUrZr_rdrhrlrorsrvrzr}rrrrrrrrrrrrrrrrrrrr<rrs@rr$r$'s' "(2-:% NSX T R(W  X S,QV R +0SX T 8>RW S 5050rr$r)-r;runittestrrenumrtypingrrrrrtwisted.internetrr twisted.internet.deferr r r r rrrtwisted.python.compatrtwisted.trial.unittestrrrr!r.r1rr4r>rrrrrrrrr$r5rrrs 33*(@ , !  a*a*H 7x7