כh[SSrSSKJrJrJr SSKJr "SS5r"SS5r"SS \R5r "S S \ 5r "S S \R5r "SS\R5rg)z_ This module contains tests for L{twisted.internet.task.Cooperator} and related functionality. )deferreactortask)unittestc$\rSrSrSrSrSrSrg)FakeDelayedCallz9 Fake delayed call which lets us simulate the scheduler. cXlSUlg)z A function to run, later. FN)func cancelledselfr s `C:\Users\psant\Downloads\Noiseback\school\venv\Lib\site-packages\twisted/test/test_cooperator.py__init__FakeDelayedCall.__init__s cSUlg)z Don't run my function later. TN)r rs rcancelFakeDelayedCall.cancels r)r r N)__name__ __module__ __qualname____firstlineno____doc__rr__static_attributes__rrrrsrrc*\rSrSrSrSrSrSrSrg) FakeScheduler!z' A fake scheduler for testing against. c/Ulg)z4 Create a fake scheduler with a list of work to do. Nworkrs rrFakeScheduler.__init__&s  rcR[U5nURRU5 U$)z+ Schedule a unit of work to be done later. )rr#append)rthunkunits r__call__FakeScheduler.__call__,s%u%  rcUR/solUH&nUR(aMUR5 M( g)z< Do all of the work that is currently available to be done. N)r#r r )rr#r(s rpumpFakeScheduler.pump4s/))RiD>>> rr"N) rrrrrrr)r,rrrrrr!s rrcx\rSrSrSrSrSrSrSrSr Sr S r S r S r S rS rSrSrSrSrSrSrg)CooperatorTests>donecXUR[R5 UR$N)traprSchedulerStoppedRESULT)rerrs rebIterCooperatorTests.ebIterAs &&'{{rc$UR5 gr3)fail)rigns rcbIterCooperatorTests.cbIterEs  rcH^^U4SjmT"S5RU4Sj5$)zE Test that Cooperators refuse new tasks when they have been stopped. c>[R"5nUR5 UR[ S5U5nUR TR 5 URTR5 UR U4Sj5$)Nrc<>TRUTR5$r3 assertEqualr6resultrs rNCooperatorTests.testStoppedRejectsNewTasks..testwith..Ss0@0@0Ur) r Cooperatorstop coiterateiter addCallbackr= addErrbackr8)stuffcdrs rtestwith.testwithMs\!A FFH DHe,A MM$++ & LL %==!UV VrNc:>T"[R"55$r3)rDeferred)r<rQs rrF.Ushu~~?O6Pr)rL)rrQs`@rtestStoppedRejectsNewTasks*CooperatorTests.testStoppedRejectsNewTasksHs!  W~))*PQQrc0^^[R"5nSmSTlURT"55nUR TR 5 UR TR5 UR5 UU4SjnUR U5 U$)zY Test that a running iterator will not run to completion when the cooperator is stopped. c36# [S5ShvN gN7f)N)rangerrrmyiter/CooperatorTests.testStopRunning..myiter^sQx  s cv>TRUTR5 TRTRS5 gNr^)rCr6value)rEr\rs r doasserts2CooperatorTests.testStopRunning..doassertsgs+   VT[[ 1   V\\2 .r) rrHrarJrLr=rMr8rI)rrOrPrbr\s` @rtestStopRunningCooperatorTests.testStopRunningWsp OO   KK ! dkk" T[[!  / i rc^^^^[R"5m[R"5mUUU4Sjn[R"5mTR U"55nUU4SjnTR U5 UR TR 5 URTR5 UR U4Sj5$)z An iterator run with L{Cooperator.coiterate} paused on a L{Deferred} yielded by that iterator will fire its own L{Deferred} (the one returned by C{coiterate}) when L{Cooperator.stop} is called. c3z># [R"STRS5 Tv TR5 g7fNr)r callLatercallbackr;) outstandingDr testControlDsrr\3CooperatorTests.testStopOutstanding..myiterws-   a!6!6 =  IIKs8;cH>TR5 TRS5 g)N arglebargle)rIrj)r<rOrks r stopAndGo6CooperatorTests.testStopOutstanding..stopAndGos FFH  ! !- 0rc<>TRUTR5$r3rBrDs rrF5CooperatorTests.testStopOutstanding..sD,<,.myiters#n$s rrHrJ assertFailurerx)rrOr\rPs rtestUnexpectedError#CooperatorTests.testUnexpectedErrors8 OO  % KK !!!!\22rcSn[R"5nURU"55nURU[5$)Nc3# [R"5n[R"SUR[ 55 Uv g7frh)rrTrrierrbackrx)Ds rr\@CooperatorTests.testUnexpectedErrorActuallyLater..myiters. A   aLN ;GsAArzrr\rOrPs r testUnexpectedErrorActuallyLater0CooperatorTests.testUnexpectedErrorActuallyLaters8  OO  KK !!!!\22rcSn[R"5nURU"55nURU[5$)Nc3L# [R"[55v g7fr3)rr;rxrrrr\CCooperatorTests.testUnexpectedErrorNotActuallyLater..myiters**\^, ,s"$rzrs r#testUnexpectedErrorNotActuallyLater3CooperatorTests.testUnexpectedErrorNotActuallyLaters8 - OO  KK !!!!\22rc^^^/mU4Sjn/SQm[R"5n/nTH)nURURU"U555 M+ [R "U5R UUU4Sj5$)Nc3J># UHnTRU5 Sv M g7fr3r&)thingsthLs rr\/CooperatorTests.testCooperation..myiters   s #)abcrZdef)cZ>TR[T5[[T6S55$Nr)rCtuplesumzip)r<rgroupsOfThingsrs rrF1CooperatorTests.testCooperation..s"((q3sN7KR3PQr)rrHr&rJr DeferredListrL)rr\rOtasksrNrrs` @@rtestCooperationCooperatorTests.testCooperationsk   > OO #E LLVE]3 4$!!%(44 Q  rc^^/mUU4Sjn"SS5m[R"TS9nURU"55RUR5 UR R 5 UR5 UR5 URTR5 URT[[S555 g)Nc3v># [S5H%nTRU5 US:XaSTlUv M' g7f)Nd T)r[r&stopped)i_TPFoutputs rr\6CooperatorTests.testResourceExhaustion..myiters33Z a 6#'DL  s69c\rSrSrSrSrSrg)4CooperatorTests.testResourceExhaustion.._TPFFcUR$r3)rrs rr)=CooperatorTests.testResourceExhaustion.._TPF.__call__s ||#rrN)rrrrrr)rrrrrrs G $rr)terminationPredicateFactory )rrHrJrMr8 _delayedCallr_tickrI assertTruerrClistr[)rr\rOrrs @@rtestResourceExhaustion&CooperatorTests.testResourceExhaustions  $ $ OO = FH((5      % eBi1rc^^^^^/m"SS5mUUU4Sjn[R"USS9mTR[S55n/mUU4SjnUR U5 SnT(dZUS - nT(a-TR S5R 5 US - nT(aM-US :aTRS 5 T(dMYg g ) a If a callback to a deferred returned by coiterate calls coiterate on the same Cooperator, we should make sure to only do the minimal amount of scheduling work. (This test was added to demonstrate a specific bug that was found while writing the scheduler.) c(\rSrSrSrS\4SjrSrg)9CooperatorTests.testCallbackReCoiterate..FakeCallcXlgr3r r s rrBCooperatorTests.testCallbackReCoiterate..FakeCall.__init__s rreturnc$SUR<S3$)Nz rrs r__repr__BCooperatorTests.testCallbackReCoiterate..FakeCall.__repr__s#DII=22rrN)rrrrrstrrrrrrFakeCallrs ! 3# 3rrcr>TRT[T55 TRT"U55 TS$r`) assertFalsereprr&)frcallsrs rsched6CooperatorTests.testCallbackReCoiterate..scheds1   UDK 0 LL! %9 rcS$)NcgNTrrrrrFKCooperatorTests.testCallbackReCoiterate....srrrrrrF9CooperatorTests.testCallbackReCoiterate..sr schedulerrrcl>TR[S55RTR5 gr)rJrKaddBothr&)r<rOr1s r anotherTask.anotherTasks" KKR ! ) )$++ 6rrr2zCooperator took too longN)rrHrJrKrLpopr r;) rrrPrr#rrOrr1s ` @@@@rtestCallbackReCoiterate'CooperatorTests.testCallbackReCoiterates 3 3  OO9M  KKR ! 7 k" AID ! !!# %by 45 $rc^S/mU4Sjn[R"US9nUR[SS/55nUR[SS/55nUR TSR UR 5 UR5 URTSR5 UR URTS5 UR5 URTSR5 URUR5 UR[SS/55 URTSR5 UR URTS5 g)z If the last task in a Cooperator is removed, the scheduled call for the next tick is cancelled, since it is no longer necessary. This behavior is useful for tests that want to assert they have left no reactor state behind when they're done. Nc*>[U5TS'TS$rh)r)rrs rrFCooperatorTests.test_removingLastTaskStopsScheduledCall..scheds&q)E!H8Or)rrrr) rrH cooperaterKrCr rrIrr rr assertIsNone)rrcooptask1task2rs @r'test_removingLastTaskStopsScheduledCall7CooperatorTests.test_removingLastTaskStopsScheduledCalls% /tQF|,tQF|, q 3   q++, **E!H5   a**+ $++, tQF|$ q++, **E!H5rcd[R"5nURUR5 g)zU L{Cooperator.running} reports C{True} if the L{Cooperator} was started on creation. N)rrHrrunningrrOs rtest_runningWhenStarted'CooperatorTests.test_runningWhenStarted"s OO   "rcb[R"SS9nURUR5 g)zS L{Cooperator.running} reports C{False} if the L{Cooperator} has not been started. FstartedN)rrHrrrs rtest_runningWhenNotStarted*CooperatorTests.test_runningWhenNotStarted*s$ OOE * #rc[R"SS9nUR5 URUR5 UR UR 5 g)zJ L{Cooperator.running} reports C{True} when the L{Cooperator} is running. FrN)rrHstart addCleanuprIrrrs rtest_runningWhenRunning'CooperatorTests.test_runningWhenRunning2s; OOE *     "rc[R"SS9nUR5 UR5 UR UR 5 g)zR L{Cooperator.running} reports C{False} after the L{Cooperator} has been stopped. FrN)rrHrrIrrrs rtest_runningWhenStopped'CooperatorTests.test_runningWhenStopped<s6 OOE *    #rrN)rrrrr6r8r=rVrdrtr|rrrrrrrrrrrrrrr/r/>s[ F R.S6 333 &24(6T"6H#$#$rr/c\rSrSrSrSrg)UnhandledExceptioniGz( An exception that should go unhandled. rN)rrrrrrrrrrrGsrrc\rSrSrSrSrSrg) AliasTestsiMz[ Integration test to verify that the global singleton aliases do what they're supposed to. c^[R"5mU4SjnU"5n[R"U5nUR U[R R 5 T$)zJ L{twisted.internet.task.cooperate} ought to run the generator that it is c3H># Sv Sv Sv TRS5 g7f)NrrrZyay)rj)rPsrdoit'AliasTests.test_cooperate..doitYs!GGG JJu s")rrTrrassertIn_theCooperator_tasks)rrittheTaskrPs @rtest_cooperateAliasTests.test_cooperateSsL NN   V..$ gt2299:rrN)rrrrrr rrrrrrMs  rrc\rSrSrSrSrSrSrSrSr Sr S r S r S r S rS rSrSrSrSrSrSrSrSrSrSrg) RunStateTestsiez Tests to verify the behavior of L{CooperativeTask.pause}, L{CooperativeTask.resume}, L{CooperativeTask.stop}, exhausting the underlying iterator, and their interactions with each other. c4SUlSUlSUl/Ul[ 5Ul[ R"UR SS9UlURRUR55UlURR5 g)z Create a cooperator with a fake scheduler and a termination predicate that ensures only one unit of work will take place per tick. FcS$)NcgrrrrrrF7RunStateTests.setUp....zsrrrrrrF%RunStateTests.setUp..zs rrN) _doDeferNext _doStopNext _doDieNextr#rrrrH cooperatorrworkerrrs rsetUpRunStateTests.setUplsu "  &//nn)=   OO--dkkm<  rc#P# SnUS- nUR(a<SUl[R"5nURR U5 Uv OLUR (agUR (a [5eURR U5 Uv M7f)zz This is a sample generator which yields Deferreds when we are testing deferral and an ascending integer count otherwise. rrFN)rrrTr#r&rrr)rrrPs rrRunStateTests.workers  FA  $)!NN$   #!!(**   #sB$B&c U?U?g)zw Drop references to interesting parts of the fixture to allow Deferred errors to be noticed when things start failing. N)rrrs rtearDownRunStateTests.tearDowns I NrcSUlg)z0 Defer the next result from my worker iterator. TN)rrs r deferNextRunStateTests.deferNexts !rcSUlg)zU Make the next result from my worker iterator be completion (raising StopIteration). TN)rrs rstopNextRunStateTests.stopNexts  rcSnSUlg)zS Make the next result from my worker iterator be raising an L{UnhandledException}. c.UR[5 gr3)r4r)failures rignoreUnhandled.RunStateTests.dieNext..ignoreUnhandleds LL+ ,rTN)r)rr's rdieNextRunStateTests.dieNexts  rcfURR5 URURS/5 URR5 URURSS/5 URR 5 URR5 URURSS/5 URR 5 URURSS/5 URR5 URUR/SQ5 g)zh Cooperators should stop running their tasks when they're paused, and start again when they're resumed. rrrN)rr,rCr#rpauseresumers rtest_pauseResumeRunStateTests.test_pauseResumes  QC(  QF+   QF+  QF+  I.rc<UR[RURR5 URR 5 URR5 UR[RURR5 g)z L{CooperativeTask.resume} should raise a L{TaskNotPaused} exception if it was not paused; e.g. if L{CooperativeTask.pause} was not invoked more times than L{CooperativeTask.resume} on that object. N) assertRaisesr NotPausedr-r,rs rtest_resumeNotPaused"RunStateTests.test_resumeNotPauseds^ $..$))*:*:;   $..$))*:*:;rcURR5 URR5 UR UR /5 URR5 URR5 UR UR /5 URR 5 URR5 UR UR /5 URR 5 URR5 UR UR S/5 g)zf Pauses on tasks should behave like a stack. If a task is paused twice, it needs to be resumed twice. rN)rr,rr,rCr#r-rs rtest_pauseTwiceRunStateTests.test_pauseTwices   B'   B'   B'   QC(rcUR5 URR5 UR[ UR 5S5 UR UR S[R5 URR5 UR[ UR 5S5 URR5 URR5 UR[ UR 5S5 URR5 URR5 UR[ UR 5S5 UR SRS5 URR5 UR[ UR 5S5 URUR SS5 g)z C{pause()}ing a task while it is waiting on an outstanding L{defer.Deferred} should put the task into a state where the outstanding L{defer.Deferred} must be called back I{and} the task is C{resume}d before it will continue processing. rrzSTUFF!rN) rrr,rClenr#assertIsInstancerrTrr,r-rjrs rtest_pauseWhileDeferred%RunStateTests.test_pauseWhileDeferreds>   TYY+ diilENN;  TYY+   TYY+   TYY+ ! h'  TYY+ 1q)rc^^URR5nURR5n/m/m/n/nU4SjnU4SjnURU5 URU5 URUR5 URUR5 UR 5 UR R 5 UR[T5S5 UR[T5S5 URTSURR5 URTSURR5 URUS/5 URUS/5 g)a L{CooperativeTask.whenDone} returns a Deferred which fires when the Cooperator's iterator is exhausted. It returns a new Deferred each time it is called; callbacks added to other invocations will not modify the value that subsequent invocations will fire with. c(>TRU5 g)Nrr)rEresults1s r callbackOne0RunStateTests.test_whenDone..callbackOne OOF #rc(>TRU5 g)Nrr)rEresults2s r callbackTwo0RunStateTests.test_whenDone..callbackTworBrrrrN) rwhenDonerLr&r"rr,rCr9assertIs _iterator) r deferred1 deferred2final1final2r@rEr?rDs @@r test_whenDoneRunStateTests.test_whenDones(II&&( II&&(    k*k*fmm,fmm,   X* X* hqk499#6#67 hqk499#6#67 !% !%rcTURR5n/nURUR5 UR 5 UR R 5 UR[U5S5 URUSR[5[5 g)z L{CooperativeTask.whenDone} returns a L{defer.Deferred} that will fail when the iterable's C{next} method raises an exception, with that exception. rrN) rrGrMr&r)rr,rCr9checkr)rrJresultss rtest_whenDoneError RunStateTests.test_whenDoneError/s{ II&&( W^^,   Wq) ))*<=?QRrc\URR5n/nURUR5 URR 5 UR [ U5S5 UR USR[R5[R5 g)z L{CooperativeTask.whenDone} returns a L{defer.Deferred} that fails with L{TaskStopped} when the C{stop} method is called on that L{CooperativeTask}. rrN) rrGrMr&rIrCr9rQ TaskStopped)rrJerrorss rtest_whenDoneStopRunStateTests.test_whenDoneStop=sx II&&( V]]+  Va( )9)9:D>:rc^^/mUU4SjnTRR5RU5 TR5 TRR 5 TR TTRRS/5 g)a[ If a callback of a L{Deferred} from L{CooperativeTask.whenDone} calls C{Cooperator.stop} on its L{CooperativeTask._cooperator}, the L{Cooperator} will stop, but the L{CooperativeTask} whose callback is calling C{stop} should already be considered 'stopped' by the time the callback is running, and therefore removed from the L{CoooperativeTask}. c~>TRU5 TRR5 TRS5 g)Nr1)r&rrI)rEcallbackPhasesrs rstopit;RunStateTests.test_stopCooperatorReentrancy..stopits1  ! !& ) OO "  ! !& )rr1N)rrGrLr"rr,rCrI)rrsrrs` @rtest_stopCooperatorReentrancy+RunStateTests.test_stopCooperatorReentrancysd * ((0   $))*=*=v)FGr)rrrrrrr#N)rrrrrrrrrr"r)r.r3r6r;rNrSrXr[r^rarfrjrnrurrrrr r eso  &*!   /, <),*0)&V S N 9 ( ((49;Hrr N)rtwisted.internetrrr twisted.trialrrrTestCaser/ Exceptionrrr rrrr{sr 21"&:F$h''F$R ""0MHH%%MHr