Your IP : 216.73.216.213

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



��Yf���@s�dZddlZddlmZmZmZmZddlmZm	Z	ddl
Z
ddlZddlZed�Z
ed�ZddlZddlZddlZddlZddlZddlmZdd	d
ddfZGd
d�de�ZGdd�dej�ZGdd�dej�ZGdd�de�ZGdd�de�ZGdd�de�ZGdd�de�ZGdd�de�Z Gdd�dej!�Z!Gdd �d ej"�Z#ej$ej%dkd!�Gd"d#�d#ej"��Z&Gd$d%�d%ej'�Z'Gd&d'�d'ej"�Z(Gd(d)�d)ej)�Z)Gd*d+�d+ej*�Z*Gd,d-�d-ej+�Z+Gd.d/�d/ej,�Z,e-d0kr�ej.�dS)1z!
Tests for the threading module.
�N)�verbose�
import_module�cpython_only�requires_type_collecting)�assert_python_ok�assert_python_failure�_thread�	threading)�
lock_testsZfreebsd4Zfreebsd5Zfreebsd6Znetbsd5zhp-ux11c@s@eZdZdd�Zdd�Zdd�Zdd�Zd	S)
�CountercCs
d|_dS)Nr)�value)�self�r�8/opt/alt/python35/lib64/python3.5/test/test_threading.py�__init__"szCounter.__init__cCs|jd7_dS)N�)r)r
rrr�inc$szCounter.inccCs|jd8_dS)Nr)r)r
rrr�dec&szCounter.deccCs|jS)N)r)r
rrr�get(szCounter.getN)�__name__�
__module__�__qualname__rrrrrrrrr!src@s(eZdZdd�Zdd�ZdS)�
TestThreadcCs>tjj|d|�||_||_||_||_dS)N�name)r	�Threadr�testcase�sema�mutex�nrunning)r
rrrrrrrrr,s
			zTestThread.__init__cCs"tj�d}tr1td|j|df�|j��|j�J|jj�trnt|jj�d�|j	j
|jj�d�WdQRXtj|�tr�td|jd�|j�T|jj
�|j	j|jj�d�trtd	|j|jj�f�WdQRXWdQRXdS)
Ng��@ztask %s will run for %.1f usecg��.Aztasks are running�Ztask�donerz$%s is finished. %d tasks are running)�randomr�printrrrrrrrZassertLessEqual�time�sleeprZassertGreaterEqual)r
Zdelayrrr�run3s&


#


zTestThread.runN)rrrrr%rrrrr+src@s(eZdZdd�Zdd�ZdS)�BaseTestCasecCstjj�|_dS)N)�test�supportZthreading_setup�_threads)r
rrr�setUpMszBaseTestCase.setUpcCs$tjj|j�tjj�dS)N)r'r(Zthreading_cleanupr)Z
reap_children)r
rrr�tearDownPszBaseTestCase.tearDownN)rrrr*r+rrrrr&Lsr&c@s�eZdZdd�Zdd�Zdd�Zdd�Zd	d
�Zdd�Zd
d�Z	dd�Z
dd�Zdd�Zdd�Z
dd�Zdd�Zdd�Zdd�Zejeed�d �d!d"��Zejeed�d#�d$d%��Zd&d'�Zejeed�d(�ejeed)�d*�d+d,���Zejejekd-�ejeed�d(�ejeed)�d*�d.d/����Zd0d1�Zd2d3�Z d4d5�Z!e"d6d7��Z#d8S)9�ThreadTestscCsDd}tjdd�}tj�}t�}g}xmt|�D]_}td|||||�}|j|�|j|j�|j	t
|�d�|j�q@Wtr�t
d�xd|D]\}|j�|j|j��|j|jd�|j|j�|j	t
|�d�q�Wtr*t
d	�|j|j�d�dS)
N�
rrz<thread %d>z^<TestThread\(.*, initial\)>$z!waiting for all tasks to completerz#^<TestThread\(.*, stopped -?\d+\)>$zall tasks done)r	�BoundedSemaphore�RLockr�ranger�append�assertIsNone�ident�assertRegex�repr�startrr"�join�assertFalse�is_alive�assertNotEqual�assertIsNotNone�assertEqualr)r
ZNUMTASKSrrZ
numrunning�threads�i�trrr�test_various_opsYs,	




zThreadTests.test_various_opscsz|jtj�j���fdd�}tj��g�tj|f��j�|j�d�tj�d=dS)Ncs$�jtj�j��j�dS)N)r1r	�
currentThreadr3�setr)r r3rr�f{sz9ThreadTests.test_ident_of_no_threading_threads.<locals>.fr)	r;r	rAr3�Eventr�start_new_thread�wait�_active)r
rCr)r r3r�"test_ident_of_no_threading_threadsxs
z.ThreadTests.test_ident_of_no_threading_threadscCsctrtd�ytjd�Wn$tjk
rGtjd��YnX|j�tjd�dS)Nzwith 256kB thread stack size...iz4platform does not support changing thread stack sizer)	rr"r	�
stack_sizer�error�unittest�SkipTestr@)r
rrr�test_various_ops_small_stack�s

z(ThreadTests.test_various_ops_small_stackcCsctrtd�ytjd�Wn$tjk
rGtjd��YnX|j�tjd�dS)Nzwith 1MB thread stack size...iz4platform does not support changing thread stack sizer)	rr"r	rIrrJrKrLr@)r
rrr�test_various_ops_large_stack�s

z(ThreadTests.test_various_ops_large_stackcCs�dd�}tj�}|j�tj||f�}|j�|j|tj�|jtj|tj�|j	tj|j
��|jttj|�d�tj|=dS)NcSstj�|j�dS)N)r	�current_thread�release)rrrrrC�s
z*ThreadTests.test_foreign_thread.<locals>.f�_DummyThread)
r	�Lock�acquirerrE�assertInrG�assertIsInstancerQ�
assertTruer9r4r5)r
rCr�tidrrr�test_foreign_thread�s

zThreadTests.test_foreign_threadc	s3td�}|jj}Gdd�dt��|j��}tj�}y#||j|�|�}xqgWWn�k
r�YnX|jd�y|j	|d�Wnt
k
r�YnXtj��tj��G���fdd�dtj�}|�}d|_
|j�tr td	�tr0td
�||jd�|�}|j	|d�trhtd��j�}|j|�tr�td
�|j|j�tr�td�||j|j�|�}|j	|d�tr�td��jdd�|j|j�trtd�|jr/|j�dS)N�ctypesc@seZdZdS)z<ThreadTests.test_PyThreadState_SetAsyncExc.<locals>.AsyncExcN)rrrrrrr�AsyncExc�srZzAsyncExc not raisedrcs(eZdZ���fdd�ZdS)z:ThreadTests.test_PyThreadState_SetAsyncExc.<locals>.Workercsftj�|_d|_y"x�j�tjd�qWWn%�k
rad|_�j�YnXdS)NFg�������?T)r	�	get_ident�id�finishedrBr#r$)r
)rZ�worker_saw_exception�worker_startedrrr%�s	

	z>ThreadTests.test_PyThreadState_SetAsyncExc.<locals>.Worker.runN)rrrr%r)rZr^r_rr�Worker�sr`Tz    started worker threadz     trying nonsensical thread idrz,    waiting for worker thread to get startedz"    verifying worker hasn't exitedz2    attempting to raise asynch exception in workerz5    waiting for worker to say it caught the exception�timeoutr-z    all OK -- joining worker���)rZ	pythonapiZPyThreadState_SetAsyncExc�	ExceptionZ	py_objectr	r[Zc_longZfailr<�UnboundLocalErrorrDr�daemonr6rr"rFrVr8r]r\r7)	r
rYZ
set_async_excZ	exceptionrW�resultr`r?�retr)rZr^r_r�test_PyThreadState_SetAsyncExc�s^


%
		








	z*ThreadTests.test_PyThreadState_SetAsyncExccCszdd�}tj}|t_zKtjddd��}|jtj|j�|j|tjkd�Wd|t_XdS)NcWstj��dS)N)r	�ThreadError)�argsrrr�fail_new_threadsz7ThreadTests.test_limbo_cleanup.<locals>.fail_new_thread�targetcSsdS)Nrrrrr�<lambda>sz0ThreadTests.test_limbo_cleanup.<locals>.<lambda>z:Failed to cleanup _limbo map on failure of Thread.start().)r	�_start_new_threadr�assertRaisesrir6r8Z_limbo)r
rkrnr?rrr�test_limbo_cleanup	s		zThreadTests.test_limbo_cleanupcCs6td�tdd�\}}}|j|d�dS)NrYz-caNif 1:
            import ctypes, sys, time, _thread

            # This lock is used as a simple event variable.
            ready = _thread.allocate_lock()
            ready.acquire()

            # Module globals are cleared before __del__ is run
            # So we save the functions in class dict
            class C:
                ensure = ctypes.pythonapi.PyGILState_Ensure
                release = ctypes.pythonapi.PyGILState_Release
                def __del__(self):
                    state = self.ensure()
                    self.release(state)

            def waitingThread():
                x = C()
                ready.release()
                time.sleep(100)

            _thread.start_new_thread(waitingThread, ())
            ready.acquire()  # Be sure the other thread is waiting.
            sys.exit(42)
            �*)rrr<)r
�rc�out�errrrr�test_finalize_runnning_threads
z)ThreadTests.test_finalize_runnning_threadcCstdd�dS)Nz-caPif 1:
            import sys, threading

            # A deadlock-killer, to prevent the
            # testsuite to hang forever
            def killer():
                import os, time
                time.sleep(2)
                print('program blocked; aborting')
                os._exit(2)
            t = threading.Thread(target=killer)
            t.daemon = True
            t.start()

            # This is the trace function
            def func(frame, event, arg):
                threading.current_thread()
                return func

            sys.settrace(func)
            )r)r
rrr�test_finalize_with_trace9sz$ThreadTests.test_finalize_with_tracecCsBtdd�\}}}|j|j�d�|j|d�dS)Nz-ca�if 1:
                import threading
                from time import sleep

                def child():
                    sleep(1)
                    # As a non-daemon thread we SHOULD wake up and nothing
                    # should be torn down yet
                    print("Woke up, sleep function is:", sleep)

                threading.Thread(target=child).start()
                raise SystemExit
            s5Woke up, sleep function is: <built-in function sleep>�)rr<�strip)r
rrrsrtrrr�test_join_nondaemon_on_shutdownRs
z+ThreadTests.test_join_nondaemon_on_shutdownc
Cs�tj}tj�}z�xztdd�D]i}tj|d�tjddd��}|j�|j�|�}|j	||d||f�q(WWdtj|�XdS)Nr�dg-C��6*?rlcSsdS)Nrrrrrrmnsz7ThreadTests.test_enumerate_after_join.<locals>.<lambda>z&#1703448 triggered after %d trials: %s)
r	�	enumerate�sys�getswitchintervalr0�setswitchintervalrr6r7�assertNotIn)r
Zenum�old_intervalr>r?�lrrr�test_enumerate_after_joinfs	

	z%ThreadTests.test_enumerate_after_joincCs�Gdd�dt�}|dd�}tj|�}|jj�~|j|�ddtj|���|dd�}tj|�}|jj�~|j|�ddtj|���dS)Nc@s(eZdZdd�Zdd�ZdS)zDThreadTests.test_no_refcycle_through_target.<locals>.RunSelfFunctioncSsG||_tjd|jd|fdd|i�|_|jj�dS)Nrlrj�kwargs�yet_another)�should_raiser	r�_run�threadr6)r
r�rrrrys
		zMThreadTests.test_no_refcycle_through_target.<locals>.RunSelfFunction.__init__cSs|jrt�dS)N)r��
SystemExit)r
Z	other_refr�rrrr��s	zIThreadTests.test_no_refcycle_through_target.<locals>.RunSelfFunction._runN)rrrrr�rrrr�RunSelfFunctionxs	r�r�F�msgz%d references still aroundT)�object�weakref�refr�r7r2r|�getrefcount)r
r�Z
cyclic_objectZweak_cyclic_objectZraising_cyclic_objectZweak_raising_cyclic_objectrrr�test_no_refcycle_through_targetws

z+ThreadTests.test_no_refcycle_through_targetcCshtj�}|j�|jd�|j�|jd�|j�tj�}|j�tj	�dS)NTr)
r	rZisDaemonZ	setDaemonZgetNameZsetNameZisAliverDZisSetZactiveCount)r
r?�errr�test_old_threading_api�s





z"ThreadTests.test_old_threading_apicCsEtj�}|jdt|��d|_|jdt|��dS)NreT)r	rrr5rerT)r
r?rrr�test_repr_daemon�s	zThreadTests.test_repr_daemoncCsdtj�}|j|j�tjdd�}|j|j�tjdd�}|j|j�dS)NreFT)r	rr8rerV)r
r?rrr�test_deamon_param�szThreadTests.test_deamon_param�forkztest needs fork()cCsBd}td|�\}}}|j|d�|j|d�dS)Na�if 1:
            import _thread, threading, os, time

            def background_thread(evt):
                # Creates and registers the _DummyThread instance
                threading.current_thread()
                evt.set()
                time.sleep(10)

            evt = threading.Event()
            _thread.start_new_thread(background_thread, (evt,))
            evt.wait()
            assert threading.active_count() == 2, threading.active_count()
            if os.fork() == 0:
                assert threading.active_count() == 1, threading.active_count()
                os._exit(0)
            else:
                os.wait()
        z-crw)rr<)r
�code�_rsrtrrr�test_dummy_thread_after_fork�sz(ThreadTests.test_dummy_thread_after_forkzneeds os.fork()cCs�tj�}|jtj|�tjd�x�td�D]�}tjddd��}|j�tj	�}|dkr�tj
|j�r�dnd�q9|j�tj
|d�\}}|jtj|��|jdtj|��q9WdS)	Ng���ư>�rlcSsdS)Nrrrrrrm�sz6ThreadTests.test_is_alive_after_fork.<locals>.<lambda>r�r-)r|r}�
addCleanupr~r0r	rr6�osr��_exitr9r7�waitpidrV�	WIFEXITEDr<�WEXITSTATUS)r
r�r>r?�pid�statusrrr�test_is_alive_after_fork�s

"
z$ThreadTests.test_is_alive_after_forkcs�tj�}�j|jd��j|jtj�j��j|jtj���fdd�}tjd|�}|j�|j	�dS)NZ
MainThreadcs&�jtj�jtj�j�dS)N)r:r	�main_threadr3rOr)r
rrrC�sz'ThreadTests.test_main_thread.<locals>.frl)
r	r�r<rr3rOr[rr6r7)r
�mainrCZthr)r
r�test_main_thread�s
zThreadTests.test_main_threadztest needs os.fork()r�ztest needs os.waitpid()cCsZd}td|�\}}}|j�jdd�}|j|d�|j|d�dS)Nakif 1:
            import os, threading

            pid = os.fork()
            if pid == 0:
                main = threading.main_thread()
                print(main.name)
                print(main.ident == threading.current_thread().ident)
                print(main.ident == threading.get_ident())
            else:
                os.waitpid(pid, 0)
        z-c�
�rwzMainThread
True
True
)r�decode�replacer<)r
r�r�rsrt�datarrr�test_main_thread_after_fork�s
z'ThreadTests.test_main_thread_after_forkzdue to known OS bugcCsZd}td|�\}}}|j�jdd�}|j|d�|j|d�dS)Na�if 1:
            import os, threading, sys

            def f():
                pid = os.fork()
                if pid == 0:
                    main = threading.main_thread()
                    print(main.name)
                    print(main.ident == threading.current_thread().ident)
                    print(main.ident == threading.get_ident())
                    # stdout is fully buffered because not a tty,
                    # we have to flush before exit.
                    sys.stdout.flush()
                else:
                    os.waitpid(pid, 0)

            th = threading.Thread(target=f)
            th.start()
            th.join()
        z-cr�r�rwzThread-1
True
True
)rr�r�r<)r
r�r�rsrtr�rrr�/test_main_thread_after_fork_from_nonmain_threads
z;ThreadTests.test_main_thread_after_fork_from_nonmain_threadcstj��tj���j��j���fdd�}tjd|�}|j|jd�|j��j�|j|j	��|j}|j
|jdd�d��j�|j|jdd�d�|j|j	��|j�|j
|j	��|j|j�dS)Ncs%�j��j�tjd�dS)Ng{�G�z�?)rPrSr#r$r)�finish�startedrrrC's

z'ThreadTests.test_tstate_lock.<locals>.frlrarF�)
r�
allocate_lockrSr	rZassertIsZ_tstate_lockr6rVr9r8rPr2)r
rCr?Ztstate_lockr)r�r�r�test_tstate_lock!s$



	

zThreadTests.test_tstate_lockcs�tj��tj���j��j���fdd�}tjd|�}|j��j�|jdt|���j�d}x4t	d�D]&}|t|�kr�Pt
jd�q�W|j|t|��dS)Ncs�j��j�dS)N)rPrSr)r�r�rrrCIs
z(ThreadTests.test_repr_stopped.<locals>.frlr�Zstoppedi�g{�G�z�?)rr�rSr	rr6rTr5rPr0r#r$)r
rCr?ZLOOKING_FORr>r)r�r�r�test_repr_stoppedCs 




zThreadTests.test_repr_stoppedcs�x�tdd�D]�}tj|���fdd�t|�D�}x|D]}|j�qKWx|D]}|j�qfW�fdd�t|�D�}x|D]}|j�q�Wx|D]}|j�q�W|jt�j�qWdS)Nrr-cs%g|]}tjd�j��qS)rl)r	rrS)�.0r�)�bsrr�
<listcomp>as	z;ThreadTests.test_BoundedSemaphore_limit.<locals>.<listcomp>cs%g|]}tjd�j��qS)rl)r	rrP)r�r�)r�rrr�gs	)r0r	r.r6r7ro�
ValueErrorrP)r
�limitr=r?r)r�r�test_BoundedSemaphore_limit]s



z'ThreadTests.test_BoundedSemaphore_limitcs��fdd��dd����fdd��d�_tj�}tj��zHtj��ddl}|j��xtd�D]
}��q�WWdtj|�XdS)	Ncs�S)Nr)�frameZevent�arg)�
noop_tracerrr�wsz9ThreadTests.test_frame_tstate_tracing.<locals>.noop_tracecssx	dVqWdS)N�	generatorrrrrrr�{sz8ThreadTests.test_frame_tstate_tracing.<locals>.generatorcs(�jdkr���_t�j�S)N)�gen�nextr)�callbackr�rrr�sz7ThreadTests.test_frame_tstate_tracing.<locals>.callbackrr)r�r|�gettrace�settracer	�	_testcapiZcall_in_temporary_c_threadr0)r
Z	old_tracer�r'r)r�r�r�r�test_frame_tstate_tracingos	


z%ThreadTests.test_frame_tstate_tracingN)$rrrr@rHrMrNrXrhrprurvryr�r�r�r�r�rK�
skipUnless�hasattrr�r�r�r�r��skipIfr|�platform�platforms_to_skipr�r�r�r�rr�rrrrr,Us6U!
''
*-"r,c@s<eZdZdd�Zdd�Zejeed�d�ej	e
jekd�dd	���Z
ejeed�d�ej	e
jekd�d
d���Zej	e
jekd�dd
��Zejeed�d�ej	e
jekd�dd���Zejeed�d�dd��ZdS)�ThreadJoinOnShutdowncCsNd|}td|�\}}}|j�jdd�}|j|d�dS)Na�if 1:
            import sys, os, time, threading

            # a thread, which waits for the main program to terminate
            def joiningfunc(mainthread):
                mainthread.join()
                print('end of thread')
                # stdout is fully buffered because not a tty, we have to flush
                # before exit.
                sys.stdout.flush()
        
z-cr�r�zend of main
end of thread
)rr�r�r<)r
�scriptrrrsrtr�rrr�
_run_and_join�s
z"ThreadJoinOnShutdown._run_and_joincCsd}|j|�dS)Nz�if 1:
            import os
            t = threading.Thread(target=joiningfunc,
                                 args=(threading.current_thread(),))
            t.start()
            time.sleep(0.1)
            print('end of main')
            )r�)r
r�rrr�test_1_join_on_shutdown�s	z,ThreadJoinOnShutdown.test_1_join_on_shutdownr�zneeds os.fork()zdue to known OS bugcCsd}|j|�dS)NaGif 1:
            childpid = os.fork()
            if childpid != 0:
                os.waitpid(childpid, 0)
                sys.exit(0)

            t = threading.Thread(target=joiningfunc,
                                 args=(threading.current_thread(),))
            t.start()
            print('end of main')
            )r�)r
r�rrr�test_2_join_in_forked_process�sz2ThreadJoinOnShutdown.test_2_join_in_forked_processcCsd}|j|�dS)Na:if 1:
            main_thread = threading.current_thread()
            def worker():
                childpid = os.fork()
                if childpid != 0:
                    os.waitpid(childpid, 0)
                    sys.exit(0)

                t = threading.Thread(target=joiningfunc,
                                     args=(main_thread,))
                print('end of main')
                t.start()
                t.join() # Should not block: main_thread is already stopped

            w = threading.Thread(target=worker)
            w.start()
            )r�)r
r�rrr�!test_3_join_in_forked_from_thread�sz6ThreadJoinOnShutdown.test_3_join_in_forked_from_threadcCs/d}td|�\}}}|j|�dS)Na�if True:
            import os
            import random
            import sys
            import time
            import threading

            thread_has_run = set()

            def random_io():
                '''Loop for a while sleeping random tiny amounts and doing some I/O.'''
                while True:
                    in_f = open(os.__file__, 'rb')
                    stuff = in_f.read(200)
                    null_f = open(os.devnull, 'wb')
                    null_f.write(stuff)
                    time.sleep(random.random() / 1995)
                    null_f.close()
                    in_f.close()
                    thread_has_run.add(threading.current_thread())

            def main():
                count = 0
                for _ in range(40):
                    new_thread = threading.Thread(target=random_io)
                    new_thread.daemon = True
                    new_thread.start()
                    count += 1
                while len(thread_has_run) < count:
                    time.sleep(0.001)
                # Trigger process shutdown
                sys.exit(0)

            main()
            z-c)rr8)r
r�rrrsrtrrr�test_4_daemon_threads�s'z*ThreadJoinOnShutdown.test_4_daemon_threadscCsqdd�}g}x=td�D]/}tjd|�}|j|�|j�qWx|D]}|j�qYWdS)NcSs<tj�}|dkr+tj|d�n
tjd�dS)Nr)r�r�r�r�)r�rrr�do_fork_and_waitszIThreadJoinOnShutdown.test_reinit_tls_after_fork.<locals>.do_fork_and_wait�rl)r0r	rr1r6r7)r
r�r=r>r?rrr�test_reinit_tls_after_forks	

z/ThreadJoinOnShutdown.test_reinit_tls_after_forkcCs�g}xCtd�D]5}tjddd��}|j|�|j�qWtj�}|dkr�ttj	��dkr�tj
d�q�tj
d�n(tj|d�\}}|jd|�x|D]}|j
�q�WdS)Nr�rlcSs
tjd�S)Ng333333�?)r#r$rrrrrm+szKThreadJoinOnShutdown.test_clear_threads_states_after_fork.<locals>.<lambda>rr)r0r	rr1r6r�r��lenr|�_current_framesr�r�r<r7)r
r=r>r?r�r�r�rrr�$test_clear_threads_states_after_fork$s

z9ThreadJoinOnShutdown.test_clear_threads_states_after_forkN)rrrr�r�rKr�r�r�r�r|r�r�r�r�r�r�r�rrrrr��s**'+*r�c@s:eZdZdd�Zdd�Zedd��ZdS)�SubinterpThreadingTestscCs�tj�\}}|jtj|�|jtj|�d|f}tjj|�}|j|d�|jtj|d�d�dS)Na\if 1:
            import os
            import threading
            import time

            def f():
                # Sleep a bit so that the thread is still running when
                # Py_EndInterpreter is called.
                time.sleep(0.05)
                os.write(%d, b"x")
            threading.Thread(target=f).start()
            rr�x)	r��piper��closer'r(�run_in_subinterpr<�read)r
�r�wr�rgrrr�test_threads_join@s
z)SubinterpThreadingTests.test_threads_joincCs�tj�\}}|jtj|�|jtj|�d|f}tjj|�}|j|d�|jtj|d�d�dS)Naif 1:
            import os
            import threading
            import time

            class Sleeper:
                def __del__(self):
                    time.sleep(0.05)

            tls = threading.local()

            def f():
                # Sleep a bit so that the thread is still running when
                # Py_EndInterpreter is called.
                time.sleep(0.05)
                tls.x = Sleeper()
                os.write(%d, b"x")
            threading.Thread(target=f).start()
            rrr�)	r�r�r�r�r'r(r�r<r�)r
r�r�r�rgrrr�test_threads_join_2Ws
z+SubinterpThreadingTests.test_threads_join_2c
Cs\d}d|f}tjj��td|�\}}}WdQRX|jd|j��dS)NaAif 1:
            import os
            import threading
            import time

            def f():
                # Make sure the daemon thread is still running when
                # Py_EndInterpreter is called.
                time.sleep(10)
            threading.Thread(target=f, daemon=True).start()
            z[if 1:
            import _testcapi

            _testcapi.run_in_subinterp(%r)
            z-cz:Fatal Python error: Py_EndInterpreter: not the last thread)r'r(ZSuppressCrashReportrrTr�)r
Zsubinterp_coder�rrrsrtrrr�test_daemon_threads_fatal_errorws
	z7SubinterpThreadingTests.test_daemon_threads_fatal_errorN)rrrr�r�rr�rrrrr�>s r�c@s�eZdZdd�Zdd�Zdd�Zdd�Zd	d
�Zej	e
jdkoiej
j�d�d
d��Zdd�Zedd��Zdd�Zdd�ZdS)�ThreadingExceptionTestscCs-tj�}|j�|jt|j�dS)N)r	rr6ro�RuntimeError)r
r�rrr�test_start_thread_again�s
z/ThreadingExceptionTests.test_start_thread_againcCs#tj�}|jt|j�dS)N)r	rOror�r7)r
rOrrr�test_joining_current_thread�sz3ThreadingExceptionTests.test_joining_current_threadcCs#tj�}|jt|j�dS)N)r	rror�r7)r
r�rrr�test_joining_inactive_thread�sz4ThreadingExceptionTests.test_joining_inactive_threadcCs3tj�}|j�|jtt|dd�dS)NreT)r	rr6ror��setattr)r
r�rrr�test_daemonize_active_thread�s
z4ThreadingExceptionTests.test_daemonize_active_threadcCs#tj�}|jt|j�dS)N)r	rRror�rP)r
�lockrrr�test_releasing_unacquired_lock�sz6ThreadingExceptionTests.test_releasing_unacquired_lock�darwinztest macosx problemcCs�d}d}tjtjd|gdtjdtj�}|j�\}}|j�jdd�}|j|j	dd	|j��|j||�dS)
Naif True:
            import threading

            def recurse():
                return recurse()

            def outer():
                try:
                    recurse()
                except RecursionError:
                    pass

            w = threading.Thread(target=outer)
            w.start()
            w.join()
            print('end of main thread')
            zend of main thread
z-c�stdout�stderrr�r�rzUnexpected error: )
�
subprocess�Popenr|�
executable�PIPEZcommunicater�r�r<�
returncode)r
r�Zexpected_output�pr�r�r�rrr�test_recursion_limit�s z,ThreadingExceptionTests.test_recursion_limitcCs~d}td|�\}}}|j|d�|j�}|jd|�|jd|�|jd|�|jd|�dS)Na�if True:
            import threading
            import time

            running = False
            def run():
                global running
                running = True
                while running:
                    time.sleep(0.01)
                1/0
            t = threading.Thread(target=run)
            t.start()
            while not running:
                time.sleep(0.01)
            running = False
            t.join()
            z-crwzException in threadz"Traceback (most recent call last):�ZeroDivisionErrorzUnhandled exception)rr<r�rTr)r
r�rrrsrtrrr�test_print_exception�sz,ThreadingExceptionTests.test_print_exceptioncCs~d}td|�\}}}|j|d�|j�}|jd|�|jd|�|jd|�|jd|�dS)Na�if True:
            import sys
            import threading
            import time

            running = False
            def run():
                global running
                running = True
                while running:
                    time.sleep(0.01)
                1/0
            t = threading.Thread(target=run)
            t.start()
            while not running:
                time.sleep(0.01)
            sys.stderr = None
            running = False
            t.join()
            z-crwzException in threadz"Traceback (most recent call last):r�zUnhandled exception)rr<r�rTr)r
r�rrrsrtrrr�%test_print_exception_stderr_is_none_1�sz=ThreadingExceptionTests.test_print_exception_stderr_is_none_1cCsHd}td|�\}}}|j|d�|jd|j��dS)Na�if True:
            import sys
            import threading
            import time

            running = False
            def run():
                global running
                running = True
                while running:
                    time.sleep(0.01)
                1/0
            sys.stderr = None
            t = threading.Thread(target=run)
            t.start()
            while not running:
                time.sleep(0.01)
            running = False
            t.join()
            z-crwzUnhandled exception)rr<rr�)r
r�rrrsrtrrr�%test_print_exception_stderr_is_none_2sz=ThreadingExceptionTests.test_print_exception_stderr_is_none_2csodd��G�fdd�dtj�}|�}|j�|j�|j|j�|j|jt�dS)NcSs�dS)Nrrrrr�
bare_raiseszOThreadingExceptionTests.test_bare_raise_in_brand_new_thread.<locals>.bare_raisecs(eZdZdZ�fdd�ZdS)zOThreadingExceptionTests.test_bare_raise_in_brand_new_thread.<locals>.Issue27558Ncs@y��Wn.tk
r;}z||_WYdd}~XnXdS)N)rc�exc)r
r�)r�rrr%"szSThreadingExceptionTests.test_bare_raise_in_brand_new_thread.<locals>.Issue27558.run)rrrr�r%r)r�rr�
Issue27558sr�)r	rr6r7r;r�rUr�)r
r�r�r)r�r�#test_bare_raise_in_brand_new_threads		

z;ThreadingExceptionTests.test_bare_raise_in_brand_new_threadN)rrrr�r�r�r�r�rKr�r|r�r'r(Zpython_is_optimizedr�r�rr�r�r�rrrrr��s! r�c@s4eZdZdd�Zdd�Zdd�ZdS)�
TimerTestscCs)tj|�g|_tj�|_dS)N)r&r*�
callback_argsr	rD�callback_event)r
rrrr*0s
	zTimerTests.setUpcCs�tjd|j�}|j�|jj�|jjd�d|jd<|jj	�tjd|j�}|j�|jj�|j
t|j�d�|j
|jfiffifg�dS)Ng{�G�z�?ZblahZbarZfoo�)
r	ZTimer�
_callback_spyr6r�rFrjr1r��clearr<r�r�)r
Ztimer1Ztimer2rrr� test_init_immutable_default_args5s





z+TimerTests.test_init_immutable_default_argscOs7|jj|dd�|j�f�|jj�dS)N)r�r1�copyr�rB)r
rjr�rrrrDs&zTimerTests._callback_spyN)rrrr*rrrrrrr�.sr�c@seZdZeej�ZdS)�	LockTestsN)rrr�staticmethodr	rR�locktyperrrrrHsrc@seZdZeej�ZdS)�PyRLockTestsN)rrrrr	Z_PyRLockrrrrrrKsrzRLock not implemented in Cc@seZdZeej�ZdS)�CRLockTestsN)rrrrr	�_CRLockrrrrrrNsrc@seZdZeej�ZdS)�
EventTestsN)rrrrr	rDZ	eventtyperrrrr
Rsr
c@seZdZeej�ZdS)�ConditionAsRLockTestsN)rrrrr	�	ConditionrrrrrrUsrc@seZdZeej�ZdS)�ConditionTestsN)rrrrr	rZcondtyperrrrr
Ysr
c@seZdZeej�ZdS)�SemaphoreTestsN)rrrrr	Z	Semaphore�semtyperrrrr\src@seZdZeej�ZdS)�BoundedSemaphoreTestsN)rrrrr	r.rrrrrr_src@seZdZeej�ZdS)�BarrierTestsN)rrrrr	ZBarrierZbarriertyperrrrrbsr�__main__)/�__doc__Ztest.supportr'rrrrZtest.support.script_helperrrr!�rer|rr	r#rKr�r�r�r
r�r�rrrZTestCaser&r,r�r�r�r�rZ
RLockTestsrr�r	rr
rr
rrrrr�rrrr�<module>sL"	
!	��E�Q�%