Your IP : 216.73.216.60


Current Path : /opt/alt/python35/lib64/python3.5/test/__pycache__/
Upload File :
Current File : //opt/alt/python35/lib64/python3.5/test/__pycache__/lock_tests.cpython-35.opt-1.pyc



��Yf�m�@sadZddlZddlZddlmZmZddlZddlZddlm	Z	dd�Z
Gdd�de�ZGd	d
�d
ej
�ZGdd�de�ZGd
d�de�ZGdd�de�ZGdd�de�ZGdd�de�ZGdd�de�ZGdd�de�ZGdd�de�ZGdd�de�ZdS)z/
Various tests for synchronization primitives.
�N)�start_new_thread�TIMEOUT_MAX)�supportcCstjd�dS)Ng{�G�z�?)�time�sleep�rr�4/opt/alt/python35/lib64/python3.5/test/lock_tests.py�_waitsr	c@sIeZdZdZddd�Zdd�Zdd�Zd	d
�ZdS)�Bunchz
    A bunch of threads.
    Fc
s���_|�_g�_g�_|�_��fdd�}y(x!t|�D]}t|f�qSWWnd�_�YnXdS)z�
        Construct a bunch of `n` threads running the same function `f`.
        If `wait_before_exit` is True, the threads won't terminate until
        do_finish() is called.
        csVtj�}�jj|�z��Wd�jj|�x�jsPt�q=WXdS)N)�	threading�	get_ident�started�append�finished�	_can_exitr	)�tid)�f�selfrr�task!szBunch.__init__.<locals>.taskTN)r�nr
rr�ranger)rrrZwait_before_exitr�ir)rrr�__init__s				
		zBunch.__init__cCs*x#t|j�|jkr%t�qWdS)N)�lenr
rr	)rrrr�wait_for_started1szBunch.wait_for_startedcCs*x#t|j�|jkr%t�qWdS)N)rrrr	)rrrr�wait_for_finished5szBunch.wait_for_finishedcCs
d|_dS)NT)r)rrrr�	do_finish9szBunch.do_finishN)�__name__�
__module__�__qualname__�__doc__rrrrrrrrr
s
r
c@s4eZdZdd�Zdd�Zdd�ZdS)�BaseTestCasecCstj�|_dS)N)rZthreading_setup�_threads)rrrr�setUp>szBaseTestCase.setUpcCstj|j�tj�dS)N)rZthreading_cleanupr"Z
reap_children)rrrr�tearDownAszBaseTestCase.tearDowncCs,|j||d�|j||d�dS)Ng333333�?g$@)ZassertGreaterEqual�
assertLess)rZactualZexpectedrrr�
assertTimeoutEszBaseTestCase.assertTimeoutN)rrrr#r$r&rrrrr!=sr!c@s�eZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dd�Z
dd�Zdd�Zdd�Z
dd�ZdS)�
BaseLockTestsz;
    Tests for both recursive and non-recursive locks.
    cCs|j�}~dS)N)�locktype)r�lockrrr�test_constructorSszBaseLockTests.test_constructorcCs)|j�}|jt|�d�~dS)Nz<unlocked .* object (.*)?at .*>)r(�assertRegex�repr)rr)rrr�	test_reprWszBaseLockTests.test_reprcCs3|j�}|j�|jt|�d�~dS)Nz<locked .* object (.*)?at .*>)r(�acquirer+r,)rr)rrr�test_locked_repr\s
zBaseLockTests.test_locked_reprcCs|j�}|j�~dS)N)r(r.)rr)rrr�test_acquire_destroybs
z"BaseLockTests.test_acquire_destroycCs'|j�}|j�|j�~dS)N)r(r.�release)rr)rrr�test_acquire_releasegs

z"BaseLockTests.test_acquire_releasecCs0|j�}|j|jd��|j�dS)NF)r(�
assertTruer.r1)rr)rrr�test_try_acquiremszBaseLockTests.test_try_acquirecsc|j���j�g���fdd�}t|d�j�|j�d��j�dS)Ncs�j�jd��dS)NF)rr.r)r)�resultrrrvsz3BaseLockTests.test_try_acquire_contended.<locals>.f�r)r(r.r
r�assertFalser1)rrr)r)r5r�test_try_acquire_contendedrs
z(BaseLockTests.test_try_acquire_contendedcs�|j���j�d}�fdd�}t||�}|j�t�|jt|j�d��j�|j	�|jt|j�|�dS)N�cs�j��j�dS)N)r.r1r)r)rrr�s
z/BaseLockTests.test_acquire_contended.<locals>.fr)
r(r.r
rr	�assertEqualrrr1r)r�Nr�br)r)r�test_acquire_contended|s



z$BaseLockTests.test_acquire_contendedcsw|j���fdd�}d�fdd�}|�t|d�j�|jt|t�t|d�j�dS)Ncs�j��j�dS)N)r.r1r)r)rrr�s
z"BaseLockTests.test_with.<locals>.fc	s$��|dk	r|�WdQRXdS)Nr)�err)r)rr�_with�sz&BaseLockTests.test_with.<locals>._withr6)r(r
r�assertRaises�	TypeError)rrr?r)r)r�	test_with�szBaseLockTests.test_withcs�|j���fdd�}ttj��}t|d�j�ttj��|kr�tjd�|j|ttj���dS)Ncs�j��j�dS)N)r.r1r)r)rrr�s
z)BaseLockTests.test_thread_leak.<locals>.f�g�������?)	r(rr�	enumerater
rrrr:)rrrr)r)r�test_thread_leak�s
zBaseLockTests.test_thread_leakcs*|j��|jt�jdd�|jt�jdd
�|jt�jdd�|jt�jdtd��jdt��j�tj�}|j�jdd��tj�}|j	||d�g���fdd�}t
|d�j�|j�d�|j
�dd	�dS)Nrr6�timeout�dg}Ô%�I�Tr9csFtj�}�j�jdd��tj�}�j||�dS)NrFg�?)rrr.)�t1�t2)r)�resultsrrr�sz%BaseLockTests.test_timeout.<locals>.fg�?i����)r(r@�
ValueErrorr.�
OverflowErrorrr1rr3r%r
rr7r&)rrHrIrr)r)rJr�test_timeout�s 
zBaseLockTests.test_timeoutN)rrrr r*r-r/r0r2r4r8r=rBrErMrrrrr'Ns
r'c@s:eZdZdZdd�Zdd�Zdd�ZdS)	�	LockTestszn
    Tests for non-recursive, weak locks
    (which can be acquired and released from different threads).
    cs�|j��g���fdd�}t|f�xt��dkrSt�q7Wt�|jt��d��j�xt��dkr�t�q~W|jt��d�dS)Ncs2�j��jd��j��jd�dS)N)r.rr)r)�phaserrr�s


z#LockTests.test_reacquire.<locals>.frr6�)r(rrr	r:r1)rrr)r)rOr�test_reacquire�s

zLockTests.test_reacquirecsY|j���j��fdd�}t|d�}|j��j��j�dS)Ncs�j�dS)N)r1r)r)rrr�sz*LockTests.test_different_thread.<locals>.fr6)r(r.r
rr1)rrr<r)r)r�test_different_thread�s


zLockTests.test_different_threadcCsi|j�}|j�|j|jdd��|j�|j|j��|j|jdd��dS)NrFg{�G�z�?ZblockingF)r(r.r7r1�lockedr3)rr)rrr�test_state_after_timeout�s

z"LockTests.test_state_after_timeoutN)rrrr rQrRrTrrrrrN�srNc@sReZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�ZdS)
�
RLockTestsz$
    Tests for recursive locks.
    cCsL|j�}|j�|j�|j�|j�|j�|j�dS)N)r(r.r1)rr)rrrrQ�s




zRLockTests.test_reacquirecCsr|j�}|jt|j�|j�|j�|j�|j�|j�|j�|jt|j�dS)N)r(r@�RuntimeErrorr1r.)rr)rrr�test_release_unacquireds





z"RLockTests.test_release_unacquiredcCsr|j�}|jt|j�|j�|j�|j�|j�|j�|j�|jt|j�dS)N)r(r@rV�
_release_saver.r1)rr)rrr�test_release_save_unacquireds





z'RLockTests.test_release_save_unacquiredc
sY|j���fdd�}t|dd�}z|jt�j�Wd|j�XdS)Ncs�j�dS)N)r.r)r)rrr sz+RLockTests.test_different_thread.<locals>.fr6T)r(r
r@rVr1r)rrr<r)r)rrRsz RLockTests.test_different_threadcs�|j��|j�j���j�|j�j���j�|j�j��g���fdd�}t|d�j�|j�d��j�|j�j���j�|j�j��dS)Ncs�j�j��dS)N)r�	_is_ownedr)r)r5rrr0sz$RLockTests.test__is_owned.<locals>.fr6r)r(r7rZr.r3r
rr1)rrr)r)r5r�test__is_owned(s



zRLockTests.test__is_ownedN)	rrrr rQrWrYrRr[rrrrrU�s	rUc@s^eZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dS)�
EventTestsz"
    Tests for Event objects.
    cCs�|j�}|j|j��|j�|j|j��|j�|j|j��|j�|j|j��|j�|j|j��dS)N)�	eventtyper7Zis_set�setr3�clear)r�evtrrr�test_is_set?s



zEventTests.test_is_setcs�d}g�g����fdd�}t||�}|j�t�|jt��d��j�|j�|j�dg|�|j�dg|�dS)Nr9cs*�j�j���j�j��dS)N)r�waitr)r`�results1�results2rrrPsz#EventTests._check_notify.<locals>.frT)r
rr	r:rr^r)rr`r;rr<r)r`rcrdr�
_check_notifyKs


zEventTests._check_notifycCs>|j�}|j|�|j�|j�|j|�dS)N)r]rer^r_)rr`rrr�test_notify\s



zEventTests.test_notifycs�|j��g�g�d}���fdd�}t||�j�|j�dg|�x1�D])\}}|j|�|j|d�qgWg�g��j�t||�j�|j�dg|�x!�D]\}}|j|�q�WdS)Nr9csX�j�jd��tj�}�jd�}tj�}�j|||f�dS)Ngg�?)rrbr)rH�rrI)r`rcrdrrris
z"EventTests.test_timeout.<locals>.fFg�?T)r]r
rr:r7r&r^r3)rr;rrg�dtr)r`rcrdrrMds"

zEventTests.test_timeoutcs�|j��g�d}��fdd�}t||�}|j�tjd��j��j�|j�|j�dg|�dS)Nr9cs�j�jd��dS)Nr6)rrbr)r`rJrrr�sz(EventTests.test_set_and_clear.<locals>.fg�?T)	r]r
rrrr^r_rr:)rr;rr<r)r`rJr�test_set_and_clear}s




zEventTests.test_set_and_clearcCsn|j�}|j�|j|jjd��WdQRX|j�|j�|j|jjd��WdQRXdS)NF)r]Z_condr7r.Z_reset_internal_locks)rr`rrr�test_reset_internal_locks�s
 

z$EventTests.test_reset_internal_locksN)
rrrr rarerfrMrirjrrrrr\:sr\c@sveZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dd�Z
dd�ZdS)�ConditionTestsz(
    Tests for condition variables.
    c
Cs�|j�}|j�|j�|j�|j�tj�}|j|�}|j�|j|jd��|j�|j|jd��|j|jd��|j�|�|j|jd��WdQRXdS)NF)�condtyper.r1rZLockr7r3)r�condr)rrr�test_acquire�s






zConditionTests.test_acquirecCs#|j�}|jt|j�dS)N)rlr@rVrb)rrmrrr�test_unacquired_wait�sz#ConditionTests.test_unacquired_waitcCs#|j�}|jt|j�dS)N)rlr@rV�notify)rrmrrr�test_unacquired_notify�sz%ConditionTests.test_unacquired_notifycsrd}g�g�g�d������fdd�}t||�}|j�xt��dkrtt�qXW�j�|j�g��j��jd�t�d��j�xt��dkr�t�q�W|j�d
gd�|j�g�xt��dkr#t�qW�j��jd�t�d��j�x't��t��d	kr{t�qUW|j�dgddgd�|j�d
gd�xt��dkr�t�q�W�j��j	�t�d��j�xt��dkrt�qW|j�dgddgd�|j�dgddgd�|j
�dS)Nr9rcs��j��j���j�}�j��j|�f��j��j���j�}�j��j|�f�dS)N)r.rrbr1)r5)rm�	phase_num�readyrcrdrrr�s





z'ConditionTests._check_notify.<locals>.f�r6TrP�)Tr6)Tr6)TrP)TrP)Tr6)TrP)TrP)Trt)r
rrr	r_r:r.rpr1Z
notify_allr)rrmr;rr<r)rmrrrsrcrdrre�sX







"


""zConditionTests._check_notifycCs*|j�}|j|�|j|�dS)N)rlre)rrmrrrrfs
zConditionTests.test_notifycs�|j��g�d}��fdd�}t||�j�|jt��|�x1�D])\}}|j|d�|j|�q]WdS)Nr9csV�j�tj�}�jd�}tj�}�j��j|||f�dS)Ng�?)r.rrbr1r)rHr5rI)rmrJrrrs

z&ConditionTests.test_timeout.<locals>.fg�?)rlr
rr:rr&r7)rr;rrhr5r)rmrJrrMszConditionTests.test_timeoutc
s��j��d����fdd�}t|d�}|j�xCtd�D]5}tjd����d7��j�WdQRXqPW|j�dS)NrcsJ��=�j�fdd��}�j|��j�d�WdQRXdS)Ncs
�dkS)N�rr)�staterr�<lambda>"sz8ConditionTests.test_waitfor.<locals>.f.<locals>.<lambda>rv)�wait_forr3r:)r5)rmrrwrrr s
z&ConditionTests.test_waitfor.<locals>.fr6rvg{�G�z�?)rlr
rrrrrpr)rrr<rr)rmrrwr�test_waitfors


zConditionTests.test_waitforc
s��j��d�g�����fdd�}t|d�}|j�xCtd�D]5}tjd����d7��j�WdQRXqYW|j��jt	��d�dS)Nrcsy��ltj�}�j�fdd�dd�}tj�|}�j|��j|d��jd�WdQRXdS)Ncs
�dkS)Nrvrr)rwrrrx5sz@ConditionTests.test_waitfor_timeout.<locals>.f.<locals>.<lambda>rFg�������?)rryr7r&r)rhr5)rmrrw�successrrr2s!
z.ConditionTests.test_waitfor_timeout.<locals>.fr6rtg{�G�z�?)
rlr
rrrrrprr:r)rrr<rr)rmrrwr{r�test_waitfor_timeout.s



z#ConditionTests.test_waitfor_timeoutN)rrrr rnrorqrerfrMrzr|rrrrrk�sJrkc@s�eZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dd�Z
dd�Zdd�ZdS)�BaseSemaphoreTestszB
    Common tests for {bounded, unbounded} semaphore objects.
    cCs:|jt|jdd�|jt|jdtj�dS)N�valuer6���)r@rK�semtype�sys�maxsize)rrrrr*Ksz#BaseSemaphoreTests.test_constructorcCs^|jd�}|j�|j�|jd�}|j�|j�|j�|j�dS)Nr6rP)r�r.r1)r�semrrrrnOs




zBaseSemaphoreTests.test_acquirecCs|j�}|j�~dS)N)r�r.)rr�rrrr0Ys
z'BaseSemaphoreTests.test_acquire_destroycs�|jd���j�d}g�g�d�����fdd�}t|d�}|j�x't��t��dkr�t�qhW|j��dgd�d�xtd�D]}�j�q�Wx't��t��dkr�t�q�W|jt	���dgddgd�d	�xtd�D]}�j�q:Wx't��t��d
krwt�qQW|jt	���dgddgdd	gd�|j
�jd���j�|j�dS)N��
rcs2�j��j���j��j��dS)N)r.rr)rrrcrdr�rrres


z4BaseSemaphoreTests.test_acquire_contended.<locals>.f�r6�
rP�F)r�r.r
rrr	r:rr1�sortedr7r)rr;rr<rr)rrrcrdr�rr=^s6

,7
z)BaseSemaphoreTests.test_acquire_contendedcCsu|jd�}|j|jd��|j|jd��|j|jd��|j�|j|jd��dS)NrPF)r�r3r.r7r1)rr�rrrr4�s
z#BaseSemaphoreTests.test_try_acquirecss|jd���j�g���fdd�}t|d�j�|jt��dgddgd�dS)	Nrvcs0�j�jd���j�jd��dS)NF)rr.r)rJr�rrr�sz8BaseSemaphoreTests.test_try_acquire_contended.<locals>.fr9Fr�Trt)r�r.r
rr:r�)rrr)rJr�rr8�s
z-BaseSemaphoreTests.test_try_acquire_contendedcCs�|jd�}|jt|jddd�|j|jdd��|j|jdd��|j|jdd��|j�|j|jdd��tj�}|j|jdd��tj�|}|j|d�dS)NrPFrFg�?g{�G�zt?g�?)	r�r@rKr.r3r7r1rr&)rr��trhrrr�test_acquire_timeout�s
z'BaseSemaphoreTests.test_acquire_timeoutcsp|j���j��fdd�}t|d�}|j�t�|j|j��j�|j�dS)Ncs�j��j�dS)N)r.r1r)r�rrr�s
z0BaseSemaphoreTests.test_default_value.<locals>.fr6)	r�r.r
rr	r7rr1r)rrr<r)r�r�test_default_value�s


z%BaseSemaphoreTests.test_default_valuecs��jd��d��fdd�}|��j�jd���j��jt|t��j�jd���j�dS)NrPcsb��U�j�jd���j���'�j�jd��|rP|�WdQRXWdQRXdS)NF)r3r.r1r7)r>)rr�rrr?�s
z+BaseSemaphoreTests.test_with.<locals>._withF)r�r3r.r1r@rA)rr?r)rr�rrB�s
zBaseSemaphoreTests.test_withN)
rrrr r*rnr0r=r4r8r�r�rBrrrrr}Fs
#

r}c@s"eZdZdZdd�ZdS)�SemaphoreTestsz)
    Tests for unbounded semaphores.
    cCs;|jd�}|j�|j�|j�|j�dS)Nr6)r�r1r.)rr�rrrrW�s



z&SemaphoreTests.test_release_unacquiredN)rrrr rWrrrrr��sr�c@s"eZdZdZdd�ZdS)�BoundedSemaphoreTestsz'
    Tests for bounded semaphores.
    cCsJ|j�}|jt|j�|j�|j�|jt|j�dS)N)r�r@rKr1r.)rr�rrrrW�s


z-BoundedSemaphoreTests.test_release_unacquiredN)rrrr rWrrrrr��sr�c@s�eZdZdZdZdZdd�Zdd�Zdd	�Zd
d�Z	dd
d�Z
dd�Zdd�Zdd�Z
dd�Zdd�Zdd�Zdd�Zdd�Zdd �Zd!S)"�BarrierTestsz$
    Tests for Barrier objects.
    r9g@cCs"|j|jd|j�|_dS)NrF)�barriertyper;�defaultTimeout�barrier)rrrrr#�szBarrierTests.setUpcCs|jj�dS)N)r��abort)rrrrr$�szBarrierTests.tearDowncCs+t||jd�}|�|j�dS)Nr6)r
r;r)rrr<rrr�run_threads�szBarrierTests.run_threadscCs�|jj}|j||j�x�t|�D]�}|djd�|jt|d�||�|jj�|djd�|jt|d�|d|�|jj�q,W|j|jjd�|j	|jj
�dS)NrTr6)r�Zpartiesr:r;rrrrb�	n_waitingr7�broken)rrJr�mrrrr�	multipass�s
"zBarrierTests.multipassr6cs5ggg����fdd�}�j|�dS)z;
        Test that a barrier is passed in lockstep
        cs�j���dS)N)r�r)�passesrJrrrrsz$BarrierTests.test_barrier.<locals>.fN)r�)rr�rr)r�rJrr�test_barrier�szBarrierTests.test_barriercCs
|jd�S)zC
        Test that a barrier works for 10 consecutive runs
        r�)r�)rrrr�test_barrier_10szBarrierTests.test_barrier_10csQg���fdd�}�j|��jt��tt�j���dS)z9
        test the return value from barrier.wait
        cs �jj�}�j|�dS)N)r�rbr)rg)rJrrrrsz(BarrierTests.test_wait_return.<locals>.fN)r�r:�sumrr;)rrr)rJrr�test_wait_returns
zBarrierTests.test_wait_returncsVg��fdd�}�j�j|�����fdd�}�j|�dS)z,
        Test the 'action' callback
        cs�jd�dS)NT)rr)rJrr�actionsz(BarrierTests.test_action.<locals>.actioncs$�j��jt��d�dS)Nr6)rbr:rr)r�rJrrrrs
z#BarrierTests.test_action.<locals>.fN)r�r;r�)rr�rr)r�rJrr�test_actions
zBarrierTests.test_actioncs{g�g����fdd�}�j|��jt��d��jt���jd��j�jj�dS)zK
        Test that an abort will put the barrier in a broken state
        cs�yF�jj�}|�jdkr+t��jj��jd�Wn@tjk
rj�jd�Yntk
r��jj�YnXdS)NrPT)r�rbr;rVrr�BrokenBarrierErrorr�)r)rcrdrrrr+s


z"BarrierTests.test_abort.<locals>.frr6N)r�r:rr;r3r�r�)rrr)rcrdrr�
test_abort%s

zBarrierTests.test_abortcs�g�g�g�����fdd�}�j|��jt��d��jt���jd��jt���j�dS)zL
        Test that a 'reset' on a barrier frees the waiting threads
        cs��jj�}|�jdkr_x*�jj�jdkrNtjd�q%W�jj�nCy�jj��jd�Wn"tj	k
r��jd�YnX�jj��jd�dS)NrPr6g����MbP?T)
r�rbr;r�rr�resetrrr�)r)rcrd�results3rrrrDs

z"BarrierTests.test_reset.<locals>.frr6N)r�r:rr;)rrr)rcrdr�rr�
test_reset=s
zBarrierTests.test_resetcs�g�g�g��j�j�������fdd�}�j|��jt��d��jt���jd��jt���j�dS)zF
        Test that a barrier can be reset after being broken.
        cs�yF�jj�}|�jdkr+t��jj��jd�Wn@tjk
rj�jd�Yntk
r��jj�YnX�j��jdkr��jj��j��jj��jd�dS)NrPT)	r�rbr;rVrrr�r�r�)r)�barrier2rcrdr�rrrrcs 





z,BarrierTests.test_abort_and_reset.<locals>.frr6N)r�r;r�r:r)rrr)r�rcrdr�rr�test_abort_and_reset[s
z!BarrierTests.test_abort_and_resetcs#�fdd�}�j|�dS)z$
        Test wait(timeout)
        csO�jj�}|�jdkr/tjd��jtj�jjd�dS)NrPg�?g�?)r�rbr;rrr@rr�)r)rrrr�s

z$BarrierTests.test_timeout.<locals>.fN)r�)rrr)rrrM}szBarrierTests.test_timeoutcs>�j�jdd����fdd�}�j|�dS)z4
        Test the barrier's default timeout
        rFg333333�?csF�j�}|�jdkr,tjd��jtj�j�dS)NrPg�?)rbr;rrr@rr�)r)r�rrrr�s
z,BarrierTests.test_default_timeout.<locals>.fN)r�r;r�)rrr)r�rr�test_default_timeout�sz!BarrierTests.test_default_timeoutcCs'|jd�}|j�|j�dS)Nr6)r�rb)rr<rrr�test_single_thread�s
zBarrierTests.test_single_threadN)rrrr r;r�r#r$r�r�r�r�r�r�r�r�r�rMr�r�rrrrr��s"
	"r�)r r�r�_threadrrrZunittestZtestrr	�objectr
ZTestCaser!r'rNrUr\rkr}r�r�r�rrrr�<module>s$+|.B]�|