+
    üÐjÓ!  ã                  ó*  € R t ^ RIHt ^ RIt^ RIt^ RIHtHt ^ RIH	t	H
t
Ht ^ RIHt ^RIHtHtHt ^RIHt ]! R4      t ! R	 R
]4      t ! R R]4      t ! R R4      t ! R R]
],          4      t ! R R4      t ! R R]4      t ! R R]4      tR# )z.
Tests for L{twisted._threads._threadworker}.
)ÚannotationsN)ÚThreadErrorÚlocal)ÚCallableÚGenericÚTypeVar)ÚSynchronousTestCase)ÚAlreadyQuitÚ
LockWorkerÚThreadWorker)Ú
SimpleLockÚTc                  ó   € ] tR t^tRtRtR# )ÚFakeQueueEmptyz0
L{FakeQueue}'s C{get} has exhausted the queue.
© N©Ú__name__Ú
__module__Ú__qualname__Ú__firstlineno__Ú__doc__Ú__static_attributes__r   ó    ÚI/usr/lib/python3/dist-packages/twisted/_threads/test/test_threadworker.pyr   r      s   † õr   r   c                  ó   € ] tR t^tRtRtR# )ÚWouldDeadlockzZ
If this were a real lock, you'd be deadlocked because the lock would be
double-acquired.
r   Nr   r   r   r   r   r      s   † õr   r   c                  ó2   € ] tR t^#tRtR R ltR R ltRtR# )Ú
FakeThreadz‹
A fake L{threading.Thread}.

@ivar target: A target function to run.

@ivar started: Has this thread been started?
@type started: L{bool}
c               ó    € V ^8„  d   QhRRRR/# )é   ÚtargetúCallable[[], object]ÚreturnÚNoner   )Úformats   "r   Ú__annotate__ÚFakeThread.__annotate__-   s   € ÷ ñ Ð3ð ¸ñ r   c                ó    € Wn         RV n        R# )z'
Create a L{FakeThread} with a target.
FN)r    Ústarted)Úselfr    s   &&r   Ú__init__ÚFakeThread.__init__-   s   € ð ŒØˆŽr   c               ó   € V ^8„  d   QhRR/# ©r   r"   r#   r   )r$   s   "r   r%   r&   4   s   € ÷ ñ �tñ r   c                ó   € RV n         R# )z
Set the "started" flag.
TN)r(   ©r)   s   &r   ÚstartÚFakeThread.start4   s   € ð ˆŽr   )r(   r    N)r   r   r   r   r   r*   r0   r   r   r   r   r   r   #   s   † ñõ÷ñ r   r   c                  ó>   € ] tR t^;tRtR R ltR R ltR R ltRtR	# )
Ú	FakeQueuez™
A fake L{Queue} implementing C{put} and C{get}.

@ivar items: A lit of items placed by C{put} but not yet retrieved by
    C{get}.
@type items: L{list}
c               ó   € V ^8„  d   QhRR/# r-   r   )r$   s   "r   r%   ÚFakeQueue.__annotate__D   s   € ÷ !ñ !˜$ñ !r   c                ó   € . V n         R# )z
Create a L{FakeQueue}.
N©Úitemsr/   s   &r   r*   ÚFakeQueue.__init__D   s   € ð !ˆŽ
r   c               ó    € V ^8„  d   QhRRRR/# )r   Úitemr   r"   r#   r   )r$   s   "r   r%   r5   J   s   € ÷  ñ  ˜ð  ˜dñ  r   c                ó<   € V P                   P                  V4       R# )z^
Put an item into the queue for later retrieval by L{FakeQueue.get}.

@param item: any object
N)r8   Úappend)r)   r;   s   &&r   ÚputÚFakeQueue.putJ   s   € ð 	�
‰
×Ñ˜$Ör   c               ó   € V ^8„  d   QhRR/# )r   r"   r   r   )r$   s   "r   r%   r5   R   s   € ÷ !ñ !�Qñ !r   c                óp   € V P                   '       g   \        4       hV P                   P                  ^ 4      # )z:
Get an item.

@return: an item previously put by C{put}.
)r8   r   Úpopr/   s   &r   ÚgetÚFakeQueue.getR   s)   € ð �z�zˆzÜ Ó"Ð"Ø�z‰z�~‰~˜aÓ Ð r   r7   N)	r   r   r   r   r   r*   r>   rC   r   r   r   r   r3   r3   ;   s   † ñõ!õ ÷!ñ !r   r3   c                  ó>   € ] tR t^]tRtR R ltR R ltR R ltRtR	# )
ÚFakeLockz]
A stand-in for L{threading.Lock}.

@ivar acquired: Whether this lock is presently acquired.
c               ó   € V ^8„  d   QhRR/# r-   r   )r$   s   "r   r%   ÚFakeLock.__annotate__d   s   € ÷ ñ ˜$ñ r   c                ó   € RV n         R# )z)
Create a lock in the un-acquired state.
FN©Úacquiredr/   s   &r   r*   ÚFakeLock.__init__d   s   € ð ˆŽr   c               ó   € V ^8„  d   QhRR/# )r   r"   Úboolr   )r$   s   "r   r%   rH   j   s   € ÷ ñ ˜ñ r   c                óL   € V P                   '       d   \        4       hRV n         R# )zH
Acquire the lock.  Raise an exception if the lock is already acquired.
T)rK   r   r/   s   &r   ÚacquireÚFakeLock.acquirej   s   € ð �=�=ˆ=Ü“/Ð!ØˆŒÙr   c               ó   € V ^8„  d   QhRR/# r-   r   )r$   s   "r   r%   rH   s   s   € ÷ ñ ˜ñ r   c                óL   € V P                   '       g   \        4       hRV n         R# )zN
Release the lock.  Raise an exception if the lock is not presently
acquired.
FN)rK   r   r/   s   &r   ÚreleaseÚFakeLock.releases   s   € ð
 �}�}ˆ}Ü“-ÐØˆŽr   rJ   N)	r   r   r   r   r   r*   rP   rT   r   r   r   r   rF   rF   ]   s   † ñõõ÷ñ r   rF   c                  ó>   € ] tR t^}tRtR R ltR R ltR R ltRtR	# )
ÚThreadWorkerTestsz
Tests for L{ThreadWorker}.
c               ó   € V ^8„  d   QhRR/# r-   r   )r$   s   "r   r%   ÚThreadWorkerTests.__annotate__‚   s   € ÷ =ñ =�tñ =r   c                óZ   a € . S n         R V 3R llp\        V\        4       4      S n        R# )z$
Create a worker with fake threads.
c               ó    € V ^8„  d   QhRRRR/# )r   r    r!   r"   r   r   )r$   s   "r   r%   Ú-ThreadWorkerTests.setUp.<locals>.__annotate__ˆ   s   € ÷ 	ñ 	Ð 4ð 	¸ñ 	r   c                óv   <€ \        V R 7      pVP                  4        SP                  P                  V4       V# ))r    )r   r0   ÚfakeThreadsr=   )r    Ú	newThreadr)   s   & €r   ÚstartThreadÚ,ThreadWorkerTests.setUp.<locals>.startThreadˆ   s1   ø€ Ü"¨&Ô1ˆIØ�O‰OÔØ×Ñ×#Ñ# IÔ.ØÐr   N)r^   r   r3   Úworker)r)   r`   s   f r   ÚsetUpÚThreadWorkerTests.setUp‚   s)   ø€ ð .0ˆÔ÷	ð 	ô # ;´	³Ó<ˆŽr   c               ó   € V ^8„  d   QhRR/# r-   r   )r$   s   "r   r%   rY   �   s   € ÷ %ñ %°$ñ %r   c                ó¢  a€ V P                  \        V P                  4      ^4       V P                  V P                  ^ ,          P                  R4       RoR V3R llpV P                  P                  V4       V P                  SR4       V P                  \        V P                  ^ ,          P                  4       V P                  SR4       R# )z°
L{ThreadWorker} calls its C{createThread} callable to create a thread,
its C{createQueue} callable to create a queue, and then the thread's
target pulls work from that queue.
TFc               ó   € V ^8„  d   QhRR/# r-   r   )r$   s   "r   r%   ÚHThreadWorkerTests.test_startsThreadAndPerformsWork.<locals>.__annotate__›   s   € ÷ 	ñ 	�dñ 	r   c                 ó   <€ R o R# ©TNr   )Údones   €r   ÚdoItÚ@ThreadWorkerTests.test_startsThreadAndPerformsWork.<locals>.doIt›   s   ø€ àŠDr   N)	ÚassertEqualÚlenr^   r(   rb   ÚdoÚassertRaisesr   r    )r)   rl   rk   s   & @r   Ú test_startsThreadAndPerformsWorkÚ2ThreadWorkerTests.test_startsThreadAndPerformsWork�   s£   ø€ ð 	×Ñœ˜T×-Ñ-Ó.°Ô2Ø×Ñ˜×)Ñ)¨!Õ,×4Ñ4°dÔ;àˆ÷	ð 	ð 	�‰�‰�tÔØ×Ñ˜˜uÔ%Ø×Ñœ.¨$×*:Ñ*:¸1Õ*=×*DÑ*DÔEØ×Ñ˜˜tÖ$r   c               ó   € V ^8„  d   QhRR/# r-   r   )r$   s   "r   r%   rY   ¤   s   € ÷ =ñ =¨dñ =r   c                óì   € V P                   P                  4        V P                  \        V P                   P                  4       V P                  \        V P                   P                  \
        4       R# )zr
L{ThreadWorker.quit} causes future calls to L{ThreadWorker.do} and
L{ThreadWorker.quit} to raise L{AlreadyQuit}.
N)rb   Úquitrq   r	   rp   Úlistr/   s   &r   Útest_quitPreventsFutureCallsÚ.ThreadWorkerTests.test_quitPreventsFutureCalls¤   sH   € ð
 	�‰×ÑÔØ×Ñœ+ t§{¡{×'7Ñ'7Ô8Ø×Ñœ+ t§{¡{§~¡~´tÖ<r   )r^   rb   N)	r   r   r   r   r   rc   rr   rx   r   r   r   r   rW   rW   }   s   † ñõ=õ%÷(=ñ =r   rW   c                  ón   € ] tR t^®tRtR R ltR R ltR R ltR R	 ltR
 R lt	R R lt
R R ltRtR# )ÚLockWorkerTestsz
Tests for L{LockWorker}.
c               ó   € V ^8„  d   QhRR/# r-   r   )r$   s   "r   r%   ÚLockWorkerTests.__annotate__³   s   € ÷ 7ñ 7 4ñ 7r   c                óz   € \        4       pVP                  4        V P                  \        VP                  4       R# )zM
The L{FakeLock} test fixture will alert us if there's a potential
deadlock.
N)rF   rP   rq   r   )r)   Úlocks   & r   Útest_fakeDeadlockÚ!LockWorkerTests.test_fakeDeadlock³   s(   € ô
 ‹zˆØ�‰ŒØ×Ñœ-¨¯©Ö6r   c               ó   € V ^8„  d   QhRR/# r-   r   )r$   s   "r   r%   r}   ¼   s   € ÷ 
5ñ 
5¨ñ 
5r   c                óþ   € \        4       pV P                  \        VP                  4       VP	                  4        VP                  4       pV P                  RV4       V P                  \        VP                  4       R# )zS
The L{FakeLock} test fixture will alert us if there's a potential
double-release.
N)rF   rq   r   rT   rP   ÚassertIs)r)   r   ÚnoResults   &  r   Útest_fakeDoubleReleaseÚ&LockWorkerTests.test_fakeDoubleRelease¼   sU   € ô
 ‹zˆØ×Ñœ+ t§|¡|Ô4Ø�‰ŒØ—<‘<“>ˆØ�‰�d˜HÔ%Ø×Ñœ+ t§|¡|Ö4r   c               ó   € V ^8„  d   QhRR/# r-   r   )r$   s   "r   r%   r}   È   s   € ÷ /ñ /°Dñ /r   c                ó  aaa€ \        4       p\        4       o\        SV4      pRoRoR VVV3R llpVP                  V4       V P	                  SR4       V P	                  SR4       V P	                  SP
                  R4       R# )zX
L{LockWorker.do} immediately performs the work it's given, while the
lock is acquired.
Fc               ó   € V ^8„  d   QhRR/# r-   r   )r$   s   "r   r%   ÚHLockWorkerTests.test_doExecutesImmediatelyWithLock.<locals>.__annotate__Ó   s   € ÷ 	%ñ 	%�dñ 	%r   c                 ó$   <€ R oSP                   o R# rj   rJ   )rK   rk   r   s   €€€r   ÚworkÚ@LockWorkerTests.test_doExecutesImmediatelyWithLock.<locals>.workÓ   s   ø€ àˆDØ—}‘}ŠHr   TN)r   rF   r
   rp   rn   rK   )r)   Ústoragerb   r�   rK   rk   r   s   &   @@@r   Ú"test_doExecutesImmediatelyWithLockÚ2LockWorkerTests.test_doExecutesImmediatelyWithLockÈ   st   ú€ ô
 “'ˆÜ‹zˆÜ˜D 'Ó*ˆØˆØˆ÷	%ò 	%ð
 	�	‰	�$ŒØ×Ñ˜˜tÔ$Ø×Ñ˜ 4Ô(Ø×Ñ˜Ÿ™¨Ö.r   c               ó   € V ^8„  d   QhRR/# r-   r   )r$   s   "r   r%   r}   Ý   s   € ÷ 1ñ 1¨$ñ 1r   c                óè   aaaaaa€ \        4       o\        S\        4       4      o. o. o^ oR VVVVVV3R lloSP                  S4       V P	                  S^^.4       V P	                  SRR.4       R# )zi
If L{LockWorker.do} is called recursively, it postpones the inner call
until the outer one is complete.
c               ó   € V ^8„  d   QhRR/# r-   r   )r$   s   "r   r%   Ú>LockWorkerTests.test_doUnwindsReentrancy.<locals>.__annotate__è   s   € ÷ 	ñ 	�dñ 	r   c                 óÆ   <€ S^,          oSP                  S4       S P                  SP                  4       \        S4      ^8  d   SP                  S4       S^,          oR# )é   N)r=   rK   ro   rp   )rK   ÚlevelÚlevelsr   r�   rb   s   €€€€€€r   r�   Ú6LockWorkerTests.test_doUnwindsReentrancy.<locals>.workè   sG   ø€ à�Q�JˆEØ�M‰M˜%Ô Ø�O‰O˜DŸM™MÔ*Ü�6‹{˜QŒØ—	‘	˜$”Ø�Q�JŠEr   TN)rF   r
   r   rp   rn   )r)   rK   r˜   r™   r   r�   rb   s   &@@@@@@r   Útest_doUnwindsReentrancyÚ(LockWorkerTests.test_doUnwindsReentrancyÝ   sh   ý€ ô
 ‹zˆÜ˜D¤%£'Ó*ˆØˆØˆØˆ÷	õ 	ð 	�	‰	�$ŒØ×Ñ˜ ! Q Ô(Ø×Ñ˜ D¨$ <Ö0r   c               ó   € V ^8„  d   QhRR/# r-   r   )r$   s   "r   r%   r}   õ   s   € ÷ 8ñ 8˜4ñ 8r   c                ó   € \        4       p\        P                  ! V4      p\        V\	        4       4      p?V P                  V! 4       R4       VP                  4        \        P                  ! 4        V P                  V! 4       R4       V P                  \        VP                  4       V P                  \        VP                  \        4       R# )zx
L{LockWorker.quit} frees the resources associated with its lock and
causes further calls to C{do} and C{quit} to fail.
N)rF   ÚweakrefÚrefr
   r   ÚassertIsNotrv   ÚgcÚcollectr„   rq   r	   rp   rw   )r)   r   r    rb   s   &   r   Ú	test_quitÚLockWorkerTests.test_quitõ   sˆ   € ô
 ‹zˆÜ�kŠk˜$ÓˆÜ˜D¤%£'Ó*ˆØØ×Ñ™› Ô%Ø�‰ŒÜ
�
Š
ŒØ�‰‘c“e˜TÔ"Ø×Ñœ+ v§{¡{Ô3Ø×Ñœ+ v§y¡y´$Ö7r   c               ó   € V ^8„  d   QhRR/# r-   r   )r$   s   "r   r%   r}     s   € ÷  #ñ  # tñ  #r   c                ó²  a aaaaaa€ \        4       o\        P                  ! S4      p\        S\	        4       4      oRoRoRoR VVV V3R llpR VVV3R lloSP                  V4       S P                  SR4       S P                  SR4       S P                  SP                  R4       >\        P                  ! 4        S P                  V! 4       R4       R# )z©
If L{LockWorker.quit} is invoked during a call to L{LockWorker.do}, all
recursive work scheduled with L{LockWorker.do} will be completed and
the lock will be released.
FNc               ó   € V ^8„  d   QhRR/# r-   r   )r$   s   "r   r%   Ú;LockWorkerTests.test_quitWhileWorking.<locals>.__annotate__  s   € ÷ 	"ñ 	"˜ñ 	"r   c                 ó˜   <€ SP                  S4       SP                  4        SP                  \        SP                   \        4       R o R# rj   )rp   rv   rq   r	   rw   )Úphase1completeÚphase2r)   rb   s   €€€€r   Úphase1Ú5LockWorkerTests.test_quitWhileWorking.<locals>.phase1  s3   ø€ à�I‰I�fÔØ�K‰KŒMØ×Ñœk¨6¯9©9´dÔ;Ø!ŠNr   c               ó   € V ^8„  d   QhRR/# r-   r   )r$   s   "r   r%   r©     s   € ÷ 	+ñ 	+˜ñ 	+r   c                 ó$   <€ R oS P                   oR# rj   rJ   )r   Úphase2acquiredÚphase2completes   €€€r   r¬   Ú5LockWorkerTests.test_quitWhileWorking.<locals>.phase2  s   ø€ à!ˆNØ!Ÿ]™]ŠNr   T)rF   rŸ   r    r
   r   rp   rn   rK   r¢   r£   r„   )	r)   r    r­   r   r«   r¬   r±   r²   rb   s	   f  @@@@@@r   Útest_quitWhileWorkingÚ%LockWorkerTests.test_quitWhileWorking  s©   þ€ ô ‹zˆÜ�kŠk˜$ÓˆÜ˜D¤%£'Ó*ˆàˆØˆØˆ÷	"ó 	"÷	+ò 	+ð
 	�	‰	�&ÔØ×Ñ˜¨Ô.Ø×Ñ˜¨Ô.Ø×Ñ˜Ÿ™¨Ô.ØÜ
�
Š
ŒØ�‰‘c“e˜TÖ"r   c               ó   € V ^8„  d   QhRR/# r-   r   )r$   s   "r   r%   r}   '  s   € ÷ 8ñ 8¨4ñ 8r   c                ó    €  ! R R\         4      pV! \        4       \        4       4      pV P                  \        VP
                  \        4       R# )z©
If L{LockWorker.do} is called concurrently with L{LockWorker.quit}, and
C{quit} wins the race before C{do} gets the lock attribute, then
L{AlreadyQuit} will be raised.
c                  óV   € ] tR tRt]R R l4       t]P                  R R l4       tRtR# )ÚALockWorkerTests.test_quitWhileGettingLock.<locals>.RacyLockWorkeri.  c               ó   € V ^8„  d   QhRR/# )r   r"   úSimpleLock | Noner   )r$   s   "r   r%   ÚNLockWorkerTests.test_quitWhileGettingLock.<locals>.RacyLockWorker.__annotate__0  s   € ÷ ñ Ð0ñ r   c                	óL   € V P                  4        V P                  R ,          pV# )Ú_lock)rv   Ú__dict__)r)   Úits   & r   r¾   ÚGLockWorkerTests.test_quitWhileGettingLock.<locals>.RacyLockWorker._lock/  s   € à—	‘	”Ø!%§¡¨wÕ!7�Ø�	r   c               ó    € V ^8„  d   QhRRRR/# )r   Úvaluer»   r"   r#   r   )r$   s   "r   r%   r¼   6  s   € ÷ /ñ /Ð#4ð /¸ñ /r   c                	ó"   € WP                   R &   R# )r¾   N)r¿   )r)   rÃ   s   &&r   r¾   rÁ   5  s   € à).—‘˜gÓ&r   r   N)r   r   r   r   Úpropertyr¾   Úsetterr   r   r   r   ÚRacyLockWorkerr¹   .  s,   † Øôó ðð
 �\‰\ô/ó ô/r   rÇ   N)r
   rF   r   rq   r	   rp   rw   )r)   rÇ   rb   s   &  r   Útest_quitWhileGettingLockÚ)LockWorkerTests.test_quitWhileGettingLock'  s6   € ô		/œZô 		/ñ  ¤£
¬E«GÓ4ˆØ×Ñœ+ v§y¡y´$Ö7r   r   N)r   r   r   r   r   r€   r†   r�   r›   r¤   r´   rÈ   r   r   r   r   r{   r{   ®   s0   † ñõ7õ
5õ/õ*1õ08õ  #÷D8ñ 8r   r{   )r   Ú
__future__r   r¢   rŸ   Ú	threadingr   r   Útypingr   r   r   Útwisted.trial.unittestr   Ú r	   r
   r   Ú_threadworkerr   r   Ú	Exceptionr   r   r   r3   rF   rW   r{   r   r   r   Ú<module>rÑ      sŽ   ðñõ #ã 	Û ß (ß -Ñ -å 6ß 4Ñ 4Ý &áˆCƒL€ô�Yô ô�Iô ÷ñ ô0!�˜•
ô !÷Dñ ô@.=Ð+ô .=ôbL8Ð)ö L8r   