o >h!@sdZddlmZddlZddlZddlmZmZddlm Z m Z m Z ddl m Z ddlmZmZmZdd lmZe d ZGd d d eZGd ddeZGdddZGddde eZGdddZGddde ZGddde ZdS)z. Tests for L{twisted._threads._threadworker}. ) annotationsN) ThreadErrorlocal)CallableGenericTypeVar)SynchronousTestCase) AlreadyQuit LockWorker ThreadWorker) SimpleLockTc@eZdZdZdS)FakeQueueEmptyz8 L{FakeQueue}'s C{get} has exhausted the queue. N__name__ __module__ __qualname____doc__rr/var/www/vedio/testing/chatpythonscript.ninositsolution.com/env/lib/python3.10/site-packages/twisted/_threads/test/test_threadworker.pyrrc@r) WouldDeadlockzf If this were a real lock, you'd be deadlocked because the lock would be double-acquired. Nrrrrrrrrc@s$eZdZdZd ddZd dd Zd S) FakeThreadz A fake L{threading.Thread}. @ivar target: A target function to run. @ivar started: Has this thread been started? @type started: L{bool} targetCallable[[], object]returnNonecCs||_d|_dS)z7 Create a L{FakeThread} with a target. FN)rstarted)selfrrrr__init__-s zFakeThread.__init__cC d|_dS)z) Set the "started" flag. TN)rr rrrstart4 zFakeThread.startN)rrrrrr)rrrrr!r$rrrrr#s rc@s.eZdZdZd ddZddd Zdd d Zd S) 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} rrcCs g|_dS)z( Create a L{FakeQueue}. N)itemsr#rrrr!Dr%zFakeQueue.__init__itemrcCs|j|dS)zv Put an item into the queue for later retrieval by L{FakeQueue.get}. @param item: any object N)r(append)r r)rrrputJsz FakeQueue.putcCs|jst|jdS)zR Get an item. @return: an item previously put by C{put}. r)r(rpopr#rrrgetRs z FakeQueue.getNr&)r)rrr)rr)rrrrr!r+r-rrrrr';s   r'c@s.eZdZdZd ddZd ddZd d d Zd S)FakeLockzi A stand-in for L{threading.Lock}. @ivar acquired: Whether this lock is presently acquired. rrcCr")z9 Create a lock in the un-acquired state. FNacquiredr#rrrr!dr%zFakeLock.__init__boolcCs|jrtd|_dS)zX Acquire the lock. Raise an exception if the lock is already acquired. T)r0rr#rrracquirejszFakeLock.acquirecCs|jstd|_dS)zf Release the lock. Raise an exception if the lock is not presently acquired. FN)r0rr#rrrreleasess zFakeLock.releaseNr&)rr1)rrrrr!r2r3rrrrr.]s    r.c@s.eZdZdZd ddZd ddZd dd Zd S) ThreadWorkerTestsz$ Tests for L{ThreadWorker}. rrcs&g_dfdd }t|t_dS) z4 Create a worker with fake threads. rrrrcs"t|d}|j||S)N)r)rr$ fakeThreadsr*)r newThreadr#rr startThreads  z,ThreadWorkerTests.setUp..startThreadN)rrrr)r5r r'worker)r r7rr#rsetUpszThreadWorkerTests.setUpcst|t|jd||jdjddd fdd }|j||d|t|jdj|dd S) 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. rTFrrcsddSNTrrdonerrdoItsz@ThreadWorkerTests.test_startsThreadAndPerformsWork..doItNr&) assertEquallenr5rr8do assertRaisesrr)r r>rr<r test_startsThreadAndPerformsWorks  z2ThreadWorkerTests.test_startsThreadAndPerformsWorkcCs0|j|t|jj|t|jjtdS)z L{ThreadWorker.quit} causes future calls to L{ThreadWorker.do} and L{ThreadWorker.quit} to raise L{AlreadyQuit}. N)r8quitrBr rAlistr#rrrtest_quitPreventsFutureCallss z.ThreadWorkerTests.test_quitPreventsFutureCallsNr&)rrrrr9rCrFrrrrr4}s   r4c@sVeZdZdZdddZdddZddd Zdd d Zdd d ZdddZ dddZ dS)LockWorkerTestsz" Tests for L{LockWorker}. rrcCs t}||t|jdS)ze The L{FakeLock} test fixture will alert us if there's a potential deadlock. N)r.r2rBr)r lockrrrtest_fakeDeadlocksz!LockWorkerTests.test_fakeDeadlockcCsBt}|t|j||}|d||t|jdS)zk The L{FakeLock} test fixture will alert us if there's a potential double-release. N)r.rBrr3r2assertIs)r rHnoResultrrrtest_fakeDoubleReleases  z&LockWorkerTests.test_fakeDoubleReleasecsdt}tt|}dddfdd }|||d|d|jddS) zp L{LockWorker.do} immediately performs the work it's given, while the lock is acquired. FrrcsdjdSr;r/rr0r=rHrrwork z@LockWorkerTests.test_doExecutesImmediatelyWithLock..workTNr&)rr.r rAr?r0)r storager8rNrrMr"test_doExecutesImmediatelyWithLocks    z2LockWorkerTests.test_doExecutesImmediatelyWithLockcsdtttggdd fdd |ddg|ddgdS) z If L{LockWorker.do} is called recursively, it postpones the inner call until the outer one is complete. rrrcs@d7jtdkrd8dS)Nr:r )r*r0r@rArr0levellevelsrHrNr8rrrNs      z6LockWorkerTests.test_doUnwindsReentrancy..workr:TNr&)r.r rrAr?r#rrRrtest_doUnwindsReentrancys  z(LockWorkerTests.test_doUnwindsReentrancycCslt}t|}t|t}~||d|t| |d| t |j| t |j t dS)z L{LockWorker.quit} frees the resources associated with its lock and causes further calls to C{do} and C{quit} to fail. N)r.weakrefrefr r assertIsNotrDgccollectrJrBr rArE)r rHrWr8rrr test_quits  zLockWorkerTests.test_quitcstt}ttdddd fdd }d fdd |d d jdt  |ddS) 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. FNrrcs*tjtddSr;)rArDrBr rEr)phase1completephase2r r8rrphase1s z5LockWorkerTests.test_quitWhileWorking..phase1csdjdSr;r/r)rHphase2acquiredphase2completerrr]rOz5LockWorkerTests.test_quitWhileWorking..phase2Tr&) r.rVrWr rrAr?r0rYrZrJ)r rWr^r)rHr\r]r_r`r r8rtest_quitWhileWorkings     z%LockWorkerTests.test_quitWhileWorkingcCs2Gdddt}|tt}|t|jtdS)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@s*eZdZed ddZejd ddZdS) zALockWorkerTests.test_quitWhileGettingLock..RacyLockWorkerrSimpleLock | NonecSs||jd}|SN_lock)rD__dict__)r itrrrrd/s zGLockWorkerTests.test_quitWhileGettingLock..RacyLockWorker._lockvaluercSs||jd<dSrc)re)r rgrrrrd5sN)rrb)rgrbrr)rrrpropertyrdsetterrrrrRacyLockWorker.s  rjN)r r.rrBr rArE)r rjr8rrrtest_quitWhileGettingLock's z)LockWorkerTests.test_quitWhileGettingLockNr&) rrrrrIrLrQrUr[rarkrrrrrGs    "rG)r __future__rrYrV threadingrrtypingrrrtwisted.trial.unittestrr r r _threadworkerr r Exceptionrrrr'r.r4rGrrrrs"   " 1