Current File : //proc/self/root/lib/python3/dist-packages/twisted/test/__pycache__/test_task.cpython-312.pyc
�

Ϫ�f����dZddlmZmZmZmZmZddlmZddl	m
Z
ddlmZejZ
ddlmZGd�dej �ZGd	�d
e�ZGd�dej(�ZGd
�dej(�ZGd�dej(�ZGd�dej(�ZGd�d�ZGd�dej4�ZGd�dej4�Zy)z%
Tests for L{twisted.internet.task}.
�)�defer�error�
interfaces�reactor�task)�installReactor)�	NoReactor)�unittest)�failurec���eZdZ�fd�Z�xZS)�TestableLoopingCallc�2��t�|�|i|��||_y�N)�super�__init__�clock)�selfr�a�kw�	__class__s    ��8/usr/lib/python3/dist-packages/twisted/test/test_task.pyrzTestableLoopingCall.__init__s���
���!�"�r�"���
�)�__name__�
__module__�__qualname__r�
__classcell__)rs@rr
r
s
����rr
c��eZdZy)�
TestExceptionN�rrr�rrrrs��rrc�j�eZdZdZd�Zd�Zd�Zd�Zd�Zd�Z	d�Z
d	�Zd
�Zd�Z
d�Zd
�Zd�Zd�Zd�Zy)�
ClockTestsz<
    Test the non-wallclock based clock implementation.
    c�l�tj�}|j|j�d�y)zV
        Test that the C{seconds} method of the fake clock returns fake time.
        rN)r�Clock�assertEqual�seconds�r�cs  r�testSecondszClockTests.testSeconds#s%��
�J�J�L���������a�(rc�2�tj�}|jdd�dd��}|jtj
j
|��|j|j�d�|j|j��y)z{
        Test that calls can be scheduled for later with the fake clock and
        hands back an L{IDelayedCall}.
        �c��yrr �r�bs  r�<lambda>z*ClockTests.testCallLater.<locals>.<lambda>0��r��r.N)
rr$�	callLater�
assertTruer�IDelayedCall�
providedByr%�getTime�active�rr(�calls   r�
testCallLaterzClockTests.testCallLater*sk��

�J�J�L���{�{�1�/��a�{�8�����
�/�/�:�:�4�@�A���������+�������
�&rc��tj�}|jdd�dd��}|j�|j	|j��y)z3
        Test that calls can be cancelled.
        r+c��yrr r-s  rr/z3ClockTests.testCallLaterCancelled.<locals>.<lambda>:r0rr1r2N)rr$r3�cancel�assertFalser8r9s   r�testCallLaterCancelledz!ClockTests.testCallLaterCancelled5sC��
�J�J�L���{�{�1�/��a�{�8�����
��������'rc��tj�}|jdd�dd��}|jdd�dd��}|j||u�y	)
z[
        Test that the DelayedCall returned is not one previously
        created.
        �
c��yrr r-s  rr/z3ClockTests.test_callLaterOrdering.<locals>.<lambda>Dr0rr+r1r2c��yrr r-s  rr/z3ClockTests.test_callLaterOrdering.<locals>.<lambda>Er0r��N)rr$r3r?)rr(�call1�call2s    r�test_callLaterOrderingz!ClockTests.test_callLaterOrdering>sO��

�J�J�L�����B� 1�1���:�����A�0�!�q��9������%��(rc�(��g�tj�}|jd�fd��}|jd�|j	�g�|jd�|j	�dg�|j|j
��y)zE
        Test that advancing the clock will fire some calls.
        r1c�&���jd�Sr��append)�eventss�rr/z(ClockTests.testAdvance.<locals>.<lambda>Ns���f�m�m�D�&9�rr+N)rr$r3�advancer%r?r8�rr(r:rNs   @r�testAdvancezClockTests.testAdvanceHsr������J�J�L���{�{�1�9�:��	�	�	�!�������$�	�	�	�!������$��(��������'rc����tj�}��fd�}|jd|��|jd�y)a
        Test attempting to cancel the call in a callback.

        AlreadyCalled should be raised, not for example a ValueError from
        removing the call from Clock.calls. This requires call.called to be
        set before the callback is called.
        c�Z���jtj�j�yr)�assertRaisesr�
AlreadyCalledr>)r:rs��r�cbz(ClockTests.testAdvanceCancel.<locals>.cb_s������e�1�1�4�;�;�?rr+N)rr$r3rO)rr(rVr:s`  @r�testAdvanceCancelzClockTests.testAdvanceCancelUs3���
�J�J�L��	@��{�{�1�b�!��	�	�	�!�rc�R��g�tj�}|jd�fd�dd��}|jd�|j	|j�d�|j
d�|j	�g�|j
d�|j	�dg�y)	z1
        Test that calls can be delayed.
        r+c�*���j||f�SrrL�rr.rNs  �rr/z1ClockTests.testCallLaterDelayed.<locals>.<lambda>k����6�=�=�!�Q��+@�rr1r2g�?��?�r+r1N)rr$r3�delayr%r7rOrPs   @r�testCallLaterDelayedzClockTests.testCallLaterDelayedes�������J�J�L���{�{�1�@�!�q�{�I���
�
�1�
���������+�	�	�	�#�������$�	�	�	�#������&��*rc�t��g�tj�}|jd�fd�dd��}|jd�|j	d�|j|j
�d�|jd�|j�g�|jd�|j�dg�y)	zL
        Test that calls can have their time reset to a later time.
        r1c�*���j||f�SrrLrZs  �rr/z4ClockTests.testCallLaterResetLater.<locals>.<lambda>yr[rr+r2rErFr]N)rr$r3rO�resetr%r7rPs   @r�testCallLaterResetLaterz"ClockTests.testCallLaterResetLaterss�������J�J�L���{�{�1�@�!�q�{�I��	�	�	�!���
�
�1�
���������+�	�	�	�!�������$�	�	�	�!������&��*rc���g�tj�}|jd�fd�dd��}|jd�|j	|j�d�|j
d�|j	�dg�y)	zO
        Test that calls can have their time reset to an earlier time.
        rFc�*���j||f�SrrLrZs  �rr/z5ClockTests.testCallLaterResetSooner.<locals>.<lambda>�r[rr+r1r2rEr]N)rr$r3rbr%r7rOrPs   @r�testCallLaterResetSoonerz#ClockTests.testCallLaterResetSooner�sj������J�J�L���{�{�1�@�!�q�{�I���
�
�1�
���������+�	�	�	�!������&��*rc���tj�}|jdd��}|jdd��}|j�}|j	||ht|��y)zB
        Test that we can get a list of all delayed calls
        r+c��yrr ��xs rr/z1ClockTests.test_getDelayedCalls.<locals>.<lambda>�r0rr1c��yrr ris rr/z1ClockTests.test_getDelayedCalls.<locals>.<lambda>�r0rN)rr$r3�getDelayedCallsr%�set)rr(r:rH�callss     r�test_getDelayedCallszClockTests.test_getDelayedCalls�sU��
�J�J�L���{�{�1�n�-�����A�~�.���!�!�#�����$����E�
�3rc�l�tj�}|j|j�g�y)zk
        Test that we get an empty list from getDelayedCalls on a newly
        constructed Clock.
        N)rr$r%rlr's  r�test_getDelayedCallsEmptyz$ClockTests.test_getDelayedCallsEmpty�s(��

�J�J�L������*�*�,�b�1rc��tj�}|jtjj|�d�y)Nz#Clock does not provide IReactorTime)rr$r4r�IReactorTimer6r's  r�test_providesIReactorTimez$ClockTests.test_providesIReactorTime�s0���J�J�L������#�#�.�.�q�1�3X�	
rc����g�ddg}tj����fd�}�jd|d�}|jd��jd|d��j	d	gd
z�|j�|�y)a4
        The order of calls scheduled by L{task.Clock.callLater} is honored when
        adding a new call via calling L{task.Clock.callLater} again.

        For example, if L{task.Clock.callLater} is invoked with a callable "A"
        and a time t0, and then the L{IDelayedCall} which results from that is
        C{reset} to a later time t2 which is greater than t0, and I{then}
        L{task.Clock.callLater} is invoked again with a callable "B", and time
        t1 which is less than t2 but greater than t0, "B" will be invoked before
        "A".
        �r.�@�r�@c�F���j|�j�f�Sr�rMr&��nr�results ��rr/z<ClockTests.test_callLaterKeepsCallsOrdered.<locals>.<lambda>�����F�M�M�1�e�m�m�o�*>�?�rr\rryrwr.r+rEN�rr$r3rb�pumpr%�r�expected�logtime�call_arr~s    @@r�test_callLaterKeepsCallsOrderedz*ClockTests.test_callLaterKeepsCallsOrdered�st������
�+���
�
���?������g�s�3�����S��
����W�c�*�
�
�
�A�3��7�������*rc����g�ddg}tj����fd�}�jd|d�}�jd|d�|jd��j	d	gd
z�|j�|�y)a:
        The order of calls scheduled by L{task.Clock.callLater} is honored when
        re-scheduling an existing call via L{IDelayedCall.reset} on the result
        of a previous call to C{callLater}.

        For example, if L{task.Clock.callLater} is invoked with a callable "A"
        and a time t0, and then L{task.Clock.callLater} is invoked again with a
        callable "B", and time t1 greater than t0, and finally the
        L{IDelayedCall} for "A" is C{reset} to a later time, t2, which is
        greater than t1, "B" will be invoked before "A".
        rvrxc�F���j|�j�f�Srr{r|s ��rr/zAClockTests.test_callLaterResetKeepsCallsOrdered.<locals>.<lambda>�rrr\rrwr.ryr+rENr�r�s    @@r�$test_callLaterResetKeepsCallsOrderedz/ClockTests.test_callLaterResetKeepsCallsOrdered�st������
�+���
�
���?������g�s�3��
����W�c�*����S��
�
�
�A�3��7�������*rc�����g�ddg}tj����fd�}�jd|d���fd�}�jd|��jd|d	��jd
gdz�|j	�|�y)
a9
        The order of calls scheduled by L{task.Clock.callLater} is honored when
        re-scheduling an existing call via L{IDelayedCall.reset} on the result
        of a previous call to C{callLater}, even when that call to C{reset}
        occurs within the callable scheduled by C{callLater} itself.
        )r(ry)r.g@c�F���j|�j�f�Srr{r|s ��rr/zKClockTests.test_callLaterResetInsideCallKeepsCallsOrdered.<locals>.<lambda>�rrrwr.c�(���jd�y)Nry)rb)�call_bs�rrzDClockTests.test_callLaterResetInsideCallKeepsCallsOrdered.<locals>.a�s����L�L��rr\ryr(��?rBN)rr$r3r�r%)rr�r�rr�rr~s    @@@r�.test_callLaterResetInsideCallKeepsCallsOrderedz9ClockTests.test_callLaterResetInsideCallKeepsCallsOrdered�s}������
�+���
�
���?������g�s�3��	�	����Q��
����W�c�*�
�
�
�C�5�2�:�������*rN)rrr�__doc__r)r;r@rIrQrWr_rcrfrorqrtr�r�r�r rrr"r"sR���)�	'�(�)�(�� +�
+�
+�
4�2�
�+�0+�0+rr"c��eZdZdZd�Zd�Zd�Zd�Zd�Zd�Z	d�Z
d	�Zd
�Zd�Z
d�Zd
�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zy)�	LoopTestsz[
    Tests for L{task.LoopingCall} based on a fake L{IReactorTime}
    implementation.
    c�p�tjd��}|j|jt�y)zG
        L{LoopingCall}'s default clock should be the reactor.
        c��yrr r rrr/z-LoopTests.test_defaultClock.<locals>.<lambda>�r0rN)r�LoopingCallr%rr)rr:s  r�test_defaultClockzLoopTests.test_defaultClock�s(������-��������W�-rc�����g�d�tj�����fd�}tj|�}�|_d�|j	d�|j�dg�|j�j
����jd�|j�dg�d��jd�|j�ddg�|j�j
�d��jd�|j�ddg�d��jd�|j�gd	��|j�j
�d
�y)z�
        When more time than the defined interval passes during the execution
        of a callback, L{LoopingCall} should schedule the next call for the
        next interval which is still in the future.
        Nc�f���j�j���j��yr)rMr&rO)�callDurationr�timess���r�	aCallbackz3LoopTests.test_callbackTimeSkips.<locals>.aCallbacks!����L�L�����)��M�M�,�'rr1r�rr+�@g@)rr�rFrF)rr$r�r�startr%r&rO)rr�r:r�rr�s   @@@r�test_callbackTimeSkipsz LoopTests.test_callbackTimeSkips�s.��������
�
���	(����	�*����
����
�
�3��	
������$�	
�������,�7�
	�
�
�a��������$���
�
�
�c�������C��)��������#�.�	�
�
�a�������C��)���
�
�
�c�������,��������!�,rc����g�tj����fd�}tj|�}�|_|j	d�|j�dg��j
d�|j�ddg��j
d�|j�gd���j
d�|j�gd��y)a	
        When more time than the defined interval passes between when
        L{LoopingCall} schedules itself to run again and when it actually
        runs again, it should schedule the next call for the next interval
        which is still in the future.
        c�D���j�j��yrr{)rr�s��rr�z2LoopTests.test_reactorTimeSkips.<locals>.aCallback;s����L�L�����)rr�rr1r+)rr1rEN)rr$r�rr�r%rO)rr�r:rr�s   @@r�test_reactorTimeSkipszLoopTests.test_reactorTimeSkips1s�������
�
���	*�
���	�*����
��
�
�3��	
������$�	�
�
�a�������A��'�	�
�
�a������	�*�	�
�
�a������	�*rc����g�tj����fd�}tjj|�}�|_d}d}|j|�|j
�dg��j||z�|j
�d||zdfg��jd|z|z�|j
�d||zdfd|zd|zzdfg��jd	�|j
�d||zdfd|zd|zzdfg�y
)a�
        When L{LoopingCall} schedules itself to run again, if more than the
        specified interval has passed, it should schedule the next call for the
        next interval which is still in the future. If it was created
        using L{LoopingCall.withCount}, a positional argument will be
        inserted at the beginning of the argument list, indicating the number
        of calls that should have been made.
        c�H���j�j�|f�yrr{)�numCallsrr�s ��rr�z7LoopTests.test_reactorTimeCountSkips.<locals>.aCallback_s����L�L�%�-�-�/�8�4�5rr��{�G�z�?�rr+r+rErFr1rN)rr$r��	withCountrr�r%rO�rr�r:�INTERVAL�REALISTIC_DELAYrr�s     @@r�test_reactorTimeCountSkipsz$LoopTests.test_reactorTimeCountSkipsSs2������
�
���	6�
���)�)�)�4����
������
�
�8��	
������)�
	�
�
�h��0�1������(�_�*D�a�)H� I�J�	�
�
�q�8�|��6�7�������O�+�Q�/��h�,�1��#6�7��;�
�	
�	�
�
�a��������O�+�Q�/��h�,�1��#6�7��;�
�	
rc�X���g�tj����fd�}tjj|�}�|_d}d}|j|�|j
�j�d��j||z�|j
�j�||zdf��j|dz�|j
�j�d|z|zdf��j|dz�|j
�j�d	|z|zdf�y
)a1
        L{LoopingCall.withCount} counts only calls that were expected to be
        made.  So, if more than one, but less than two intervals pass between
        invocations, it won't increase the count above 1.  For example, a
        L{LoopingCall} with interval T expects to be invoked at T, 2T, 3T, etc.
        However, the reactor takes some time to get around to calling it, so in
        practice it will be called at T+something, 2T+something, 3T+something;
        and due to other things going on in the reactor, "something" is
        variable.  It won't increase the count unless "something" is greater
        than T.  So if the L{LoopingCall} is invoked at T, 2.75T, and 3T,
        the count has not increased, even though the distance between
        invocation 1 and invocation 2 is 1.75T.
        c�H���j�j�|f�yrr{)�countrr�s ��rr�z<LoopTests.test_countLengthyIntervalCounts.<locals>.aCallback�s����L�L�%�-�-�/�5�1�2rr�r�r�r+g�?g@g�?ryN)	rr$r�r�rr�r%�poprOr�s     @@r�test_countLengthyIntervalCountsz)LoopTests.test_countLengthyIntervalCounts�s������
�
���	3�
���)�)�)�4����
������
�
�8���������f�-�	�
�
�h��0�1��������x�/�'A�1�&E�F�	�
�
�h��o�&���������x��?�'J�A�&N�O�	�
�
�h��o�&���������h��/�'I�1�&M�Nrc�:�tj�}g}tjj|j�}||_d}d}||z}|j
|d��t|�D]}|j|��d�}|||g|z�z
}	|j|	�|j�}
|jt|	�dkD|	�d��|j|
|k\|
�d|���|j||�|�|jd	|�y
)a�
        L{task.LoopingCall.withCount} should never invoke its callable with a
        zero.  Specifically, if a L{task.LoopingCall} created with C{withCount}
        has its L{start <task.LoopingCall.start>} method invoked with a
        floating-point number which introduces decimal inaccuracy when
        multiplied or divided, such as "0.1", L{task.LoopingCall} will never
        invoke its callable with 0.  Also, the sum of all the values passed to
        its callable as the "count" will be an integer, the number of intervals
        that have elapsed.

        This is a regression test for a particularly tricky case to implement.
        rBr\F��nowc�"�d}|D]}||z
}�	|S)z�
            Make sure the result is more precise.
            On Python 3.11 or older this can be a float with ~ 0.00001
            in precision difference.
            See: https://github.com/python/cpython/issues/100425
            �r )�items�total�items   r�
sum_compatzALoopTests.test_withCountFloatingPointBoundary.<locals>.sum_compat�s&���E��
����
��
��Lrr�z should be greater than zeroz$ should be greater than or equal to rN)rr$r�r�rMrr��rangerOr&r4�absr%�assertNotIn)rr�accumulatorr:r��timespan�intervalrjr��epsilon�secondsValues           r�#test_withCountFloatingPointBoundaryz-LoopTests.test_withCountFloatingPointBoundary�s���
�
��������)�)�+�*<�*<�=����
�
�����e�#���
�
�8��
�'��u��	$�A��M�M�(�#�	$�
	��Z��
�U�(:�;�;��
�
�
�g���}�}���	
����G��s�*�w�i�7S�,T�U�	
����H�$��n�@��
�K�	
�
	
����K�0�%�8�����K�(rc�*���tj�}g���fd�}tjj|��|�_�jdd��}|j
dgdz�|j|�|jdgdz��y)zy
        L{task.LoopingCall.withCount} with interval set to 0 calls the
        countCallable with a count of 1.
        c�f���j|�t��dkDr�j�yy)NrF�rM�len�stop)�cntr��loops ��r�fooz1LoopTests.test_withCountIntervalZero.<locals>.foos,������s�#��;��!�#��	�	��$rrFr��r+N)	rr$r�r�rr�r��successResultOfr%)rrr��deferredr�r�s    @@r�test_withCountIntervalZeroz$LoopTests.test_withCountIntervalZero�s����
�
�
�����	�
���)�)�#�.����
��:�:�a�U�:�+��	�
�
�A�3��7�����X�&����!��q��+�.rc�����tj�}tj��g����fd�}tjj|��|�_�jdd��|jdgdz�|jdgdz��|jdgdz�|jdgdz���jd�|jdgdz�|jdgd	z��y)
z�
        L{task.LoopingCall.withCount} with interval set to 0 and a delayed
        call during the loop run will still call the countCallable 1 as if
        no delay occurred.
        c����j|�t��dk(r�St��dkDr�j�yy)Nr1rFr�)r�r�r�r�s ���rr�z6LoopTests.test_withCountIntervalZeroDelay.<locals>.foos>������s�#��;��1�$����;��!�#��	�	��$rrFr�r1r+NrFr�)rr$r�Deferredr�r�rr�r�r%�callback)rrr�r�r�r�s   @@@r�test_withCountIntervalZeroDelayz)LoopTests.test_withCountIntervalZeroDelays�����
�
����>�>�#����	����)�)�#�.����
��
�
�1�%�
� �
�
�
�A�3��7�����!��q��+�.�	�
�
�A�3��7�����!��q��+�.�	���$��
�
�
�A�3��7�����!��q��+�.rc��	�
��tj�}tj��
g�	d�d}d}d}||z}||z}|dz
}�	�
�fd�}tjj|�}||_|jdd��|jdg�|zz�|jdg�z�	�||_
�
jd	�|j|�|jdd|g�	�|jd|z�|jdd|dg�	�|jd|z�|jdd|ddg�	�y	)
z�
        L{task.LoopingCall.withCount} with interval set to 0 will still keep
        the time when last called so when the interval is reset.
        r1r��	r+c�H���j|�t���k(r�Syr�rMr�)r�r�r��stepsBeforeDelays ���rr�zILoopTests.test_withCountIntervalZeroDelayThenNonZeroInterval.<locals>.foobs)������s�#��;��#3�3���4rrFr�N)
rr$rr�r�r�rr�r�r%r�r�rO)rr�extraTimeAfterDelay�mutatedLoopInterval�durationOfDelay�skippedTime�expectedSkipCountr�r�r�r�r�s         @@@r�2test_withCountIntervalZeroDelayThenNonZeroIntervalz<LoopTests.test_withCountIntervalZeroDelayThenNonZeroInterval8sd���
�
�
����>�>�#������
 �� ����
*�O�;��(�+>�>��	�Q���	 �
���)�)�#�.����
��
�
�1�%�
� �	�
�
�A�3�*�-@�@�A�B����!��/�/��=�,��
����$��
�
�
�o�&����!�Q� 1�2�K�@�
�
�
�a�-�-�.����!�Q� 1�1�5�{�C�
�
�
�a�-�-�.����!�Q� 1�1�a�8�+�Frc�T���gd�}tj�}g�d�fd�	}t||ddd��}|jd�}g��fd�}|j	|�|j|�|j
t��d	d
t��fz��D]N\}}}	}
|j
|d�|j
|d�|j|	�|j
|
d��P|j�|j�d|�|j|j�y)
N�g�������?皙�����?r�c�0���j||||f�yrrL)rr.r(�d�Ls    �rr�z(LoopTests.testBasicFunction.<locals>.foo�s���
�H�H�a��A�q�\�"rrr.r��r�r�c�(���j|�yrrL�r~�	theResults �r�
saveResultz/LoopTests.testBasicFunction.<locals>.saveResult��������V�$rrEzgot %d iterations, not 3r)NN)
rr$r
r��addCallbackr�r%r��assertIsNoner��assertIsr?rn)
r�timingsrr��lc�Dr�rr.r(r�r�r�s
           @@r�testBasicFunctionzLoopTests.testBasicFunction�s���
#���
�
�����	#�!���S�#��
=���H�H�S�M���	�	%�	
�
�
�j�!�
�
�
�7������Q���$>�#�a�&��$J�K��	%�J�A�q�!�Q����Q��$����Q��$����a� ����Q��$�		%�	���	��
�
�i��l�B�'�	
������%rc���gd�}tj�}g}t||jd�}|j	dd��}g��fd�}|j|�|j
|�|jt|�ddt|�fz�|j�|j�d|�|j|j�y)	Nr�r�Fr�c�(���j|�yrrLr�s �rr�z.LoopTests.testDelayedStart.<locals>.saveResult�r�rr1zgot %d iterations, not 2r)
rr$r
rMr�r�r�r%r�r�r�r?rn)rr�rr�r�r�r�r�s       @r�testDelayedStartzLoopTests.testDelayedStart�s����"���
�
�����
 �����$�
7���H�H�S�e�H�$���	�	%�	
�
�
�j�!�
�
�
�7������Q���$>�#�a�&��$J�K�
���	��
�
�i��l�B�'�������%rc�r�tjd��}|jt|jd�y)Nc��yrr r rrr/z(LoopTests.testBadDelay.<locals>.<lambda>�r0r���)rr�rT�
ValueErrorr�)rr�s  r�testBadDelayzLoopTests.testBadDelay�s(��
�
�
�l�
+�����*�b�h�h��3rc����g��fd�}tj�}t||�}|j|d��|j	�|j��|j|j�y)Nc�(���jd�yrrL��rans�rr�z$LoopTests._stoppingTest.<locals>.foo������J�J�t�rFr�)rr$r
r�r�r?rn)rr^r�rr�r�s     @r�
_stoppingTestzLoopTests._stoppingTest�s_�����	��
�
���
 ���
,��
����E��"�
���	������������%rc�$�|jd�S)Nr�r��rs r�testStopAtOncezLoopTests.testStopAtOnce�s���!�!�!�$�$rc�$�|jd�S)NrBrrs r�testStoppingBeforeDelayedStartz(LoopTests.testStoppingBeforeDelayedStart�s���!�!�"�%�%rc�J��g��fd�}tj�}t||�}|jdd��|j	d�|j�|j	d�|j
�g�|j	d�|j
�dg�y)z8
        Test that L{LoopingCall} can be reset.
        c�(���jd�yrrLr�s�rr�z!LoopTests.test_reset.<locals>.foo�r�rr1Fr�r+N)rr$r
r�rOrbr%)rr�r(r�r�s    @r�
test_resetzLoopTests.test_reset�s������	�
�J�J�L��
 ��C�
(��
�������	�	�	�!��
���
�	�	�	�!������b�!�	�	�	�!������t�f�%rc	�n�|jttjtdd���d�y)zO
        L{LoopingCall.__repr__} includes the wrapped function's name.
        r+r1)�keyz6LoopingCall<None>(installReactor, *(1,), **{'key': 2})N)r%�reprrr�rrs r�test_reprFunctionzLoopTests.test_reprFunction�s,��	
�����!�!�.�!��;�<�D�	
rc�|�|jttjtj
��d�y)zR
        L{LoopingCall.__repr__} includes the wrapped method's full name.
        z:LoopingCall<None>(TestableLoopingCall.__init__, *(), **{})N)r%rrr�r
rrs r�test_reprMethodzLoopTests.test_reprMethod�s/��	
�����!�!�"5�">�">�?�@�H�	
rc�"�tjd��}|jd}|j|jg�}|jdt
|��|jt|dd�|j||dd�y)z8
        L{LoopingCall.deferred} is deprecated.
        c��yrr r rrr/z4LoopTests.test_deferredDeprecation.<locals>.<lambda>r0rz�twisted.internet.task.LoopingCall.deferred was deprecated in Twisted 16.0.0; please use the deferred returned by start() insteadr+r�category�messageN)rr�r��
flushWarnings�test_deferredDeprecationr%r��DeprecationWarning)rr�r�warningss    rrz"LoopTests.test_deferredDeprecation�s�������-���
�
�
B�	�
�%�%�t�'D�'D�&E�F������C��M�*����+�X�a�[��-D�E�����(�1�+�i�"8�9rN)rrrr�r�r�r�r�r�r�r�r�r�r�r�r�r�rrrrrrr rrr�r��sr���
.�2-�h +�D8
�t'O�R@)�D/�4$/�LGG�R&&�P&�04�
&�%�&�&�&
�
�:rr�c�<�eZdZd�Zd�Zd�Zd�Zd�Zd�Zd�Z	d�Z
y	)
�ReactorLoopTestsc�~�d�}tj|d�}|j|jd�t�S)Nc��t|��r�rris rr�z)ReactorLoopTests.testFailure.<locals>.foos
����"�"r�barr��rr��
assertFailurer�r�rr�r�s   r�testFailurezReactorLoopTests.testFailures6��	#��
�
�c�5�
)���!�!�"�(�(�3�-��?�?rc����fd�}tj|d��|j�jd�t�S)Nc�:���j�t|��r)r�r)rjr�s �rr�z-ReactorLoopTests.testFailAndStop.<locals>.foos����G�G�I���"�"rrr�rrs  @r�testFailAndStopz ReactorLoopTests.testFailAndStops7���	#��
�
�c�5�
)���!�!�"�(�(�3�-��?�?rc�����g���fd�}tj|���jd�}��fd�}|j|�S)Nc�f���jd�t��dkDr�j�yy)Nr�r�)r�r�s��rr�z0ReactorLoopTests.testEveryIteration.<locals>.foo&s(����J�J�t���3�x�!�|����	�rrc�<���jt��d�y)N�)r%r�)�ignr�rs ��r�stoppedz4ReactorLoopTests.testEveryIteration.<locals>.stopped.s������S��X�q�)r)rr�r�r�)rr�r�r)r�r�s`   @@r�testEveryIterationz#ReactorLoopTests.testEveryIteration#sB�����	�
�
�
�c�
"���H�H�Q�K��	*��}�}�W�%�%rc����tj���fd�}tj|�|_|jjdd��t
jd|j���S)Nc�N���jtjd��y)Nz'This task also should never get called.)�errbackr�DefaultExceptionr�s�rr�z1ReactorLoopTests.testStopAtOnceLater.<locals>.foo8s���
�I�I��(�(�)R�S�
rr+Fr�r)	rr�rr��_lcr�rr3�!_callback_for_testStopAtOnceLater)rr�r�s  @r�testStopAtOnceLaterz$ReactorLoopTests.testStopAtOnceLater3s[���
�N�N���	�
�#�#�C�(��������q�e��$����!�T�C�C�Q�G��rc�z�|jj�tjd|jd�y)Nr�success)r/r�rr3r�)rr�s  rr0z2ReactorLoopTests._callback_for_testStopAtOnceLaterBs%�����
�
�����!�Q�Z�Z��3rc�����ddg}tj����fd�}t�|���jd��j	|�|j�j�y)N皙�����?g�������?c���tj�}|j�fd���jd|jd�|S)Nc�$���j�Sr)r�)�_r�s �rr/z@ReactorLoopTests.testWaitDeferred.<locals>.foo.<locals>.<lambda>Ns
���B�G�G�I�rr+)rr�r�r3r�)r�rr�s ��rr�z.ReactorLoopTests.testWaitDeferred.<locals>.fooLs5������ �A�
�M�M�-�.��O�O�A�q�z�z�4�0��Hr)rr$r
r�r�r?rn)rr�r�rr�s   @@r�testWaitDeferredz!ReactorLoopTests.testWaitDeferredFsU�����*���
�
���	�!���
,��
����
�
�
�
�7��������%rc���dg}tj���fd�}t�|�}|jd�}|j	|t
��j
|�|j�j�|S)N�333333�?c�z��tj�}�jd|jt	��|S)Nr;)rr�r3r-r)r�rs �rr�z4ReactorLoopTests.testFailurePropagation.<locals>.fooas*������ �A��O�O�C����M�O�<��Hrr+)	rr$r
r�rrr�r?rn)rr�r�r�r�rs     @r�testFailurePropagationz'ReactorLoopTests.testFailurePropagationWsj����%���
�
���	�
!���
,���H�H�Q�K�����1�m�,�
�
�
�7��������%��rc����tj�}tj��g���fd�}tjj|�}||_|jdd���|j�g�|jddg�|jt��d��jd�|jdg�|jt��d�|j�dd	g�y)
a?
        In the case that the function passed to L{LoopingCall.withCount}
        returns a deferred, which does not fire before the next interval
        elapses, the function should not be run again. And if a function call
        is skipped in this fashion, the appropriate count should be
        provided.
        c�H���j|�t��dk(r�Sy�Nr+r�)�
possibleCountr��deferredCountss ��r�countTrackerz=ReactorLoopTests.test_deferredWithCount.<locals>.countTrackerzs&����!�!�-�0��>�"�a�'���rr5Fr�g�������?r+Nr1rE)rr$rr�r�r�rr�r%r�r�r�)r�	testClockrCr�r�rBs    @@r�test_deferredWithCountz'ReactorLoopTests.test_deferredWithCountns�����J�J�L�	��N�N�����	��
�
�
'�
'��
5������H�H�S�e�H�$��	
�����,�	����S�z�"�����^�,�a�0�	
�
�
�4������u������^�,�a�0�	
����!�Q��0rN)rrrr r#r*r1r0r9r=rEr rrrrs,��@�@�&� 
�4�&�"�.*1rrc�(�eZdZdZd�Zd�Zd�Zd�Zy)�DeferLaterTestsz'
    Tests for L{task.deferLater}.
    c�P���g�t����fd�}tj�}tj|d|dd��}|j	|j
��|j
d�|j�g�|j
d�|j�dg�|S)	z�
        The L{Deferred} returned by L{task.deferLater} is called back after
        the specified delay with the result of the function passed in.
        c�.���j||f��SrrL)r�r�flag�resultss  ��r�callablez/DeferLaterTests.test_callback.<locals>.callable�s����N�N�C��:�&��KrrEr�r)rr1r+)r�r)�objectrr$�
deferLaterr�r�rOr%)rrLrr�rJrKs    @@r�
test_callbackzDeferLaterTests.test_callback�s����
���x��	��
�
����O�O�E�1�h��5�A��	�
�
�d�m�m�T�*�
�
�
�a������"�%�
�
�
�a������>�"2�3��rc��d�}tj�}tj|d|�}|jd�|j	|t
�S)z�
        The L{Deferred} returned by L{task.deferLater} is errbacked if the
        supplied function raises an exception.
        c��t��rrr rrrLz.DeferLaterTests.test_errback.<locals>.callable�s
���/�!rr+)rr$rNrOrr)rrLrr�s    r�test_errbackzDeferLaterTests.test_errback�sE��	"��
�
����O�O�E�1�h�/��
�
�
�a���!�!�!�]�3�3rc�����g�tj��tj�d�jd�}|j	����fd�}�j|tj�|j|�|S)z�
        The L{Deferred} returned by L{task.deferLater} can be
        cancelled to prevent the call from actually being performed.
        r+Nc�h���jg�j���j��yr)r%rlr?)�ignored�calledrrs ���r�cbCancelledz0DeferLaterTests.test_cancel.<locals>.cbCancelled�s*������R��!6�!6�!8�9����V�$r)	rr$rNrMr>rr�CancelledErrorr�)rr�rWrVrs`  @@r�test_cancelzDeferLaterTests.test_cancel�sd���
���
�
����O�O�E�1�f�m�m�T�:��	���
�	%�	
���1�e�2�2�3�	�
�
�k�"��rc���tj�}tj|d�}|j|�|j	d�|jd|j
|��y)z�
        The L{Deferred} returned by L{task.deferLater} fires with C{None}
        when no callback function is passed.
        rwN)rr$rN�assertNoResultrOr�r�)rrr�s   r�test_noCallbackzDeferLaterTests.test_noCallback�sR��
�
�
����O�O�E�3�'�����A��
�
�
�c���
�
�d�D�0�0��3�4rN)rrrr�rOrRrYr\r rrrGrG�s����*4��(
5rrGc�*�eZdZd�Zd�Zd�Zd�Zd�Zy)�_FakeReactorc��d|_tj�|_|jj|_|jj
|_|jj|_g|_ggd�|_y)NF��before�during)	�_runningrr$�_clockr3r&rl�_whenRunning�_shutdownTriggersrs rrz_FakeReactor.__init__�s_����
��j�j�l������.�.����{�{�*�*���#�{�{�:�:������,.�"�!=��rc�j�|j�	||i|��y|jj|||f�yr)rerM)rrL�args�kwargss    r�callWhenRunningz_FakeReactor.callWhenRunning�s6�����$��d�%�f�%����$�$�h��f�%=�>rc�^�|dvsJ�|dk(sJ�|j|j||f�y)Nr`�shutdown)rfrM)r�phase�eventrLrhs     r�addSystemEventTriggerz"_FakeReactor.addSystemEventTrigger�s=���,�,�,�,��
�"�"�"����u�%�,�,�h��-=�>rc��d|_|j}d|_|D]\}}}||i|���|jrg|j�}|std��|jj|dj
�|j�z
�|jr�g|j}d|_|d|dzD]
\}}||��y)z�
        Call timed events until there are no more or the reactor is stopped.

        @raise RuntimeError: When no timed events are left and the reactor is
            still running.
        TNzNo DelayedCalls leftrrarb)	rcrerl�RuntimeErrorrdrOr7r&rf)r�whenRunningrLrhrirn�shutdownTriggers�triggers        r�runz_FakeReactor.run�s�����
��'�'�� ���&1�	&�"�H�d�F��d�%�f�%�	&��m�m��(�(�*�E��"�#9�:�:��K�K����a�� 0� 0� 2�T�\�\�^� C�D�	�m�m�
 �1�1��!%���-�h�7�:J�8�:T�T�	�M�G�T��T�N�	rc�R�|jstj��d|_y)z#
        Stop the reactor.
        FN)rcr�ReactorNotRunningrs rr�z_FakeReactor.stops!���}�}��)�)�+�+���
rN)rrrrrjrorur�r rrr^r^�s��>�?�?�
�,rr^c�R�eZdZdZd�Zd�Zd�Zd�Zd�Zd�Z	d�Z
d	�Zd
�Zd�Z
d�Zy
)�
ReactTestsz3
    Tests for L{twisted.internet.task.react}.
    c���g��fd�}t�}|jttj||��}|jd|j�|j�dg�|j|j�d�y)��
        L{task.react} runs the reactor until the L{Deferred} returned by the
        function it is passed is called back, then stops it.
        c���tj�}|jd�jd�|jd|jd�|S�Nr+Tr1�rr�r3rMr��r�finished�
timePasseds  �r�mainz4ReactTests.test_runsUntilAsyncCallback.<locals>.main$sH����~�~�'�H��G���a��!2�!2�D�9��G���a��!2�!2�D�9��Or��_reactorrTr1N�r^rT�
SystemExitr�reactr%�coder&�rr��r�	exitErrorr�s    @r�test_runsUntilAsyncCallbackz&ReactTests.test_runsUntilAsyncCallbacksq���
�
�	�
�N���%�%�j�$�*�*�d�Q�%�O�	�����I�N�N�+�����d�V�,��������a�(rc���d�}t�}|jttj||��}|jd|j�|j|j�d�y)��
        L{task.react} returns quickly if the L{Deferred} returned by the
        function it is passed has already been called back at the time it is
        returned.
        c�,�tjd�Sr�r�succeed�rs rr�z3ReactTests.test_runsUntilSyncCallback.<locals>.main7s���=�=��&�&rr�rNr��rr�r�r�s    r�test_runsUntilSyncCallbackz%ReactTests.test_runsUntilSyncCallback0sW��	'�
�N���%�%�j�$�*�*�d�Q�%�O�	�����I�N�N�+��������a�(rc� ��Gd�dt���fd�}t�}|jttj
||��}|j
d|j�|j��}|j
t|�d�y)��
        L{task.react} runs the reactor until the L{defer.Deferred} returned by
        the function it is passed is errbacked, then it stops the reactor and
        reports the error.
        c��eZdZy)�@ReactTests.test_runsUntilAsyncErrback.<locals>.ExpectedExceptionNrr rr�ExpectedExceptionr�F���rr�c�v��tj�}|jd|j���|Sr@�rr�r3r-�rr�r�s  �rr�z3ReactTests.test_runsUntilAsyncErrback.<locals>.mainIs2����~�~�'�H��G���a��!1�!1�3D�3F�G��Orr�r+N�
�	Exceptionr^rTr�rr�r%r��flushLoggedErrorsr��rr�r�r��errorsr�s     @r�test_runsUntilAsyncErrbackz%ReactTests.test_runsUntilAsyncErrback?ss���	�	�	�	�

�N���%�%�j�$�*�*�d�Q�%�O�	�����I�N�N�+��'�'�(9�:������V��a�(rc�`��Gd�dt���fd�}t�}|jttj
||��}|j
d|j�|j
|j�d�|j��}|j
t|�d�y)��
        L{task.react} returns quickly if the L{defer.Deferred} returned by the
        function it is passed has already been errbacked at the time it is
        returned.
        c��eZdZy)�?ReactTests.test_runsUntilSyncErrback.<locals>.ExpectedExceptionNrr rrr�r�]r�rr�c�8��tj���Sr�r�fail�rr�s �rr�z2ReactTests.test_runsUntilSyncErrback.<locals>.main`s����:�:�/�1�2�2rr�r+rN�r�r^rTr�rr�r%r�r&r�r�r�s     @r�test_runsUntilSyncErrbackz$ReactTests.test_runsUntilSyncErrbackVs����	�	�	�	3�
�N���%�%�j�$�*�*�d�Q�%�O�	�����I�N�N�+��������a�(��'�'�(9�:������V��a�(rc���d�}t�}|jttj||��}|j|j
�d�|jd|j�y)��
        L{task.react} doesn't try to stop the reactor if the L{defer.Deferred}
        the function it is passed is called back after the reactor has already
        been stopped.
        c��|jd|j�tj�}|jdd|j
d�|S�Nr+rbrl�r3r�rr�ror��rr�s  rr�z0ReactTests.test_singleStopCallback.<locals>.mainqsF���G���a����.��~�~�'�H�)�G�)�)�(�J��@Q�@Q�SW�X��Orr�r+rN�r^rTr�rr�r%r&r�r�s    r�test_singleStopCallbackz"ReactTests.test_singleStopCallbackjsW��	�
�N���%�%�j�$�*�*�d�Q�%�O�	��������a�(�����I�N�N�+rc�`��Gd�dt���fd�}t�}|jttj
||��}|j
d|j�|j
|j�d�|j��}|j
t|�d�y)��
        L{task.react} doesn't try to stop the reactor if the L{defer.Deferred}
        the function it is passed is errbacked after the reactor has already
        been stopped.
        c��eZdZy)�<ReactTests.test_singleStopErrback.<locals>.ExpectedExceptionNrr rrr�r��r�rr�c���|jd|j�tj�}|jdd|j
���|Sr��r3r�rr�ror-r�s  �rr�z/ReactTests.test_singleStopErrback.<locals>.main�sO����G���a����.��~�~�'�H�)�G�)�)��*�h�&6�&6�8I�8K�
��Orr�r+Nr�r�s     @r�test_singleStopErrbackz!ReactTests.test_singleStopErrback}s����	�	�	�	�
�N���%�%�j�$�*�*�d�Q�%�O�	�����I�N�N�+��������a�(��'�'�(9�:������V��a�(rc����g��fd�}t�}|jttj|gd�|��}|jd|j�|j�gd��y)��
        L{task.react} passes the elements of the list it is passed as
        positional arguments to the function it is passed.
        c�V���j|||f�tjd�Sr��extendrr��rrj�y�zrhs    �rr�z'ReactTests.test_arguments.<locals>.main�s$����K�K��A�q�	�"��=�=��&�&r�r+r1rEr�rN�r^rTr�rr�r%r��rr�r�r�rhs    @r�test_argumentszReactTests.test_arguments�sb���
��	'�
�N���%�%���
�
�D�)�a�&�
�	�	
����I�N�N�+�����y�)rc�4���fd�}t�}t�5t|��jtt
j|g�}�jd|j�ddd��j|�j�y#1swY�&xYw)�p
        L{twisted.internet.reactor} is used if no reactor argument is passed to
        L{task.react}.
        c�<��|�_tjd�Sr��
passedReactorrr��rrs �rr�z,ReactTests.test_defaultReactor.<locals>.main�s���!(�D���=�=��&�&rrN�r^r	rrTr�rr�r%r�r�r��rr�rr�s`   r�test_defaultReactorzReactTests.test_defaultReactor�sw���	'��.��
�[�	0��7�#��)�)�*�d�j�j�$��K�I����Q�	���/�	0�	
�
�
�g�t�1�1�2�		0�	0���AB�Bc��d�}t�}|jttj|g|��}|jd|j�y)��
        L{task.react} forwards the exit code specified by the C{SystemExit}
        error returned by the passed function, if any.
        c�>�tjtd��S�N��rr�r�r�s rr�z1ReactTests.test_exitWithDefinedCode.<locals>.main�s���:�:�j��n�-�-rr�r�Nr�r�s    r�test_exitWithDefinedCodez#ReactTests.test_exitWithDefinedCode�sD��	.�
�N���%�%�j�$�*�*�d�B�QR�%�S�	�����Y�^�^�,rc��d�}t�}|jttj|g|��}|jd|j�y)�w
        L{task.react} handles when the reactor is stopped just before the
        returned L{Deferred} fires.
        c�b���tj����fd�}�j|��S)Nc�J���j��jd�yr�r�r��r�rs��rr�z;ReactTests.test_synchronousStop.<locals>.main.<locals>.stop�����������
�
�4� r�rr�rj�rr�r�s` @rr�z-ReactTests.test_synchronousStop.<locals>.main�s+������ �A�
!�
$�G�#�#�D�)��Hrr�rNr�r�s    r�test_synchronousStopzReactTests.test_synchronousStop�sD��	�
�N���%�%�j�$�*�*�d�B�QR�%�S�	�����I�N�N�+rc��d�}t�}|jttj|g|��}|jd|j�y)�v
        L{task.react} handles when the reactor is stopped and the
        returned L{Deferred} doesn't fire.
        c�d�|jd|j�tj�Sr@�r3r�rr�r�s rr�z.ReactTests.test_asynchronousStop.<locals>.main�s%���G���a����.��>�>�#�#rr�rNr�r�s    r�test_asynchronousStopz ReactTests.test_asynchronousStop�sD��	$�
�N���%�%�j�$�*�*�d�B�QR�%�S�	�����I�N�N�+rN�rrrr�r�r�r�r�r�r�r�r�r�r�r�r rrryry�>���)�&
)�)�.)�(,�&)�6*�$3�"-�,�(,rryc�R�eZdZdZd�Zd�Zd�Zd�Zd�Zd�Z	d�Z
d	�Zd
�Zd�Z
d�Zy
)�ReactCoroutineFunctionTestszP
    Tests for L{twisted.internet.task.react} with an C{async def} argument
    c���g��fd�}t�}|jttj||��}|jd|j�|j�dg�|j|j�d�y)r{c����K�tj�}|jd�jd�|jd|jd�|�d{���S7��wr}r~rs  �rr�zEReactCoroutineFunctionTests.test_runsUntilAsyncCallback.<locals>.main�sQ������~�~�'�H��G���a��!2�!2�D�9��G���a��!2�!2�D�9�!�>�!�>�s�AA �A�A r�rTr1Nr�r�s    @rr�z7ReactCoroutineFunctionTests.test_runsUntilAsyncCallback�sq���
�
�	"�
�N���%�%�j�$�*�*�d�Q�%�O�	�����I�N�N�+�����d�V�,��������a�(rc���d�}t�}|jttj||��}|jd|j�|j|j�d�y)r�c��HK�tjd��d{���S7��wrr�r�s rr�zDReactCoroutineFunctionTests.test_runsUntilSyncCallback.<locals>.main
s�������t�,�,�,�,�s�"� �"r�rNr�r�s    rr�z6ReactCoroutineFunctionTests.test_runsUntilSyncCallbacksW��	-�
�N���%�%�j�$�*�*�d�Q�%�O�	�����I�N�N�+��������a�(rc� ��Gd�dt���fd�}t�}|jttj
||��}|j
d|j�|j��}|j
t|�d�y)r�c��eZdZy)�QReactCoroutineFunctionTests.test_runsUntilAsyncErrback.<locals>.ExpectedExceptionNrr rrr�r�r�rr�c���K�tj�}|jd|j���|�d{���S7��wr@r�r�s  �rr�zDReactCoroutineFunctionTests.test_runsUntilAsyncErrback.<locals>.mains;������~�~�'�H��G���a��!1�!1�3D�3F�G�!�>�!�>�s�=A�A�Ar�r+Nr�r�s     @rr�z6ReactCoroutineFunctionTests.test_runsUntilAsyncErrbackss���	�	�	�	"�

�N���%�%�j�$�*�*�d�Q�%�O�	�����I�N�N�+��'�'�(9�:������V��a�(rc�`��Gd�dt���fd�}t�}|jttj
||��}|j
d|j�|j
|j�d�|j��}|j
t|�d�y)r�c��eZdZy)�PReactCoroutineFunctionTests.test_runsUntilSyncErrback.<locals>.ExpectedExceptionNrr rrr�r�0r�rr�c��T�K�tj����d{���S7��wrr�r�s �rr�zCReactCoroutineFunctionTests.test_runsUntilSyncErrback.<locals>.main3s ��������$5�$7�8�8�8�8�s�(�&�(r�r+rNr�r�s     @rr�z5ReactCoroutineFunctionTests.test_runsUntilSyncErrback)s����	�	�	�	9�
�N���%�%�j�$�*�*�d�Q�%�O�	�����I�N�N�+��������a�(��'�'�(9�:������V��a�(rc���d�}t�}|jttj||��}|j|j
�d�|jd|j�y)r�c���K�|jd|j�tj�}|jdd|j
d�|�d{���S7��wr�r�r�s  rr�zAReactCoroutineFunctionTests.test_singleStopCallback.<locals>.mainDsO�����G���a����.��~�~�'�H�)�G�)�)�(�J��@Q�@Q�SW�X�!�>�!�>�s�AA�A�Ar�r+rNr�r�s    rr�z3ReactCoroutineFunctionTests.test_singleStopCallback=sW��	"�
�N���%�%�j�$�*�*�d�Q�%�O�	��������a�(�����I�N�N�+rc�`��Gd�dt���fd�}t�}|jttj
||��}|j
d|j�|j
|j�d�|j��}|j
t|�d�y)r�c��eZdZy)�MReactCoroutineFunctionTests.test_singleStopErrback.<locals>.ExpectedExceptionNrr rrr�r�Wr�rr�c����K�|jd|j�tj�}|jdd|j
���|�d{���S7��wr�r�r�s  �rr�z@ReactCoroutineFunctionTests.test_singleStopErrback.<locals>.mainZsX������G���a����.��~�~�'�H�)�G�)�)��*�h�&6�&6�8I�8K�
�"�>�!�>�s�AA%�A#�A%r�r+Nr�r�s     @rr�z2ReactCoroutineFunctionTests.test_singleStopErrbackPs����	�	�	�	"�
�N���%�%�j�$�*�*�d�Q�%�O�	�����I�N�N�+��������a�(��'�'�(9�:������V��a�(rc����g��fd�}t�}|jttj|gd�|��}|jd|j�|j�gd��y)r�c��r�K��j|||f�tjd��d{���S7��wrr�r�s    �rr�z8ReactCoroutineFunctionTests.test_arguments.<locals>.mainrs.������K�K��A�q�	�"����t�,�,�,�,�s�-7�5�7r�r�rNr�r�s    @rr�z*ReactCoroutineFunctionTests.test_argumentsksb���
��	-�
�N���%�%���
�
�D�)�a�&�
�	�	
����I�N�N�+�����y�)rc�4���fd�}t�}t�5t|��jtt
j|g�}�jd|j�ddd��j|�j�y#1swY�&xYw)r�c��X�K�|�_tjd��d{���S7��wrr�r�s �rr�z=ReactCoroutineFunctionTests.test_defaultReactor.<locals>.main�s$�����!(�D�����t�,�,�,�,�s� *�(�*rNr�r�s`   rr�z/ReactCoroutineFunctionTests.test_defaultReactor}sw���	-��.��
�[�	0��7�#��)�)�*�d�j�j�$��K�I����Q�	���/�	0�	
�
�
�g�t�1�1�2�		0�	0�r�c��d�}t�}|jttj|g|��}|jd|j�y)r�c��ZK�tjtd���d{���S7��wr�r�r�s rr�zBReactCoroutineFunctionTests.test_exitWithDefinedCode.<locals>.main�s�������J�r�N�3�3�3�3�s�"+�)�+r�r�Nr�r�s    rr�z4ReactCoroutineFunctionTests.test_exitWithDefinedCode�sD��	4�
�N���%�%�j�$�*�*�d�B�QR�%�S�	�����Y�^�^�,rc��d�}t�}|jttj|g|��}|jd|j�y)r�c��~��K�tj����fd�}�j|���d{���S7��w)Nc�J���j��jd�yrr�r�s��rr�zLReactCoroutineFunctionTests.test_synchronousStop.<locals>.main.<locals>.stop�r�rr�r�s` @rr�z>ReactCoroutineFunctionTests.test_synchronousStop.<locals>.main�s3�������� �A�
!�
$�G�#�#�D�)��7�N�7�s�2=�;�=r�rNr�r�s    rr�z0ReactCoroutineFunctionTests.test_synchronousStop�sD��	�
�N���%�%�j�$�*�*�d�B�QR�%�S�	�����I�N�N�+rc��d�}t�}|jttj|g|��}|jd|j�y)r�c��K�|jd|j�tj��d{���S7��wr@r�r�s rr�z?ReactCoroutineFunctionTests.test_asynchronousStop.<locals>.main�s/�����G���a����.����)�)�)�)�s�5>�<�>r�rNr�r�s    rr�z1ReactCoroutineFunctionTests.test_asynchronousStop�sD��	*�
�N���%�%�j�$�*�*�d�B�QR�%�S�	�����I�N�N�+rNr�r rrr�r��r�rr�N)r��twisted.internetrrrrr�twisted.internet.mainr�#twisted.internet.test.modulehelpersr	�
twisted.trialr
r$�twisted.pythonrr�r
r�r�TestCaser"r�rrGr^�SynchronousTestCaseryr�r rr�<module>rs����
E�D�0�9�"�	
�
�
��"��$�*�*��	�I�	�O+��"�"�O+�d^:��!�!�^:�BG1�x�(�(�G1�TF5�h�'�'�F5�R1�1�hP,��-�-�P,�fP,�(�">�">�P,r
¿Qué es la limpieza dental de perros? - Clínica veterinaria


Es la eliminación del sarro y la placa adherida a la superficie de los dientes mediante un equipo de ultrasonidos que garantiza la integridad de las piezas dentales a la vez que elimina en profundidad cualquier resto de suciedad.

A continuación se procede al pulido de los dientes mediante una fresa especial que elimina la placa bacteriana y devuelve a los dientes el aspecto sano que deben tener.

Una vez terminado todo el proceso, se mantiene al perro en observación hasta que se despierta de la anestesia, bajo la atenta supervisión de un veterinario.

¿Cada cuánto tiempo tengo que hacerle una limpieza dental a mi perro?

A partir de cierta edad, los perros pueden necesitar una limpieza dental anual o bianual. Depende de cada caso. En líneas generales, puede decirse que los perros de razas pequeñas suelen acumular más sarro y suelen necesitar una atención mayor en cuanto a higiene dental.


Riesgos de una mala higiene


Los riesgos más evidentes de una mala higiene dental en los perros son los siguientes:

  • Cuando la acumulación de sarro no se trata, se puede producir una inflamación y retracción de las encías que puede descalzar el diente y provocar caídas.
  • Mal aliento (halitosis).
  • Sarro perros
  • Puede ir a más
  • Las bacterias de la placa pueden trasladarse a través del torrente circulatorio a órganos vitales como el corazón ocasionando problemas de endocarditis en las válvulas. Las bacterias pueden incluso acantonarse en huesos (La osteomielitis es la infección ósea, tanto cortical como medular) provocando mucho dolor y una artritis séptica).

¿Cómo se forma el sarro?

El sarro es la calcificación de la placa dental. Los restos de alimentos, junto con las bacterias presentes en la boca, van a formar la placa bacteriana o placa dental. Si la placa no se retira, al mezclarse con la saliva y los minerales presentes en ella, reaccionará formando una costra. La placa se calcifica y se forma el sarro.

El sarro, cuando se forma, es de color blanquecino pero a medida que pasa el tiempo se va poniendo amarillo y luego marrón.

Síntomas de una pobre higiene dental
La señal más obvia de una mala salud dental canina es el mal aliento.

Sin embargo, a veces no es tan fácil de detectar
Y hay perros que no se dejan abrir la boca por su dueño. Por ejemplo…

Recientemente nos trajeron a la clínica a un perro que parpadeaba de un ojo y decía su dueño que le picaba un lado de la cara. Tenía molestias y dificultad para comer, lo que había llevado a sus dueños a comprarle comida blanda (que suele ser un poco más cara y llevar más contenido en grasa) durante medio año. Después de una exploración oftalmológica, nos dimos cuenta de que el ojo tenía una úlcera en la córnea probablemente de rascarse . Además, el canto lateral del ojo estaba inflamado. Tenía lo que en humanos llamamos flemón pero como era un perro de pelo largo, no se le notaba a simple vista. Al abrirle la boca nos llamó la atención el ver una muela llena de sarro. Le realizamos una radiografía y encontramos una fístula que llegaba hasta la parte inferior del ojo.

Le tuvimos que extraer la muela. Tras esto, el ojo se curó completamente con unos colirios y una lentilla protectora de úlcera. Afortunadamente, la úlcera no profundizó y no perforó el ojo. Ahora el perro come perfectamente a pesar de haber perdido una muela.

¿Cómo mantener la higiene dental de tu perro?
Hay varias maneras de prevenir problemas derivados de la salud dental de tu perro.

Limpiezas de dientes en casa
Es recomendable limpiar los dientes de tu perro semanal o diariamente si se puede. Existe una gran variedad de productos que se pueden utilizar:

Pastas de dientes.
Cepillos de dientes o dedales para el dedo índice, que hacen más fácil la limpieza.
Colutorios para echar en agua de bebida o directamente sobre el diente en líquido o en spray.

En la Clínica Tus Veterinarios enseñamos a nuestros clientes a tomar el hábito de limpiar los dientes de sus perros desde que son cachorros. Esto responde a nuestro compromiso con la prevención de enfermedades caninas.

Hoy en día tenemos muchos clientes que limpian los dientes todos los días a su mascota, y como resultado, se ahorran el dinero de hacer limpiezas dentales profesionales y consiguen una mejor salud de su perro.


Limpiezas dentales profesionales de perros y gatos

Recomendamos hacer una limpieza dental especializada anualmente. La realizamos con un aparato de ultrasonidos que utiliza agua para quitar el sarro. Después, procedemos a pulir los dientes con un cepillo de alta velocidad y una pasta especial. Hacemos esto para proteger el esmalte.

La frecuencia de limpiezas dentales necesaria varía mucho entre razas. En general, las razas grandes tienen buena calidad de esmalte, por lo que no necesitan hacerlo tan a menudo e incluso pueden pasarse la vida sin requerir una limpieza. Sin embargo, razas pequeñas como el Yorkshire o el Maltés, deben hacérselas todos los años desde cachorros si se quiere conservar sus piezas dentales.

Otro factor fundamental es la calidad del pienso. Algunas marcas han diseñado croquetas que limpian la superficie del diente y de la muela al masticarse.

Ultrasonido para perros

¿Se necesita anestesia para las limpiezas dentales de perros y gatos?

La limpieza dental en perros no es una técnica que pueda practicarse sin anestesia general , aunque hay veces que los propietarios no quieren anestesiar y si tiene poco sarro y el perro es muy bueno se puede intentar…… , pero no se va a poder pulir ni acceder a todas la zona de la boca …. Además los limpiadores dentales van a irrigar agua y hay riesgo de aspiración a vías respiratorias si no se realiza una anestesia correcta con intubación traqueal . En resumen , sin anestesia no se va hacer una correcta limpieza dental.

Tampoco sirve la sedación ya que necesitamos que el animal esté totalmente quieto, y el veterinario tenga un acceso completo a todas sus piezas dentales y encías.

Alimentos para la limpieza dental

Hay que tener cierto cuidado a la hora de comprar determinados alimentos porque no todos son saludables. Algunos tienen demasiado contenido graso, que en exceso puede causar problemas cardiovasculares y obesidad.

Los mejores alimentos para los dientes son aquellos que están elaborados por empresas farmacéuticas y llevan componentes químicos con tratamientos específicos para el diente del perro. Esto implica no solo limpieza a través de la acción mecánica de morder sino también un tratamiento antibacteriano para prevenir el sarro.

Conclusión

Si eres como la mayoría de dueños, por falta de tiempo , es probable que no estés prestando la suficiente atención a la limpieza dental de tu perro. Por eso te animamos a que comiences a limpiar los dientes de tu perro y consideres atender a su higiene bucal con frecuencia.

Estas simples medidas pueden conllevar a que tu perro tenga una vida más larga y mucho más saludable.

Si te resulta imposible introducir un cepillo de dientes a tu perro en la boca, pásate con él por clínica Tus Veterinarios y te explicamos cómo hacerlo.

Necesitas hacer una limpieza dental profesional a tu mascota?
Llámanos al 622575274 o contacta con nosotros

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

¡Hola!