← Back
Editing: test_defer.cpython-38.pyc
U ��W[� � @ s� d Z ddlmZmZ ddlZddlZddlZddlZddlm Z e r^ddl m Z m Z m Z dZndZddlmZmZ ddlmZmZ dd lmZ dd lmZ G d d � d e�Zd d� Zdd� Z G dd� de �Z G dd� dej �Z G dd� dej!e �Z"G dd� dej!�Z#G dd� dej!�Z$G dd � d ej!�Z%G d d � d ej!�Z&G d d � d ej!�Z'G d!d"� d"ej!e �Z(G d#d$� d$ej �Z)d%d&� Z*G d'd(� d(ej!�Z+G d)d*� d*ej �Z,G d+d,� d,ej e �Z-d-d.� Z.G d/d0� d0ej �Z/dS )1z+ Test cases for L{twisted.internet.defer}. � )�division�absolute_importN)�_PY3)�new_event_loop�Future�CancelledErrorz'asyncio not available before python 3.4)�failure�log)�defer�reactor)�Clock)�unittestc @ s e Zd ZdS )� GenericErrorN)�__name__� __module__� __qualname__� r r �9/usr/lib/python3/dist-packages/twisted/test/test_defer.pyr s r c O s* z dd W n t j| |�}Y nX |S )z� Make a L{failure.Failure} of a divide-by-zero error. @param args: Any C{*args} are passed to Failure's constructor. @param kwargs: Any C{**kwargs} are passed to Failure's constructor. � r )r �Failure)�args�kwargs�fr r r �getDivisionFailure$ s r c C s | � d� dS )z� A fake L{defer.Deferred} canceller which callbacks the L{defer.Deferred} with C{str} "Callback Result" when cancelling it. @param deferred: The cancelled L{defer.Deferred}. �Callback ResultN��callback��deferredr r r �fakeCallbackCanceller3 s r c @ s e Zd ZdZdd� ZdS )�ImmediateFailureMixinz+ Add additional assertion methods. c C s> g }|� |j� | �t|�d� | �|d �|�� |d jS )z� Assert that the given Deferred current result is a Failure with the given exception. @return: The exception instance in the Deferred. r r )� addErrback�append� assertEqual�len� assertTrue�check�value)�selfr � exception�failuresr r r �assertImmediateFailureC s z,ImmediateFailureMixin.assertImmediateFailureN)r r r �__doc__r+ r r r r r > s r c @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) � UtilTestsz& Tests for utility functions. c C s0 t �t� �}t�|�}| �t� | �||� dS )z< L{defer.logError} returns the given error. N)r r � RuntimeErrorr �logError�flushLoggedErrors�assertIs)r( �error�resultr r r �test_logErrorReturnsErrorW s z#UtilTests.test_logErrorReturnsErrorc C s2 t �t� �}t�|� | �t�}| �||g� dS )z9 L{defer.logError} logs the given error. N)r r r. r r/ r0 r# )r( r2 �errorsr r r �test_logErrorLogsErrorb s z UtilTests.test_logErrorLogsErrorc sR g � � fdd�}t �|� t�t� �}t�|� | �t� | �� d � d�� dS )zR The text logged by L{defer.logError} has no repr of the failure. c s � � t�| �� d S �N)r" r �textFromEventDict)Z eventDict��outputr r �emits s z4UtilTests.test_logErrorLogsErrorNoRepr.<locals>.emitr �Unhandled Error Traceback N) r � addObserverr r r. r r/ r0 r% � startswith)r( r; r2 r r9 r � test_logErrorLogsErrorNoReprm s z&UtilTests.test_logErrorLogsErrorNoReprN)r r r r, r4 r6 r? r r r r r- R s r- c @ s4 e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d� Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd � Zd d � Zd d � Zd!d"� Zd#d$� Zd%d&� Zd'd(� Zd)d*� Zd+d,� Zd-d.� Zd/d0� Zd1d2� Zd3d4� Z d5d6� Z d7d8� Z d9d:� Z d;d<� Z d=d>� Z!d?d@� Z"dAdB� Z#dCdD� Z$dEdF� Z%dGdH� Z&dIdJ� Z'dKdL� Z(dMdN� Z)dOdP� Z*dQdR� Z+dSdT� Z,dUdV� Z-dWdX� Z.dYdZ� Z/d[d\� Z0d]d^� Z1d_d`� Z2dadb� Z3dcdd� Z4dedf� Z5dgdh� Z6didj� Z7dkdl� Z8dmdn� Z9dodp� Z:dqdr� Z;dsdt� Z<dudv� Z=dwdx� Z>dydz� Z?d{d|� Z@d}d~� ZAdd�� ZBd�d�� ZCd�d�� ZDd�d�� ZEd�d�� ZFd�d�� ZGd�S )�� DeferredTestsc C s( d | _ d | _d | _| �tjt�� � d S r7 )�callbackResults�errbackResults�callback2Results� addCleanupr � setDebugging� getDebugging�r( r r r �setUp� s zDeferredTests.setUpc O s ||f| _ |d S �Nr �rA �r( r �kwr r r � _callback� s zDeferredTests._callbackc O s ||f| _ d S r7 �rC rK r r r � _callback2� s zDeferredTests._callback2c O s ||f| _ d S r7 �rB rK r r r �_errback� s zDeferredTests._errbackc C s@ t �� }|�| j� |�d� | �| j� | �| jdi f� d S �N�hello�rS � r �Deferred� addCallbackrM r � assertIsNonerB r# rA �r( r r r r �testCallbackWithoutArgs� s z%DeferredTests.testCallbackWithoutArgsc C sB t �� }|�| jd� |�d� | �| j� | �| jdi f� d S )N�worldrS )rS r[ rU rY r r r �testCallbackWithArgs� s z"DeferredTests.testCallbackWithArgsc C sH t �� }|j| jdd� |�d� | �| j� | �| jdddif� d S )Nr[ )r[ rS rT rU rY r r r �testCallbackWithKwArgs� s �z$DeferredTests.testCallbackWithKwArgsc C s^ t �� }|�| j� |�| j� |�d� | �| j� | �| j di f� | �| j di f� d S rR ) r rV rW rM rO r rX rB r# rA rC rY r r r �testTwoCallbacks� s ��z DeferredTests.testTwoCallbacksc C s� t �� }t �� }t �� }t �|||g�}g }|fdd�}dd� }|�||� |�d� |�|� |�td�� |�d� | �|d |d d t |d d j �f|d gt j dft j dft j dfg� d S ) Nc S s |� | � d S r7 )�extend�Z resultListr3 r r r �cb� s z*DeferredTests.testDeferredList.<locals>.cbc S s d S r7 r ��errr r r �catch� s z-DeferredTests.testDeferredList.<locals>.catch�1�2�3r r � ) r rV � DeferredList� addCallbacksr r! �errbackr r# �strr' �SUCCESS�FAILURE)r( �defr1�defr2�defr3�dlr3 ra rd r r r �testDeferredList� s* ���z DeferredTests.testDeferredListc C sf g }|fdd�}t �g �}|�|� | �|g g� g |d d �< t jg dd�}|�|� | �|g � d S )Nc S s |� | � d S r7 �r" r` r r r ra � s z/DeferredTests.testEmptyDeferredList.<locals>.cbr �ZfireOnOneCallback)r ri rj r# )r( r3 ra rr r r r �testEmptyDeferredList� s z#DeferredTests.testEmptyDeferredListc C s� t �� }t �� }t �� }t j|||gdd�}g }|�|j� dd� }|�|� |�d� | �|g � |�td�� | �t |�d� |d }| � t |j t j �d|j f � |j}| �|jj t� | �|jjjd � | �|jd� d S ) Nr �ZfireOnOneErrbackc S s d S r7 r rb r r r rd � s z;DeferredTests.testDeferredListFireOnOneError.<locals>.catchre � from def2r zHissubclass(aFailure.type, defer.FirstError) failed: failure's type is %r)rx )r rV ri r! r" r r# rk r r$ r% � issubclass�type� FirstErrorr' � subFailurer �index) r( ro rp rq rr r3 rd ZaFailure� firstErrorr r r � testDeferredListFireOnOneError� s, ��z,DeferredTests.testDeferredListFireOnOneErrorc C s� t �� }t �|g�}g }|�|j� g }|�|j� |�td�� | �d|d j j d � | �dt |�� | �d|d d d j j d � d S )N�Bangr r ) r rV ri r! r" rW rk r r# r' r r$ �r( �d1rr Z errorTrapr3 r r r �!testDeferredListDontConsumeErrors s z/DeferredTests.testDeferredListDontConsumeErrorsc C s� t �� }t j|gdd�}g }|�|j� g }|�|j� |�td�� | �g |� | �dt |�� | �d|d d d j j d � d S )NT�Z consumeErrorsr� r r ) r rV ri r! r" rW rk r r# r$ r' r r� r r r � testDeferredListConsumeErrors s z+DeferredTests.testDeferredListConsumeErrorsc C sb t �� }t �� }|�td�� t j||gdd�}g }|�|j� | �dt|�� |�dd� � d S )Nr� Trw r c S s d S r7 r ��er r r �<lambda>2 � zWDeferredTests.testDeferredListFireOnOneErrorWithAlreadyFiredDeferreds.<locals>.<lambda>) r rV rk r ri r! r" r# r$ �r( r� �d2rr r3 r r r �7testDeferredListFireOnOneErrorWithAlreadyFiredDeferreds& s zEDeferredTests.testDeferredListFireOnOneErrorWithAlreadyFiredDeferredsc C sh t �� }t �� }|�td�� |�d� t �||g�}g }|�|j� | �dt |�� |� dd� � d S )Nr� rh r c S s d S r7 r r� r r r r� C r� zIDeferredTests.testDeferredListWithAlreadyFiredDeferreds.<locals>.<lambda>) r rV rk r r ri rW r" r# r$ r! r� r r r �)testDeferredListWithAlreadyFiredDeferreds4 s z7DeferredTests.testDeferredListWithAlreadyFiredDeferredsc C sF t �� }t �� }t �||g�}|�� | �|t j� | �|t j� dS )zw When cancelling an unfired L{defer.DeferredList}, cancel every L{defer.Deferred} in the list. N�r rV ri �cancel�failureResultOfr �r( � deferredOne� deferredTwo� deferredListr r r �test_cancelDeferredListF s z%DeferredTests.test_cancelDeferredListc C s� t �t�}t �� }t �||g�}|�� | �|t j� | �|�}| �|d d � | � |d d d� | � |d d � | �|d d � t j�� dS )z� When cancelling an unfired L{defer.DeferredList} without the C{fireOnOneCallback} and C{fireOnOneErrback} flags set, the L{defer.DeferredList} will be callback with a C{list} of (success, result) C{tuple}s. r r r N) r rV r ri r� r� r �successResultOfr% r# � assertFalser& �r( r� r� r� r3 r r r � test_cancelDeferredListCallbackS s z-DeferredTests.test_cancelDeferredListCallbackc C sJ t �� }t �� }t j||gdd�}|�� | �|t j� | �|t j� dS )z� When cancelling an unfired L{defer.DeferredList} with the flag C{fireOnOneCallback} set, cancel every L{defer.Deferred} in the list. Tru Nr� r� r r r �,test_cancelDeferredListWithFireOnOneCallbackf s �z:DeferredTests.test_cancelDeferredListWithFireOnOneCallbackc C sT t �t�}t �� }t j||gdd�}|�� | �|t j� | �|�}| �|d� dS )a, When cancelling an unfired L{defer.DeferredList} with the flag C{fireOnOneCallback} set, if one of the L{defer.Deferred} callbacks in its canceller, the L{defer.DeferredList} will callback with the result and the index of the L{defer.Deferred} in a C{tuple}. Tru )r r N) r rV r ri r� r� r r� r# r� r r r �?test_cancelDeferredListWithFireOnOneCallbackAndDeferredCallbackt s � zMDeferredTests.test_cancelDeferredListWithFireOnOneCallbackAndDeferredCallbackc C sr t �� }t �� }t j||gdd�}|�� | �|t j� | �|t j� | �|t j�}|j}| �|j � t j�� dS )z� When cancelling an unfired L{defer.DeferredList} with the flag C{fireOnOneErrback} set, cancel every L{defer.Deferred} in the list. Trw N) r rV ri r� r� r r{ r' r% r| r& )r( r� r� r� ZdeferredListFailurer~ r r r �+test_cancelDeferredListWithFireOnOneErrback� s ��z9DeferredTests.test_cancelDeferredListWithFireOnOneErrbackc C s� t �t�}t �t�}t j||gdd�}|�� | �|�}| �|d d � | �|d d d� | �|d d � | �|d d d� dS )a When cancelling an unfired L{defer.DeferredList} with the flag C{fireOnOneErrback} set, if all the L{defer.Deferred} callbacks in its canceller, the L{defer.DeferredList} will callback with a C{list} of (success, result) C{tuple}s. Trw r r r N)r rV r ri r� r� r% r# r� r r r �?test_cancelDeferredListWithFireOnOneErrbackAllDeferredsCallback� s � zMDeferredTests.test_cancelDeferredListWithFireOnOneErrbackAllDeferredsCallbackc C sf t �� }t �� }||g}t �|�}t �� }|�|� |�� | �|t j� | �|t j� | �|� dS )zs Cancelling a L{defer.DeferredList} will cancel the original L{defer.Deferred}s passed in. N)r rV ri r" r� r� r �assertNoResult)r( r� r� Z argumentListr� Z deferredThreer r r �,test_cancelDeferredListWithOriginalDeferreds� s z:DeferredTests.test_cancelDeferredListWithOriginalDeferredsc C s\ dd� }t �|�}t �� }t �||g�}|�� | �|t j� | �t�}| �t |�d� dS )z� Cancelling a L{defer.DeferredList} will cancel every L{defer.Deferred} in the list even exceptions raised from the C{cancel} method of the L{defer.Deferred}s. c S s t d��dS )z� A L{defer.Deferred} canceller that raises an exception. @param deferred: The cancelled L{defer.Deferred}. �testN)r. r r r r �cancellerRaisesException� s zTDeferredTests.test_cancelDeferredListWithException.<locals>.cancellerRaisesExceptionr N) r rV ri r� r� r r0 r. r# r$ )r( r� r� r� r� r5 r r r �$test_cancelDeferredListWithException� s z2DeferredTests.test_cancelDeferredListWithExceptionc C sB t �� }t �� }t j||gdd�}|�d� |�� | �|� dS )z� When a L{defer.DeferredList} has fired because one L{defer.Deferred} in the list fired with a non-failure result, the cancellation will do nothing instead of cancelling the rest of the L{defer.Deferred}s. Tru N)r rV ri r r� r� r� r r r �)test_cancelFiredOnOneCallbackDeferredList� s � z7DeferredTests.test_cancelFiredOnOneCallbackDeferredListc C s` t �� }t �� }t j||gdd�}|�td�� |�� | �|� | �|t� | �|t j� dS )z� When a L{defer.DeferredList} has fired because one L{defer.Deferred} in the list fired with a failure result, the cancellation will do nothing instead of cancelling the rest of the L{defer.Deferred}s. Trw r� N) r rV ri rk r r� r� r� r{ r� r r r �(test_cancelFiredOnOneErrbackDeferredList� s � z6DeferredTests.test_cancelFiredOnOneErrbackDeferredListc C s, g }t �d�}|�|j� | �|dg� d S )N�success)r �succeedrW r" r# �r( �l�dr r r �testImmediateSuccess� s z"DeferredTests.testImmediateSuccessc C s8 g }t �td��}|�|j� | �t|d j�d� d S �N�failr )r r� r r! r" r# rl r' r� r r r �testImmediateFailure� s z"DeferredTests.testImmediateFailurec C sT g }t �td��}|�� |�|j� | �|g � |�� | �t|d j �d� d S r� ) r r� r �pauser! r" r# �unpauserl r' r� r r r �testPausedFailure� s z DeferredTests.testPausedFailurec C sx g }t �� �dd� ��|j�}|�d� | �|d jt� g }t �� �dd� ��|j�}|�d� | �|d jt� d S )Nc S s dd S �Nr r r ��_r r r r� r� z2DeferredTests.testCallbackErrors.<locals>.<lambda>r r c S s t �t� �S r7 )r r �ZeroDivisionErrorr� r r r r� r� ) r rV rW r! r" r �assertIsInstancer' r� r� r r r �testCallbackErrors s �� z DeferredTests.testCallbackErrorsc C s( t �� }|�� |�| j� |�� d S r7 )r rV r� rW rM r� �r( r� r r r �testUnpauseBeforeCallback s z'DeferredTests.testUnpauseBeforeCallbackc C s� t �� }t �� }|�� |�|fdd�� |�| j� |�d� | jd ksRtd��|�d� | jd ksntd��|�� | jd d dks�td| jf ��d S ) Nc S s |S r7 r )�rr� r r r r� r� z2DeferredTests.testReturnDeferred.<locals>.<lambda>r z Should not have been called yet.rh z&Still should not have been called yet.r z/Result should have been from second deferred:%s) r rV r� rW rM r rA �AssertionErrorr� �r( r� r� r r r �testReturnDeferred s z DeferredTests.testReturnDeferredc sz t � }t�� � � �|� � �� t�� }|�� fdd�� |�d� g }|�|j� | �|g � � �� | �||g� dS )z� When a paused Deferred with a result is returned from a callback on another Deferred, the other Deferred is chained to the first and waits for it to be unpaused. c s � S r7 r ��ignored�Zpausedr r r� 1 r� zDDeferredTests.test_chainedPausedDeferredWithResult.<locals>.<lambda>N) �objectr rV r r� rW r" r# r� )r( �expectedZchainedr3 r r� r �$test_chainedPausedDeferredWithResult& s z2DeferredTests.test_chainedPausedDeferredWithResultc s` t �� }t �� � |�� fdd�� |�d� |�� � �d� g }� �|j� | �|dg� dS )z� A paused Deferred encountered while pushing a result forward through a chain does not prevent earlier Deferreds from continuing to execute their callbacks. c s � S r7 r r� ��secondr r r� C r� z:DeferredTests.test_pausedDeferredChained.<locals>.<lambda>N)r rV rW r r� r" r# )r( �firstr3 r r� r �test_pausedDeferredChained; s z(DeferredTests.test_pausedDeferredChainedc C s� g }t �t �d�t �d�g��|j� | �|ddgg� g }t �d�t �t� �g}t �|��|j� | �t |�d� | � |d t j � |d �dd� � d S )Nr rh r c S s dS �Nr r r� r r r r� X r� z2DeferredTests.test_gatherResults.<locals>.<lambda>) r � gatherResultsr� rW r" r# r� � ValueErrorr! r$ r� r r )r( r� rr r r r �test_gatherResultsL s "z DeferredTests.test_gatherResultsc C s� t �d�}t �td��}t j||gdd�}g }|�|j� g }|�|j� | �t|�t|�fd� | � |d j t j � |d j j }| � |j t� dS )z� If a L{Deferred} in the list passed to L{gatherResults} fires with a failure and C{consumerErrors} is C{True}, the failure is converted to a L{None} result on that L{Deferred}. r zoh noesTr� �r r r N) r r� r� r. r� r! r" r# r$ r� r' r{ r| )r( ZdgoodZdbadr� ZunconsumedErrorsZgatheredErrorsr~ r r r �#test_gatherResultsWithConsumeErrors[ s � z1DeferredTests.test_gatherResultsWithConsumeErrorsc C sn t �� }t �� }t �||g�}|�� | �|t j� | �|t j� | �|t j�}|j}| �|j � t j�� dS )z� When cancelling the L{defer.gatherResults} call, all the L{defer.Deferred}s in the list will be cancelled. N) r rV r� r� r� r r{ r' r% r| r& )r( r� r� r3 ZgatherResultsFailurer~ r r r �test_cancelGatherResultsq s z&DeferredTests.test_cancelGatherResultsc C sX t �t�}t �t�}t �||g�}|�� | �|�}| �|d d� | �|d d� dS )a When cancelling the L{defer.gatherResults} call, if all the L{defer.Deferred}s callback in their canceller, the L{defer.Deferred} returned by L{defer.gatherResults} will be callbacked with the C{list} of the results. r r r N)r rV r r� r� r� r# )r( r� r� r3 ZcallbackResultr r r �0test_cancelGatherResultsWithAllDeferredsCallback� s z>DeferredTests.test_cancelGatherResultsWithAllDeferredsCallbackc C sH g g }}t �dd� d�}|�|j|j� | �|g � | �|dg� dS )z� L{defer.maybeDeferred} should retrieve the result of a synchronous function and pass it to its resulting L{defer.Deferred}. c S s | d S �N� r ��xr r r r� � r� z6DeferredTests.test_maybeDeferredSync.<locals>.<lambda>� � N)r � maybeDeferredrj r" r# )r( �S�Er� r r r �test_maybeDeferredSync� s z$DeferredTests.test_maybeDeferredSyncc C s� g g }}z dd W n* t k r@ } z t|�}W 5 d}~X Y nX t�dd� d�}|�|j|j� | �|g � | �t|�d� | �t|d j�|� dS )z� L{defer.maybeDeferred} should catch exception raised by a synchronous function and errback its resulting L{defer.Deferred} with it. Z10r� Nc S s | d S r� r r� r r r r� � r� z;DeferredTests.test_maybeDeferredSyncError.<locals>.<lambda>r r ) � TypeErrorrl r r� rj r" r# r$ r' )r( r� r� r� r� r� r r r �test_maybeDeferredSyncError� s z)DeferredTests.test_maybeDeferredSyncErrorc sF t �� � t �� fdd��}� �d� g }|�|j� | �|dg� dS )z� L{defer.maybeDeferred} should let L{defer.Deferred} instance pass by so that original result is the same. c s � S r7 r r �r� r r r� � r� z7DeferredTests.test_maybeDeferredAsync.<locals>.<lambda>ZSuccessN)r rV r� r rW r" r# )r( r� r3 r r� r �test_maybeDeferredAsync� s z%DeferredTests.test_maybeDeferredAsyncc s< t �� � t �� fdd��}� �t�t� �� | �|t� dS )z� L{defer.maybeDeferred} should let L{defer.Deferred} instance pass by so that L{failure.Failure} returned by the original instance is the same. c s � S r7 r r r� r r r� � r� z<DeferredTests.test_maybeDeferredAsyncError.<locals>.<lambda>N)r rV r� rk r r r. r+ )r( r� r r� r � test_maybeDeferredAsyncError� s z*DeferredTests.test_maybeDeferredAsyncErrorc s� g �g � t �� �� ��fdd�}t �d�}|�|� ��d� |��j� ��� j� |�� j� | �g � � | ��ddddg� d S ) a When a L{Deferred} encounters a result which is another L{Deferred} which is waiting on a third L{Deferred}, the middle L{Deferred}'s callbacks are executed after the third L{Deferred} fires and before the first receives a result. c sR �� d| f� t�d�}��fdd�}�fdd�}|�|��|� |�� j � |S )N� start-of-cb�innerc s �� d� � S �N�� firstCallbackr� rt �r3 �r� �resultsr r r� � s zMDeferredTests.test_innerCallbacksPreserved.<locals>.cb.<locals>.firstCallbackc s � � d| f� | d S �N�secondCallbackrh rt r� �r� r r r� � s zNDeferredTests.test_innerCallbacksPreserved.<locals>.cb.<locals>.secondCallback�r" r r� rW r! �r3 r� r� r� �r* r� r� r r ra � s z6DeferredTests.test_innerCallbacksPreserved.<locals>.cb�outer�orange�r� r� r� �r� r� � orangeorangeN)r rV r� rW r r" r! r# �r( ra r� r r� r � test_innerCallbacksPreserved� s& ��z*DeferredTests.test_innerCallbacksPreservedc s� g �g �t �� � � ��fdd�}t �d�}|�|� |��j� | �ddg�� � �d� | �g �� | ��ddddgfg� dS ) a The continue callback of a L{Deferred} waiting for another L{Deferred} is not necessarily the first one. This is somewhat a whitebox test checking that we search for that callback among the whole list of callbacks. c s^ �� d| f� t�� }� �fdd�}�fdd�}|�|� |�|� |��j � |�d � |S )Nra c s �� d| f� t�� g�S �Nr� �r" r r� r� ��ar� r r r� � s zNDeferredTests.test_continueCallbackNotFirst.<locals>.cb.<locals>.firstCallbackc s � � d| f� d S �Nr� rt r� r� r r r� � s zODeferredTests.test_continueCallbackNotFirst.<locals>.cb.<locals>.secondCallback�r" r rV rW r! r r� �r� r* r� r r ra � s z7DeferredTests.test_continueCallbackNotFirst.<locals>.cbr� �ra r� �r� N�withersr� N)r rV r� rW r! r" r# r r� r r� r � test_continueCallbackNotFirst� s" ��z+DeferredTests.test_continueCallbackNotFirstc s� g �g �t �� � � ��fdd�}t �� }|�|� |��fdd�� |��j� |�d� | �ddg�� � �d� | �g �� | ��ddd dgfd g� d S ) z� A callback added to a L{Deferred} after a previous callback attached another L{Deferred} as a result is run after the callbacks of the other L{Deferred} are run. c s^ �� d| f� t�� }� �fdd�}�fdd�}|�|� |�|� |��j � |�d � |S )Nra c s �� d| f� t�� g�S r� r� r� r� r r r� # s zLDeferredTests.test_callbackOrderPreserved.<locals>.cb.<locals>.firstCallbackc s � � d| f� d S r� rt r� r� r r r� ' s zMDeferredTests.test_callbackOrderPreserved.<locals>.cb.<locals>.secondCallbackr� r� r� r r ra s z5DeferredTests.test_callbackOrderPreserved.<locals>.cbc s � � d�S )N�finalrt r� r� r r r� 2 r� z;DeferredTests.test_callbackOrderPreserved.<locals>.<lambda>r� r� r� r� r� r� N)r rV rW r! r" r r# r� r r� r �test_callbackOrderPreserved s( ��z)DeferredTests.test_callbackOrderPreservedc sh t �� �g ��fdd�� �fdd�}� ��fdd�}��|� ��|� ��d� | ��dd d g� dS ) z� A callback added to a L{Deferred} by a callback on that L{Deferred} should be added to the end of the callback chain. c s � � d� d S )N� rt r� ��calledr r � callback3F s z;DeferredTests.test_reentrantRunCallbacks.<locals>.callback3c s � � d� d S �Nrh rt r� r r r � callback2H s z;DeferredTests.test_reentrantRunCallbacks.<locals>.callback2c s �� d� ��� � d S r� �r" rW r� �r r r r r � callback1J s z;DeferredTests.test_reentrantRunCallbacks.<locals>.callback1Nr rh r �r rV rW r r# )r( r r r r r �test_reentrantRunCallbacks? s z(DeferredTests.test_reentrantRunCallbacksc sR t �� �g ��fdd�� � ���fdd�}��|� ��d� ���ddg� dS )z� A callback added to a L{Deferred} by a callback on that L{Deferred} should not be executed until the running callback returns. c s � � d� d S r rt r� r r r r Z s z;DeferredTests.test_nonReentrantCallbacks.<locals>.callback2c s& �� d� ��� � ���dg� d S r� )r" rW r# r� �r r r r( r r r \ s z;DeferredTests.test_nonReentrantCallbacks.<locals>.callback1Nr rh r )r( r r r r �test_nonReentrantCallbacksS s z(DeferredTests.test_nonReentrantCallbacksc sZ d�t �� ��fdd�� � �fdd�}��|� ��d� | ��t�}| �|j�f� dS )z� After an exception is raised by a callback which was added to a L{Deferred} by a callback on that L{Deferred}, the L{Deferred} should call the first errback with a L{Failure} wrapping that exception. zcallback raised exceptionc s t � ��d S r7 )� Exceptionr� )�exceptionMessager r r m s zFDeferredTests.test_reentrantRunCallbacksWithFailure.<locals>.callback2c s �� � � d S r7 )rW r� )r r r r r o s zFDeferredTests.test_reentrantRunCallbacksWithFailure.<locals>.callback1N)r rV rW r r+ r r# r )r( r r) r )r r r r �%test_reentrantRunCallbacksWithFailuree s z3DeferredTests.test_reentrantRunCallbacksWithFailurec sr t � }t�|�� t�� }|�� fdd�� |�d� g }� �|j� | �|d � |�|j� | �|d |� dS )a If a first L{Deferred} with a result is returned from a callback on a second L{Deferred}, the result of the second L{Deferred} becomes the result of the first L{Deferred} and the result of the first L{Deferred} becomes L{None}. c s � S r7 r ��ign�r� r r r� � r� z=DeferredTests.test_synchronousImplicitChain.<locals>.<lambda>Nr r ) r� r r� rV rW r r" rX r1 )r( r3 r� r� r r r � test_synchronousImplicitChainw s z+DeferredTests.test_synchronousImplicitChainc s� t �� � t �� }|�� fdd�� |�d� g }� �|j� g }|�|j� | �|g � | �|g � t� }� �|� | �|dg� | �||g� dS )a9 If a first L{Deferred} without a result is returned from a callback on a second L{Deferred}, the result of the second L{Deferred} becomes the result of the first L{Deferred} as soon as the first L{Deferred} has one and the result of the first L{Deferred} becomes L{None}. c s � S r7 r r r r r r� � r� z>DeferredTests.test_asynchronousImplicitChain.<locals>.<lambda>N)r rV rW r r" r# r� )r( r� � firstResult� secondResultr3 r r r � test_asynchronousImplicitChain� s z,DeferredTests.test_asynchronousImplicitChainc C s` t �td��}t �� }|�|fdd�� |�d� g }|�|j� | �|d � | �|t� dS )a If a first L{Deferred} with a L{Failure} result is returned from a callback on a second L{Deferred}, the first L{Deferred}'s result is converted to L{None} and no unhandled error is logged when it is garbage collected. �First Deferred's Failurec S s |S r7 r )r r� r r r r� � r� zBDeferredTests.test_synchronousImplicitErrorChain.<locals>.<lambda>Nr ) r r� r. rV rW r r" rX r+ )r( r� r� r r r r �"test_synchronousImplicitErrorChain� s z0DeferredTests.test_synchronousImplicitErrorChainc s� t �� � t �� }|�� fdd�� |�d� g }|�|j� g }� �|j� g }|�|j� | �|g � | �|g � � �td�� | � |d � t�� | �|dg� | �t |�d� dS )aP Let C{a} and C{b} be two L{Deferred}s. If C{a} has no result and is returned from a callback on C{b} then when C{a} fails, C{b}'s result becomes the L{Failure} that was C{a}'s result, the result of C{a} becomes L{None} so that no unhandled error is logged when it is garbage collected. c s � S r7 r r r r r r� � r� zCDeferredTests.test_asynchronousImplicitErrorChain.<locals>.<lambda>Nr r r ) r rV rW r r! r" r# rk r. r% r& r$ )r( r� Z secondErrorr r r r r �#test_asynchronousImplicitErrorChain� s z1DeferredTests.test_asynchronousImplicitErrorChainc s� t �� � t �� ���� fdd�� t �� }|��fdd�� g }|�|j� t� }��d� |�d� | �|g � � �|� | �||g� dS )z� L{Deferred} chaining is transitive. In other words, let A, B, and C be Deferreds. If C is returned from a callback on B and B is returned from a callback on A then when C fires, A fires. c s � S r7 r r r r r r� � r� zGDeferredTests.test_doubleAsynchronousImplicitChaining.<locals>.<lambda>c s � S r7 r r r� r r r� � r� N)r rV rW r" r� r r# )r( �thirdZ thirdResultr3 r )r� r� r �'test_doubleAsynchronousImplicitChaining� s z5DeferredTests.test_doubleAsynchronousImplicitChainingc s� g �g � t �� �� ��fdd�}t �d�}|�|� |��j� | ��ddg� ��d� ��� j� |�� j� | �g � d� | ��dddd g� d S ) z� L{Deferred}s can have callbacks that themselves return L{Deferred}s. When these "inner" L{Deferred}s fire (even asynchronously), the callback chain continues. c sR �� d| f� t�d�}��fdd�}�fdd�}|�|��|� |�� j � |S )Nr� r� c s �� d� � S r� rt r� r� r r r� s zXDeferredTests.test_nestedAsynchronousChainedDeferreds.<locals>.cb.<locals>.firstCallbackc s � � d| f� | d S r� rt r� r� r r r� s zYDeferredTests.test_nestedAsynchronousChainedDeferreds.<locals>.cb.<locals>.secondCallbackr� r� r� r r ra s zADeferredTests.test_nestedAsynchronousChainedDeferreds.<locals>.cbr� r� r� r� �&Got errbacks but wasn't expecting any.r� r� N�r rV r� rW r" r# r r! r� r r� r �'test_nestedAsynchronousChainedDeferreds� s6 � ���z5DeferredTests.test_nestedAsynchronousChainedDeferredsc s� g �g � t �� �� ��fdd�}t �d�}|�|� |��j� | ��ddg� ��d� |�� j� ��� j� | �g � d� | ��ddddgfddgg� d S ) aK L{Deferred}s can have callbacks that themselves return L{Deferred}s. These L{Deferred}s can have other callbacks added before they are returned, which subtly changes the callback chain. When these "inner" L{Deferred}s fire (even asynchronously), the outer callback chain continues. c sV �� d| f� t�d�}��fdd�}�fdd�}|�|� |�|� |�� j � |S )Nr� r� c s �� d| f� � �dd� �S )Nr� c S s | gS r7 r r� r r r r� I r� z|DeferredTests.test_nestedAsynchronousChainedDeferredsWithExtraCallbacks.<locals>.cb.<locals>.firstCallback.<locals>.<lambda>r r� r� r r r� C s zjDeferredTests.test_nestedAsynchronousChainedDeferredsWithExtraCallbacks.<locals>.cb.<locals>.firstCallbackc s � � d| f� | d S r� rt r� r� r r r� K s zkDeferredTests.test_nestedAsynchronousChainedDeferredsWithExtraCallbacks.<locals>.cb.<locals>.secondCallbackr� r� r� r r ra ? s zSDeferredTests.test_nestedAsynchronousChainedDeferredsWithExtraCallbacks.<locals>.cbr� r� r� r� r r� Nr r� r r� r �9test_nestedAsynchronousChainedDeferredsWithExtraCallbacks0 s6 � ���zGDeferredTests.test_nestedAsynchronousChainedDeferredsWithExtraCallbacksc C s, t �� }t �� }|�|� | �|j|� dS )zT When we chain a L{Deferred}, that chaining is recorded explicitly. N)r rV � chainDeferredr1 � _chainedTo�r( r� �br r r �&test_chainDeferredRecordsExplicitChainq s z4DeferredTests.test_chainDeferredRecordsExplicitChainc C s4 t �� }t �� }|�|� |�d� | �|j� dS )aR Any recorded chaining is cleared once the chaining is resolved, since it no longer exists. In other words, if one L{Deferred} is recorded as depending on the result of another, and I{that} L{Deferred} has fired, then the dependency is resolved and we no longer benefit from recording it. N)r rV r r rX r! r" r r r �%test_explicitChainClearedWhenResolved{ s z3DeferredTests.test_explicitChainClearedWhenResolvedc s> t �� }t �� � |�� fdd�� |�d� | �|j� � dS )z� We can chain L{Deferred}s implicitly by adding callbacks that return L{Deferred}s. When this chaining happens, we record it explicitly as soon as we can find out about it. c s � S r7 r r� �r# r r r� � r� zFDeferredTests.test_chainDeferredRecordsImplicitChain.<locals>.<lambda>N)r rV rW r r1 r! )r( r� r r& r �&test_chainDeferredRecordsImplicitChain� s z4DeferredTests.test_chainDeferredRecordsImplicitChainc s� t �� � � fdd�}� �|� � �d� | �|g�}| �t|�d� |d }| �|d t� d}| �t � ||d �d ||d f � d S ) z� When a Deferred is returned from a callback directly attached to that same Deferred, a warning is emitted. c s � S r7 r r� r� r r �circularCallback� s zADeferredTests.test_circularChainWarning.<locals>.circularCallback�foor r �categoryz1Callback returned the Deferred it was attached to�messagez Expected match: %r Got: %rN) r rV rW r � flushWarningsr# r$ �DeprecationWarningr% �re�search)r( r( Zcircular_warningsZwarning�patternr r� r �test_circularChainWarning� s �z'DeferredTests.test_circularChainWarningc s` | � ttdtj� tjdtd� t�� � � fdd�}� �|� � � d� | � � �}|� t� dS )z� If the deprecation warning for circular deferred callbacks is configured to be an error, the exception will become the failure result of the Deferred. �filtersr2 )r* c s � S r7 r r� r� r r r( � s zCDeferredTests.test_circularChainException.<locals>.circularCallbackr) N) rD �setattr�warningsr2 �filterwarningsr- r rV rW r r� �trap)r( r( r r r� r �test_circularChainException� s z)DeferredTests.test_circularChainExceptionc C s* t �� }t|�}| �t|�d|f � dS )z� The C{repr()} of a L{Deferred} contains the class name and a representation of the internal Python ID. z<Deferred at 0x%x>N)r rV �idr# �repr)r( r� Zaddressr r r � test_repr� s �zDeferredTests.test_reprc C s0 t �� }|�d� | �t|�dt|�f � dS )zb If a L{Deferred} has been fired, then its C{repr()} contains its result. r� z+<Deferred at 0x%x current result: 'orange'>N)r rV r r# r9 r8 r� r r r �test_reprWithResult� s ��z!DeferredTests.test_reprWithResultc C s> t �� }t �� }|�|� | �t|�dt|�t|�f � dS )z� If a L{Deferred} C{a} has been fired, but is waiting on another L{Deferred} C{b} that appears in its callback chain, then C{repr(a)} says that it is waiting on C{b}. z.<Deferred at 0x%x waiting on Deferred at 0x%x>N)r rV r r# r9 r8 r" r r r �test_reprWithChaining� s ��z#DeferredTests.test_reprWithChainingc s$ � fdd�}� � |d�|d�� dS )zw The depth of the call stack does not grow as more L{Deferred} instances are chained together. c s� g ��fdd�}t �� }dd� t| �D �}|d d � }t �� � |�� }|�|fdd�� |�|� |r�|�� }|�|fdd�� |}qb|�� fdd�� |�d � |D ]}|�d � q����g � � �d � �d S ) Nc s � � tt�� �� d S r7 )r" r$ � traceback� extract_stackr� )�stackr r �recordStackDepth� s zVDeferredTests.test_boundedStackDepth.<locals>.chainDeferreds.<locals>.recordStackDepthc S s g | ] }t �� �qS r )r rV )�.0r� r r r � <listcomp>� s zPDeferredTests.test_boundedStackDepth.<locals>.chainDeferreds.<locals>.<listcomp>c S s |S r7 r �r r� r r r r� � r� zNDeferredTests.test_boundedStackDepth.<locals>.chainDeferreds.<locals>.<lambda>c S s |S r7 r rC r r r r� � r� c s � S r7 r r )�lastr r r� � r� r )r rV �range�poprW r r# )ZhowManyr@ �topZinnerDeferredsZoriginalInnersr� ZnewInnerrG )rD r? r �chainDeferreds� s( z<DeferredTests.test_boundedStackDepth.<locals>.chainDeferredsr rh N)r# )r( rH r rG r �test_boundedStackDepth� s #z$DeferredTests.test_boundedStackDepthc s| t �� }t �� � t �� �|�� fdd�� � ��fdd�� � �d� |�d� ��d� g }� �|j� | �|dg� dS )a Given three Deferreds, one chained to the next chained to the next, callbacks on the middle Deferred which are added after the chain is created are called once the last Deferred fires. This is more of a regression-style test. It doesn't exercise any particular code path through the current implementation of Deferred, but it does exercise a broken codepath through one of the variations of the implementation proposed as a resolution to ticket #411. c s � S r7 r r� r� r r r� r� zZDeferredTests.test_resultOfDeferredResultOfDeferredOfFiredDeferredCalled.<locals>.<lambda>c s � S r7 r r� )r r r r� r� N)r rV rW r r" r# )r( r� �Lr )r� r r �:test_resultOfDeferredResultOfDeferredOfFiredDeferredCalled s zHDeferredTests.test_resultOfDeferredResultOfDeferredOfFiredDeferredCalledc C s� t �d� t �� }g }td�}z|�W n |�� Y nX |�|j� |d }| �|j|� |j d dd� \}}| �g |� | �g |� dS )z� C{Deferred.errback()} creates a failure from the current Python exception. When Deferred.debug is not set no globals or locals are captured in that failure. Fr� r ���N) r rE rV r rk r! r" r# r' �frames�r( r� r� �excr� �localz�globalzr r r � test_errbackWithNoArgsNoDebug& s z+DeferredTests.test_errbackWithNoArgsNoDebugc C s� t �d� t �� }g }td�}z|�W n |�� Y nX |�|j� |d }| �|j|� |j d dd� \}}| � g |� | � g |� dS )z� C{Deferred.errback()} creates a failure from the current Python exception. When Deferred.debug is set globals and locals are captured in that failure. Tr� r rL N) r rE rV r rk r! r" r# r' rM �assertNotEqualrN r r r �test_errbackWithNoArgs< s z$DeferredTests.test_errbackWithNoArgsc C sx t �� }|�d� t �d� dd� }|�|� g }|�|j� |d }|jd dd� \}}| �g |� | �g |� dS )�� An error raised by a callback creates a Failure. The Failure captures locals and globals if and only if C{Deferred.debug} is set. NFc S s t d��d S �Nr� �r r� r r r � raiseErrorZ s zHDeferredTests.test_errorInCallbackDoesNotCaptureVars.<locals>.raiseErrorr rL ) r rV r rE rW r! r" rM r# �r( r� rX r� r� rP rQ r r r �&test_errorInCallbackDoesNotCaptureVarsR s z4DeferredTests.test_errorInCallbackDoesNotCaptureVarsc C sx t �� }|�d� t �d� dd� }|�|� g }|�|j� |d }|jd dd� \}}| �g |� | �g |� dS )rU NTc S s t d��d S rV rW r� r r r rX m s zODeferredTests.test_errorInCallbackCapturesVarsWhenDebugging.<locals>.raiseErrorr rL ) r rV r rE rW r! r" rM rS rY r r r �-test_errorInCallbackCapturesVarsWhenDebugginge s z;DeferredTests.test_errorInCallbackCapturesVarsWhenDebuggingc C s8 t � }t�� }z |�� W n |�� Y nX dd� }t�|�}| �|�}t�|� � �}t r�| � t |�d� | � d|d d � | � d|d d � | � d|d d � nL| � t |�d� | � d|d d � | � d|d d � | � d|d d � | � d|d d � | � d |d d � | � d |d d � d S ) z� L{defer.inlineCallbacks} that re-raise tracebacks into their deferred should not lose their tracebacks. c s s | V d S r7 r r� r r r �ic� s z8DeferredTests.test_inlineCallbacksTracebacks.<locals>.icr Z test_deferrh r r z1/0r � test_inlineCallbacksTracebackszf.raiseException()N)r r rV ZraiseExceptionrk ZinlineCallbacksr� r= � extract_tbZgetTracebackObjectr r# r$ �assertIn)r( r r� r\ Z newFailure�tbr r r r] x s, z,DeferredTests.test_inlineCallbacksTracebacksN)Hr r r rH rM rO rQ rZ r\ r] r^ rs rv r r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r r r r r r r r r r$ r% r' r1 r7 r: r; r< rI rK rR rT rZ r[ r] r r r r r@ � s� ( %)* ;A +r@ c @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) �FirstErrorTestsz" Tests for L{FirstError}. c C sP t d�}z|�W n t�� }Y nX t�|d�}| �t|�dt|�f � dS )z� The repr of a L{FirstError} instance includes the repr of the value of the sub-failure and the index which corresponds to the L{FirstError}. � some textr zFirstError[#3, %s]N)r� r r r r{ r# r9 �r( rO r r2 r r r r: � s �zFirstErrorTests.test_reprc C sP t d�}z|�W n t�� }Y nX t�|d�}| �t|�dt|�f � dS )z� The str of a L{FirstError} instance includes the str of the sub-failure and the index which corresponds to the L{FirstError}. rb r� zFirstError[#5, %s]N)r� r r r r{ r# rl rc r r r �test_str� s �zFirstErrorTests.test_strc C s� z dd W n t �� }Y nX t�|d�}t�|d�}z td��W n t �� }Y nX t�|d�}| �||k� | �||k� | �||k� | �||k� | �|dk� dS )z� L{FirstError} instances compare equal to each other if and only if their failure and index compare equal. L{FirstError} instances do not compare equal to instances of other types. r r � Zbar� r� N)r r r r{ r� r% r� )r( Z firstFailureZoneZ anotherOneZ secondFailureZanotherr r r �test_comparison� s z FirstErrorTests.test_comparisonN)r r r r, r: rd rg r r r r ra � s ra c @ s� e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d� Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd � Zd d � Zd d � Zd!d"� Zd#d$� Zd%d&� Zd'd(� Zd)S )*�AlreadyCalledTestsc C s t �� | _t �d� d S �NT)r rF �_deferredWasDebuggingrE rG r r r rH � s zAlreadyCalledTests.setUpc C s t �| j� d S r7 )r rE rj rG r r r �tearDown� s zAlreadyCalledTests.tearDownc O s d S r7 r rK r r r rM � s z AlreadyCalledTests._callbackc O s d S r7 r rK r r r rQ � s zAlreadyCalledTests._errbackc C s |� d� d S )NrS r r� r r r �_call_1� s zAlreadyCalledTests._call_1c C s |� d� d S )NZtwicer r� r r r �_call_2� s zAlreadyCalledTests._call_2c C s |� t�t� �� d S r7 �rk r r r. r� r r r �_err_1� s zAlreadyCalledTests._err_1c C s |� t�t� �� d S r7 rn r� r r r �_err_2� s zAlreadyCalledTests._err_2c C s8 t �� }|�| j| j� | �|� | �t j| j|� d S r7 ) r rV rj rM rQ rl � assertRaises�AlreadyCalledErrorrm r� r r r �testAlreadyCalled_CC� s z'AlreadyCalledTests.testAlreadyCalled_CCc C s8 t �� }|�| j| j� | �|� | �t j| j|� d S r7 ) r rV rj rM rQ rl rq rr rp r� r r r �testAlreadyCalled_CE� s z'AlreadyCalledTests.testAlreadyCalled_CEc C s8 t �� }|�| j| j� | �|� | �t j| j|� d S r7 ) r rV rj rM rQ ro rq rr rp r� r r r �testAlreadyCalled_EE s z'AlreadyCalledTests.testAlreadyCalled_EEc C s8 t �� }|�| j| j� | �|� | �t j| j|� d S r7 ) r rV rj rM rQ ro rq rr rm r� r r r �testAlreadyCalled_EC s z'AlreadyCalledTests.testAlreadyCalled_ECc C sD d}|D ](}|� d| �r|�d| �r|d7 }q| �||k� d S )Nr z %s:z %sr )r> �endswithr% )r( Zlinetype�func�linesr� �count�liner r r �_count s � zAlreadyCalledTests._countc C s� |j d �d�}| �d||d� | �dd|d� | �dd|d� | �dd|d� | �dd|d� | �d ||d� | �d ||d� d S ) Nr � �Cr rl rm ro rp �I)r �splitr| )r( r� ZcallerZinvoker1Zinvoker2ry r r r �_check s zAlreadyCalledTests._checkc C st t �� }|�| j| j� | �|� z| �|� W n4 t jk rd } z| �|ddd� W 5 d }~X Y n X | � d� d S )N�testAlreadyCalledDebug_CCrl rm �2second callback failed to raise AlreadyCalledError) r rV rj rM rQ rl rm rr r� r� �r( r� r� r r r r� # s "z,AlreadyCalledTests.testAlreadyCalledDebug_CCc C st t �� }|�| j| j� | �|� z| �|� W n4 t jk rd } z| �|ddd� W 5 d }~X Y n X | � d� d S )N�testAlreadyCalledDebug_CErl rp �1second errback failed to raise AlreadyCalledError) r rV rj rM rQ rl rp rr r� r� r� r r r r� . s "z,AlreadyCalledTests.testAlreadyCalledDebug_CEc C st t �� }|�| j| j� | �|� z| �|� W n4 t jk rd } z| �|ddd� W 5 d }~X Y n X | � d� d S )N�testAlreadyCalledDebug_ECro rm r� ) r rV rj rM rQ ro rm rr r� r� r� r r r r� 9 s "z,AlreadyCalledTests.testAlreadyCalledDebug_ECc C st t �� }|�| j| j� | �|� z| �|� W n4 t jk rd } z| �|ddd� W 5 d }~X Y n X | � d� d S )N�testAlreadyCalledDebug_EEro rp r� ) r rV rj rM rQ ro rp rr r� r� r� r r r r� D s "z,AlreadyCalledTests.testAlreadyCalledDebug_EEc C sz t �d� t �� }|�| j| j� | �|� z| �|� W n0 t jk rj } z| � |j � W 5 d }~X Y n X | � d� d S )NFr� ) r rE rV rj rM rQ rl rm rr r� r r� r� r r r �testNoDebuggingO s z"AlreadyCalledTests.testNoDebuggingc C sl t �d� t �� }|�dd� � t �d� |�d � t �d� t �� }|�d � t �d� |�dd� � d S )NFc S s d S r7 r r r r r r� a r� z8AlreadyCalledTests.testSwitchDebugging.<locals>.<lambda>Tc S s d S r7 r r r r r r� i r� )r rE rV �addBothr r� r r r �testSwitchDebugging\ s z&AlreadyCalledTests.testSwitchDebuggingN)r r r rH rk rM rQ rl rm ro rp rs rt ru rv r| r� r� r� r� r� r� r� r r r r rh � s( rh c @ s� e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d� Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd � Zd d � Zd d � Zd!d"� Zd#d$� Zd%d&� Zd'S )(�DeferredCancellerTestsc C s d | _ d | _d | _d| _d S rI )rA rB rC �cancellerCallCountrG r r r rH n s z DeferredCancellerTests.setUpc C s | � | jd� d S )Nr� )r_ r� rG r r r rk u s z DeferredCancellerTests.tearDownc C s || _ |S r7 rJ �r( �datar r r rM z s z DeferredCancellerTests._callbackc C s || _ d S r7 rN r� r r r rO s z!DeferredCancellerTests._callback2c C s || _ d S r7 rP r� r r r rQ � s z DeferredCancellerTests._errbackc C sB t �� }|�| j| j� |�� | �| jjt j � | � | j � dS )z A L{defer.Deferred} without a canceller must errback with a L{defer.CancelledError} and not callback. N) r rV rj rM rQ r� r# rB rz r rX rA r� r r r �test_noCanceller� s z'DeferredCancellerTests.test_noCancellerc C sT t �� }|�| j| j� |�� |�d� | �t j|jd� | �t j|j t � � dS )z� A L{defer.Deferred} without a canceller, when cancelled must allow a single extra call to callback, and raise L{defer.AlreadyCalledError} if callbacked or errbacked thereafter. N) r rV rj rM rQ r� r rq rr rk r r� r r r �!test_raisesAfterCancelAndCallback� s z8DeferredCancellerTests.test_raisesAfterCancelAndCallbackc C sV t �� }|�| j| j� |�� |�t� � | �t j |j d� | �t j |jt� � dS )z� A L{defer.Deferred} without a canceller, when cancelled must allow a single extra call to errback, and raise L{defer.AlreadyCalledError} if callbacked or errbacked thereafter. N) r rV rj rM rQ r� rk r rq rr r r� r r r � test_raisesAfterCancelAndErrback� s z7DeferredCancellerTests.test_raisesAfterCancelAndErrbackc C sJ t �� }|�| j| j� |�� | j}|�d� |�� | �|| j� dS )z� A L{Deferred} without a canceller, when cancelled and then callbacked, ignores multiple cancels thereafter. N) r rV rj rM rQ r� rB r r1 �r( r� �currentFailurer r r �5test_noCancellerMultipleCancelsAfterCancelAndCallback� s zLDeferredCancellerTests.test_noCancellerMultipleCancelsAfterCancelAndCallbackc C sp t �� }|�| j| j� |�� | �| jjt j � | j}|� t � � | �| jjt j � |�� | � || j� dS )z� A L{defer.Deferred} without a canceller, when cancelled and then errbacked, ignores multiple cancels thereafter. N) r rV rj rM rQ r� r# rB rz r rk r r1 r� r r r �4test_noCancellerMultipleCancelsAfterCancelAndErrback� s zKDeferredCancellerTests.test_noCancellerMultipleCancelsAfterCancelAndErrbackc C sR t �� }|�| j| j� |�� | �| jjt j � | j}|�� | � || j� dS )z� Calling cancel multiple times on a deferred with no canceller results in a L{defer.CancelledError}. Subsequent calls to cancel do not cause an error. N) r rV rj rM rQ r� r# rB rz r r1 r� r r r � test_noCancellerMultipleCancel� s z5DeferredCancellerTests.test_noCancellerMultipleCancelc sp � fdd�}t j|d�}|�� j� j� |�� � �� jjt j � � j}|�� � � |� j� � �� j d� dS )a, Verify that calling cancel multiple times on a deferred with a canceller that does not errback results in a L{defer.CancelledError} and that subsequent calls to cancel do not cause an error and that after all that, the canceller was only called once. c s � j d7 _ d S r� �r� r� rG r r r� � s zCDeferredCancellerTests.test_cancellerMultipleCancel.<locals>.cancel�Z cancellerr N) r rV rj rM rQ r� r# rB rz r r1 r� )r( r� r� r� r rG r � test_cancellerMultipleCancel� s z3DeferredCancellerTests.test_cancellerMultipleCancelc sz � fdd�}t j|d�}|�� j� j� |�� � �� jd� � �� jj t j � � � t j |j d� � � t j |jt� � dS )z� Verify that a L{defer.Deferred} calls its specified canceller when it is cancelled, and that further call/errbacks raise L{defer.AlreadyCalledError}. c s � j d7 _ d S r� r� r� rG r r r� s z;DeferredCancellerTests.test_simpleCanceller.<locals>.cancelr� r N)r rV rj rM rQ r� r# r� rB rz r rq rr r rk r �r( r� r� r rG r �test_simpleCanceller� s z+DeferredCancellerTests.test_simpleCancellerc s6 � �fdd�}t j|d�� � ��j�j� � �� dS )zQ Verify that a canceller is given the correct deferred argument. c s �� | � � d S r7 )r1 )r� �r� r( r r r� s z8DeferredCancellerTests.test_cancellerArg.<locals>.cancelr� N)r rV rj rM rQ r� )r( r� r r� r �test_cancellerArg s z(DeferredCancellerTests.test_cancellerArgc sf � fdd�}t j|d�}|�� j� j� |�d� |�� � �� jd� � � � j � � �� j d� dS )zo Test that cancelling a deferred after it has been callbacked does not cause an error. c s � j d7 _ | �t� � d S r� �r� rk r r� rG r r r� ! s z?DeferredCancellerTests.test_cancelAfterCallback.<locals>.cancelr� zbiff!r N) r rV rj rM rQ r r� r# r� rX rB rA r� r rG r �test_cancelAfterCallback s z/DeferredCancellerTests.test_cancelAfterCallbackc sj � fdd�}t j|d�}|�� j� j� |�t� � |�� � �� j d� � �� j j t� � � � j � dS )z� Test that cancelling a L{Deferred} after it has been errbacked does not result in a L{defer.CancelledError}. c s � j d7 _ | �t� � d S r� r� r� rG r r r� 2 s z>DeferredCancellerTests.test_cancelAfterErrback.<locals>.cancelr� r N)r rV rj rM rQ rk r r� r# r� rB rz rX rA r� r rG r �test_cancelAfterErrback- s z.DeferredCancellerTests.test_cancelAfterErrbackc sR � fdd�}t j|d�}|�� j� j� |�� � �� jd� � �� jj t � dS )z? Test a canceller which errbacks its deferred. c s � j d7 _ | �t� � d S r� r� r� rG r r r� B s zADeferredCancellerTests.test_cancellerThatErrbacks.<locals>.cancelr� r N) r rV rj rM rQ r� r# r� rB rz r r� r rG r �test_cancellerThatErrbacks> s z1DeferredCancellerTests.test_cancellerThatErrbacksc s\ � fdd�}t j|d�}|�� j� j� |�� � �� jd� � �� jd� � � � j � dS )z< Test a canceller which calls its deferred. c s � j d7 _ | �d� d S )Nr �hello!)r� r r� rG r r r� P s zBDeferredCancellerTests.test_cancellerThatCallbacks.<locals>.cancelr� r r� N) r rV rj rM rQ r� r# r� rA rX rB r� r rG r �test_cancellerThatCallbacksL s z2DeferredCancellerTests.test_cancellerThatCallbacksc s� �fdd�}�fdd�}t j|d�� t j|d�}|�d� |�� fdd�� |�� |��j�j� ���j d � ���j j t j � dS ) z� Verify that a Deferred, a, which is waiting on another Deferred, b, returned from one of its callbacks, will propagate L{defer.CancelledError} when a is cancelled. c s � j d7 _ d S r� r� r� rG r r � innerCancela s zEDeferredCancellerTests.test_cancelNestedDeferred.<locals>.innerCancelc s � � d� d S �NF)r% r� rG r r r� c s z@DeferredCancellerTests.test_cancelNestedDeferred.<locals>.cancelr� Nc s � S r7 r )r� r& r r r� i r� zBDeferredCancellerTests.test_cancelNestedDeferred.<locals>.<lambda>r ) r rV r rW r� rj rM rQ r# r� rB rz r )r( r� r� r� r )r# r( r �test_cancelNestedDeferred[ s z0DeferredCancellerTests.test_cancelNestedDeferredN)r r r rH rk rM rO rQ r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r r r r� m s& r� c @ sh e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� ZdS )�LogTestsz+ Test logging of unhandled errors. c C s g | _ t�| j j� dS )z< Add a custom observer to observer logging. N)�cr r= r" rG r r r rH y s zLogTests.setUpc C s t �| jj� dS )z& Remove the observer. N)r ZremoveObserverr� r" rG r r r rk � s zLogTests.tearDownc C s dd� | j D �S )Nc S s g | ]}|d r|�qS )ZisErrorr )rA r� r r r rB � s z*LogTests._loggedErrors.<locals>.<listcomp>�r� rG r r r � _loggedErrors� s zLogTests._loggedErrorsc C s8 | � � }| �t|�d� |d d �t� | �t� dS )zV Check the output of the log observer to see if the error is present. rh r r N)r� r# r$ r6 r� r0 )r( Zc2r r r r� � s zLogTests._checkc C s, t �� �dd� ��d� t�� | �� dS )z� Verify that when a L{Deferred} with no references to it is fired, and its final result (the one not handled by any callback) is an exception, that exception will be logged immediately. c S s dd S r� r r� r r r r� � r� z(LogTests.test_errorLog.<locals>.<lambda>r N)r rV rW r �gc�collectr� rG r r r � test_errorLog� s zLogTests.test_errorLogc C s" dd� }|� t �� | �� dS )zD Same as L{test_errorLog}, but with an inner frame. c S s$ t �� } | �dd� � | �d� d S )Nc S s dd S r� r r� r r r r� � r� z`LogTests.test_errorLogWithInnerFrameRef.<locals>._subErrorLogWithInnerFrameRef.<locals>.<lambda>r )r rV rW r r� r r r � _subErrorLogWithInnerFrameRef� s zNLogTests.test_errorLogWithInnerFrameRef.<locals>._subErrorLogWithInnerFrameRefN�r� r� r� )r( r� r r r � test_errorLogWithInnerFrameRef� s z'LogTests.test_errorLogWithInnerFrameRefc C s" dd� }|� t �� | �� dS )zQ Same as L{test_errorLogWithInnerFrameRef}, plus create a cycle. c S s. t �� } | �| fdd�� | | _| �d� d S )Nc S s dd S r� r )r� r� r r r r� � r� zdLogTests.test_errorLogWithInnerFrameCycle.<locals>._subErrorLogWithInnerFrameCycle.<locals>.<lambda>r )r rV rW Z_dr r� r r r � _subErrorLogWithInnerFrameCycle� s zRLogTests.test_errorLogWithInnerFrameCycle.<locals>._subErrorLogWithInnerFrameCycleNr� )r( r� r r r � test_errorLogWithInnerFrameCycle� s z)LogTests.test_errorLogWithInnerFrameCyclec C sj t �� �dd� ��d� t�� | �� | �dt| j �� t � | j d �}d}| � |� |�d�|�� dS ) z� Verify that when a L{Deferred} with no references to it is fired, the logged message does not contain a repr of the failure object. c S s dd S r� r r� r r r r� � r� z.LogTests.test_errorLogNoRepr.<locals>.<lambda>r rh ���r< �%Expected message starting with: {0!r}N)r rV rW r r� r� r� r# r$ r� r r8 r% r> �format)r( �msgr� r r r �test_errorLogNoRepr� s ��z LogTests.test_errorLogNoReprc C s` dd� }|� t �� | �� | �dt| j�� t�| jd �}d}| �|� |�d� |�� dS )z� Verify that when a L{Deferred} with no references to it is fired, the logged message includes debug info if debugging on the deferred is enabled. c S s* t �� } d| _| �dd� � | �d� d S )NTc S s dd S r� r r� r r r r� � r� z?LogTests.test_errorLogDebugInfo.<locals>.doit.<locals>.<lambda>r )r rV �debugrW r r� r r r �doit� s z-LogTests.test_errorLogDebugInfo.<locals>.doitrh r� z (debug: Ir� N) r� r� r� r# r$ r� r r8 r% r> r� )r( r� r� r� r r r �test_errorLogDebugInfo� s ��z LogTests.test_errorLogDebugInfoc C s� t �� }|�dd� � |�d� g }g }|�|j|j� | �|g � | �t|�d� |d �t � ~~~t � � | �| � � g � dS )z� If one Deferred with an error result is returned from a callback on another Deferred, when the first Deferred is garbage collected it does not log its error. c S s t �td��S )NZzoop)r r� r. r r r r r� � r� z3LogTests.test_chainedErrorCleanup.<locals>.<lambda>Nr r ) r rV rW r rj r" r# r$ r6 r r� r� r� )r( r� r� r5 r r r �test_chainedErrorCleanup� s z!LogTests.test_chainedErrorCleanupc sL t �td��}t �� � |�� fdd�� d � }t�� | �| �� g � dS )z� If a Deferred with a failure result has an errback which chains it to another Deferred, the initial failure is cleared by the errback so it is not logged. zoh noc s � S r7 r r� �Zgoodr r r� r� z6LogTests.test_errorClearedByChaining.<locals>.<lambda>N) r r� r rV r! r� r� r# r� )r( Zbadr r� r �test_errorClearedByChaining s z$LogTests.test_errorClearedByChainingN)r r r r, rH rk r� r� r� r� r� r� r� r� r� r r r r r� t s r� c @ s, e Zd Zdd� Zdd� Zdd� Zdd� Zd S ) �DeferredListEmptyTestsc C s d| _ d S rI )� callbackRanrG r r r rH s z DeferredListEmptyTests.setUpc C s t �g �}|�| j� dS )zTesting empty DeferredList.N)r ri rW �cb_empty)r( rr r r r �testDeferredListEmpty s z,DeferredListEmptyTests.testDeferredListEmptyc C s d| _ | �g |� d S r� )r� r# )r( �resr r r r� s z DeferredListEmptyTests.cb_emptyc C s | � | jd� d S )NzCallback was never run.)r% r� rG r r r rk ! s z DeferredListEmptyTests.tearDownN)r r r rH r� r� rk r r r r r� s r� c @ sl e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d� Z dd� Z dd� Z dd� Z dd� Z dd� ZdS )�OtherPrimitivesTestsc C s | j d7 _ d S r� ��counter)r( r3 r r r �_incr' s zOtherPrimitivesTests._incrc C s d| _ d S rI r� rG r r r rH * s zOtherPrimitivesTests.setUpc s� t �� }|�� ��j� ��|j� ���jd� |�� ��j� ��|j� ���jd� |� � ��|j� ���jd� |� � �� |j� ���jd� �� t |j � t� }t� }t �� � � fdd�}|j |�|d�}��|j� ���j|� |��fdd�� |�� ��j� ��|j� ���jd� � �|� ���j|� ��|j� ���jd� |�� ��fd d��}|�� ���jjt j� |� � �� |j� d S ) Nr rh c s || _ � S r7 r& �r( r# ��controlDeferredr r �helperE s z-OtherPrimitivesTests.testLock.<locals>.helperr� c s t � d| �S �Nr3 �r3 r� rG r r r� M r� z/OtherPrimitivesTests.testLock.<locals>.<lambda>r c s t � d| �S r� r� r� rG r r r� X r� )r � DeferredLock�acquirerW r� r% �lockedr# r� �releaser� rq r� �runr� rV r# r r3 r� r� rz r )r( �lockZ firstUniqueZ secondUniquer� �resultDeferredr� r )r� r( r �testLock- sD z OtherPrimitivesTests.testLockc s2 � fdd�}t �� }|�� }|�|� |�� dS )z� When canceling a L{Deferred} from a L{DeferredLock} that already has the lock, the cancel should have no effect. c s � � d� d S �NzUnexpected errback call!�r� r� rG r r �_failOnErrbacke s zIOtherPrimitivesTests.test_cancelLockAfterAcquired.<locals>._failOnErrbackN)r r� r� r! r� )r( r� r� r� r rG r � test_cancelLockAfterAcquired` s z1OtherPrimitivesTests.test_cancelLockAfterAcquiredc C s2 t �� }|�� |�� }|�� | �|t j� dS )z� When canceling a L{Deferred} from a L{DeferredLock} that does not yet have the lock (i.e., the L{Deferred} has not fired), the cancel should cause a L{defer.CancelledError} failure. N)r r� r� r� r+ r )r( r� r� r r r � test_cancelLockBeforeAcquiredm s z2OtherPrimitivesTests.test_cancelLockBeforeAcquiredc sz d}t �|�}t �� � � fdd�}g }t� }|j|| |d�}|�|j� |�| j� | �|g � | �| j |� � � d � | � |� � � | �| j d� d| _ tdd| �D ]"}|�� �| j� | �| j |� q�g ��fdd�}�fd d �} |�� �|| �} | �� | ��d g� |�� �| j� | �| j |� |�� | �| j |d � tdd| �D ] }|�� | �| j |d � �qTd S ) Nre c s || _ � S r7 )�arg�r( r� r� r r r� s z2OtherPrimitivesTests.testSemaphore.<locals>.helperr� r r c s � � d� d S r� rt �r� �r� r r r� � s z0OtherPrimitivesTests.testSemaphore.<locals>.failc s � � d� d S ri rt r� r� r r r� � s z3OtherPrimitivesTests.testSemaphore.<locals>.succeedT)r �DeferredSemaphorerV r� r� rW r" r� r# r� r rX rF r� rE r� rj r� r� ) r( �N�semr� r� Z uniqueObjectr� �ir� r� r� r )r� r� r � testSemaphorez s> z"OtherPrimitivesTests.testSemaphorec C s$ | � ttjd� | � ttjd� dS )zz If the token count passed to L{DeferredSemaphore} is less than one then L{ValueError} is raised. r r� N)rq r� r r� rG r r r �test_semaphoreInvalidTokens� s z0OtherPrimitivesTests.test_semaphoreInvalidTokensc s4 � fdd�}t �d�}|�� }|�|� |�� dS )z� When canceling a L{Deferred} from a L{DeferredSemaphore} that already has the semaphore, the cancel should have no effect. c s � � d� d S r� r� r� rG r r r� � s zNOtherPrimitivesTests.test_cancelSemaphoreAfterAcquired.<locals>._failOnErrbackr N)r r� r� r! r� )r( r� r� r� r rG r �!test_cancelSemaphoreAfterAcquired� s z6OtherPrimitivesTests.test_cancelSemaphoreAfterAcquiredc C s4 t �d�}|�� |�� }|�� | �|t j� dS )z� When canceling a L{Deferred} from a L{DeferredSemaphore} that does not yet have the semaphore (i.e., the L{Deferred} has not fired), the cancel should cause a L{defer.CancelledError} failure. r N)r r� r� r� r+ r )r( r� r� r r r �"test_cancelSemaphoreBeforeAcquired� s z7OtherPrimitivesTests.test_cancelSemaphoreBeforeAcquiredc C s� d\}}t �||�}g }t|�D ]}|�� �|j� q | �t j|j� t|�D ]&}|�|� | � |t t|d ��� qNt|�D ]&}|�|| � | � |t t|��� q~| �t j |jd � g }t|�D ]2}|�� �|j� | � |t t||| d ��� q�t �� }g }t|�D ]}|�� �|j� �q t|�D ]}|�|� �q,| � |t t|��� t jdd�}| �t j |jd � t jdd�}| �t j|j� d S )N)rh rh r r )�size)Zbacklog) r � DeferredQueuerE �getrW r" rq ZQueueUnderflow�putr# �listZ QueueOverflow)r( r� �M�queueZgottenr� r r r � testQueue� s8 z OtherPrimitivesTests.testQueuec s< � fdd�}t �� }|�� }|�|� |�d� |�� dS )z� When canceling a L{Deferred} from a L{DeferredQueue} that already has a result, the cancel should have no effect. c s � � d� d S r� r� r� rG r r r� � s zPOtherPrimitivesTests.test_cancelQueueAfterSynchronousGet.<locals>._failOnErrbackN)r r� r� r! r� r� )r( r� r� r� r rG r �#test_cancelQueueAfterSynchronousGet� s z8OtherPrimitivesTests.test_cancelQueueAfterSynchronousGetc sb t �� � � �� }|�� ��|t j� � �fdd�}|�|� g }|�|j� ��t |�d� dS )a When canceling a L{Deferred} from a L{DeferredQueue} that does not have a result (i.e., the L{Deferred} has not fired), the cancel causes a L{defer.CancelledError} failure. If the queue has a result later on, it doesn't try to fire the deferred. c s � � d � � �� ��jd �S r7 )r� r� rW r1 )�ignore�r� r( r r ra s z9OtherPrimitivesTests.test_cancelQueueAfterGet.<locals>.cbr N) r r� r� r� r+ r rW r" r# r$ )r( r� ra �doner r� r �test_cancelQueueAfterGet s z-OtherPrimitivesTests.test_cancelQueueAfterGetN)r r r r� rH r� r� r� r� r� r� r� r� r� r� r r r r r� & s 3 . &r� c @ sX e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dS )�DeferredFilesystemLockTestsz8 Test the behavior of L{DeferredFilesystemLock} c C s" t � | _tj| �� | jd�| _d S )N)Z scheduler)r �clockr �DeferredFilesystemLock�mktempr� rG r r r rH s �z!DeferredFilesystemLockTests.setUpc C s | j jdd�}|S )zI Test that the lock can be acquired when no lock is held r ��timeout)r� �deferUntilLockedr� r r r � test_waitUntilLockedWithNoLock# s z:DeferredFilesystemLockTests.test_waitUntilLockedWithNoLockc C sB | � | j�� � | jjdd�}| �|tj� | j�dgd � |S )zs Test that the lock can not be acquired when the lock is held for longer than the timeout. g @r� r r� )r% r� r� � assertFailurer � TimeoutErrorr� �pumpr� r r r �%test_waitUntilLockedWithTimeoutLocked, s zADeferredFilesystemLockTests.test_waitUntilLockedWithTimeoutLockedc s\ � fdd�}� � � j�� � � j�d� jj� � jjdd�}|�|� � j�dgd � |S )z| Test that a lock can be acquired while a lock is held but the lock is unlocked before our timeout. c s | � tj� � �d� d S )NzShould not have timed out)r6 r r� r� �r rG r r � onTimeout@ s zVDeferredFilesystemLockTests.test_waitUntilLockedWithTimeoutUnlocked.<locals>.onTimeoutr r� r� )r% r� r� � callLater�unlockr� r! r� )r( r r� r rG r �'test_waitUntilLockedWithTimeoutUnlocked; s zCDeferredFilesystemLockTests.test_waitUntilLockedWithTimeoutUnlockedc C s t �| �� �}| �|jt� dS )zE Test that the default scheduler is set up properly. N)r r� r� r# Z _schedulerr )r( r� r r r �test_defaultSchedulerO s z1DeferredFilesystemLockTests.test_defaultSchedulerc C sN | j � � | j�d| j j� | j �� }| j �� }| �|tj� | j�d� |S )z| Test that an appropriate exception is raised when attempting to use deferUntilLocked concurrently. r ) r� r� r r r� r� r ZAlreadyTryingToLockError�advancer� r r r �test_concurrentUsageX s z0DeferredFilesystemLockTests.test_concurrentUsagec sL � fdd�}� j � � � j�d� j j� � j �� }|�|� � j�d� |S )zO Test that a DeferredFilesystemLock can be used multiple times c s � j �� � j �� }|S r7 )r� r r� )r r� rG r r � lockAquiredn s zDDeferredFilesystemLockTests.test_multipleUsages.<locals>.lockAquiredr )r� r� r r r� rW r )r( r r� r rG r �test_multipleUsagesj s z/DeferredFilesystemLockTests.test_multipleUsagesc C sR | j � � | j �� }| j j}|�� | �|�� � | �| j j� | �|tj � dS )z� When cancelling a L{defer.Deferred} returned by L{defer.DeferredFilesystemLock.deferUntilLocked}, the L{defer.DeferredFilesystemLock._tryLockCall} is cancelled. N) r� r� Z _tryLockCallr� r� �activerX r� r r )r( r Z tryLockCallr r r �test_cancelDeferUntilLocked~ s z7DeferredFilesystemLockTests.test_cancelDeferUntilLockedc C sV | j � � | j jdd�}| j j}|�� | �|�� � | �| j j� | �|tj � dS )z� When cancel a L{defer.Deferred} returned by L{defer.DeferredFilesystemLock.deferUntilLocked}, if the timeout is set, the timeout call will be cancelled. r r� N) r� r� Z _timeoutCallr� r� r rX r� r r )r( r Z timeoutCallr r r �&test_cancelDeferUntilLockedWithTimeout� s zBDeferredFilesystemLockTests.test_cancelDeferUntilLockedWithTimeoutN) r r r r, rH r� r� r r r r r r r r r r r� s r� c C s dS )zj Private function to be used to pass as an alternate onTimeoutCancel value to timeoutDeferred � OVERRIDDENr )�v�tr r r � _overrideFunc� s r c @ s� e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"d#� Zd$d%� Zd&S )'�DeferredAddTimeoutTestsz7 Tests for the function L{Deferred.addTimeout} c C s< t �� �dt� ��dd� �}|�d� | �d| �|�� dS )z� L{defer.Deferred.addTimeout} returns its own L{defer.Deferred} so it can be called in a callback chain. r� c S s dS )Nr� r r� r r r r� � r� z?DeferredAddTimeoutTests.test_timeoutChainable.<locals>.<lambda>Nr� )r rV � addTimeoutr rW r r# r� r� r r r �test_timeoutChainable� s z-DeferredAddTimeoutTests.test_timeoutChainablec s� t � }t�� }|�d|� t�� �dg� � �fdd�}|�|� |�d� | �d� d � | �� d d� |�d� | � �� dS )z� The L{defer.Deferred} callbacks with the result if it succeeds before the timeout. No cancellation happens after the callback either, which could also cancel inner deferreds. r� Nc s | � d< �S rI r r� �� dCallbacked� innerDeferredr r � onCallback� s zKDeferredAddTimeoutTests.test_successResultBeforeTimeout.<locals>.onCallbackr� r r� ) r r rV r rW r � assertIsNotr# r r� �r( r� r� r r r r � test_successResultBeforeTimeout� s z7DeferredAddTimeoutTests.test_successResultBeforeTimeoutc s� t � }t�� }|jd|td� t�� �dg� � �fdd�}|�|� |�d� | �d� d � | �� d d� |� d� | � �� dS ) a The L{defer.Deferred} callbacks with the result if it succeeds before the timeout, even if a custom C{onTimeoutCancel} function is provided. No cancellation happens after the callback either, which could also cancel inner deferreds. r� �ZonTimeoutCancelNc s | � d< �S rI r r� r r r r � s zQDeferredAddTimeoutTests.test_successResultBeforeTimeoutCustom.<locals>.onCallbackr� r r� ) r r rV r r rW r r r# r r� r r r r �%test_successResultBeforeTimeoutCustom� s z=DeferredAddTimeoutTests.test_successResultBeforeTimeoutCustomc s� t � }t�� }|�d|� t�� �dg� td�}� �fdd�}|�|� |�|� | �� d tj � | � � d j |� |� d� | � �� dS )z� The L{defer.Deferred} errbacks with the failure if it fails before the timeout. No cancellation happens after the errback either, which could also cancel inner deferreds. r� Nr� c s | � d< �S rI r r �� dErrbackedr r r � onErrback s zDDeferredAddTimeoutTests.test_failureBeforeTimeout.<locals>.onErrbackr r� )r r rV r r� r! rk r� r r r1 r' r r� �r( r� r� r2 r r r r �test_failureBeforeTimeout� s z1DeferredAddTimeoutTests.test_failureBeforeTimeoutc s� t � }t�� }|jd|td� t�� �dg� td�}� �fdd�}|�|� |�|� | �� d t j � | � � d j |� |� d� | ��� dS ) a The L{defer.Deferred} errbacks with the failure if it fails before the timeout, even if using a custom C{onTimeoutCancel} function. No cancellation happens after the errback either, which could also cancel inner deferreds. r� r Nr� c s | � d< �S rI r r r r r r * s zJDeferredAddTimeoutTests.test_failureBeforeTimeoutCustom.<locals>.onErrbackr r� )r r rV r r r� r! rk r� r r r1 r' r r� r r r r � test_failureBeforeTimeoutCustom s z7DeferredAddTimeoutTests.test_failureBeforeTimeoutCustomc C s@ t � }t�� }|�d|� | �|� |�d� | �|tj� dS )z� The L{defer.Deferred} by default errbacks with a L{defer.TimeoutError} if it times out before callbacking or errbacking. r� r� N)r r rV r r� r r� r� �r( r� r� r r r � test_timedOut< s z%DeferredAddTimeoutTests.test_timedOutc C sH t � }t�� }|jd|td� | �|� |�d� | �d| �|�� dS )a= If a custom C{onTimeoutCancel] function is provided, the L{defer.Deferred} returns the custom function's return value if the L{defer.Deferred} times out before callbacking or errbacking. The custom C{onTimeoutCancel} function can return a result instead of a failure. r� r r� r N� r r rV r r r� r r# r� r# r r r �test_timedOutCustomK s z+DeferredAddTimeoutTests.test_timedOutCustomc C sJ t � }t�dd� �}|�d|� | �|� |�d� | �| �|�d� dS )z� If a cancellation function is provided when the L{defer.Deferred} is initialized, the L{defer.Deferred} returns the cancellation value's non-failure return value when the L{defer.Deferred} times out. c S s | � d�S )N�I was cancelled!r r� r r r r� d r� zLDeferredAddTimeoutTests.test_timedOutProvidedCancelSuccess.<locals>.<lambda>r� r� r' N)r r rV r r� r r# r� r# r r r �"test_timedOutProvidedCancelSuccess] s z:DeferredAddTimeoutTests.test_timedOutProvidedCancelSuccessc s^ t � }td�� t�� fdd��}|�d|� | �|� |�d� | �|t�}| �|j � � dS )z� If a cancellation function is provided when the L{defer.Deferred} is initialized, the L{defer.Deferred} returns the cancellation value's non-L{CanceledError} failure when the L{defer.Deferred} times out. �what!c s | � � �S r7 )rk r� �r2 r r r� u r� zLDeferredAddTimeoutTests.test_timedOutProvidedCancelFailure.<locals>.<lambda>r� r� N) r r� r rV r r� r r� r1 r' )r( r� r� r r r* r �"test_timedOutProvidedCancelFailurem s z:DeferredAddTimeoutTests.test_timedOutProvidedCancelFailurec s� t � }t�� }|�d|� t�� �dg� � �fdd�}|�|� |�� | �� d tj� | � � d j tj � |� d� | � �� dS )a3 If the L{defer.Deferred} is manually cancelled before the timeout, it is not re-cancelled (no L{AlreadyCancelled} error, and also no canceling of inner deferreds), and the default C{onTimeoutCancel} function is not called, preserving the original L{CancelledError}. r� Nc s | � d< �S rI r r �Z dCanceledr r r r � s zCDeferredAddTimeoutTests.test_cancelBeforeTimeout.<locals>.onErrbackr r� )r r rV r r! r� r� r r r1 rz r r r� �r( r� r� r r r, r �test_cancelBeforeTimeout s z0DeferredAddTimeoutTests.test_cancelBeforeTimeoutc s� t � }t�� }|jd|td� t�� �dg� � �fdd�}|�|� |�� | �� d tj � | � � d j tj � |� d� | ��� dS )a2 If the L{defer.Deferred} is manually cancelled before the timeout, it is not re-cancelled (no L{AlreadyCancelled} error, and also no canceling of inner deferreds), and the custom C{onTimeoutCancel} function is not called, preserving the original L{CancelledError}. r� r Nc s | � d< �S rI r r r, r r r � s zIDeferredAddTimeoutTests.test_cancelBeforeTimeoutCustom.<locals>.onErrbackr r� )r r rV r r r! r� r� r r r1 rz r r r� r- r r, r � test_cancelBeforeTimeoutCustom� s z6DeferredAddTimeoutTests.test_cancelBeforeTimeoutCustomc C sN t � }t�dd� �}|jd|td� | �|� |�d� | �d| �|�� dS )z{ A custom translation function can handle a L{defer.Deferred} with a custom cancellation function. c S s | � td��S )Nr) )rk r� r� r r r r� � r� zVDeferredAddTimeoutTests.test_providedCancelCalledBeforeTimeoutCustom.<locals>.<lambda>r� r r� r Nr% r# r r r �,test_providedCancelCalledBeforeTimeoutCustom� s zDDeferredAddTimeoutTests.test_providedCancelCalledBeforeTimeoutCustomc sx t � }t�� }dg� � fdd�}|�|� |�d|� |�d� | �� d tj� | �� d j tj � | � |tj � dS )a An errback added before a timeout is added errbacks with a L{defer.CancelledError} when the timeout fires. If the errback returns the L{defer.CancelledError}, it is translated to a L{defer.TimeoutError} by the timeout implementation. Nc s | � d< | S rI r r �r r r rk � s zGDeferredAddTimeoutTests.test_errbackAddedBeforeTimeout.<locals>.errbackr� r� r ) r r rV r! r r r� r r r' r r� r� �r( r� r� rk r r1 r � test_errbackAddedBeforeTimeout� s z6DeferredAddTimeoutTests.test_errbackAddedBeforeTimeoutc st t � }t�� }dg� � fdd�}|�|� |�d|� |�d� | �� d tj� | �� d j tj � | � |� dS )z� An errback added before a timeout is added errbacks with a L{defer.CancelledError} when the timeout fires. If the errback suppresses the L{defer.CancelledError}, the deferred successfully completes. Nc s | � d< | � tj� d S rI )r6 r r r r1 r r rk � s z]DeferredAddTimeoutTests.test_errbackAddedBeforeTimeoutSuppressesCancellation.<locals>.errbackr� r� r ) r r rV r! r r r� r r r' r r� r2 r r1 r �4test_errbackAddedBeforeTimeoutSuppressesCancellation� s zLDeferredAddTimeoutTests.test_errbackAddedBeforeTimeoutSuppressesCancellationc s~ t � }t�� }dg� � fdd�}|�|� |�d|t� |�d� | �� d tj � | �� d j tj � | � d| � |�� dS )a An errback added before a timeout is added with a custom timeout function errbacks with a L{defer.CancelledError} when the timeout fires. The timeout function runs if the errback returns the L{defer.CancelledError}. Nc s | � d< | S rI r r r1 r r rk s zMDeferredAddTimeoutTests.test_errbackAddedBeforeTimeoutCustom.<locals>.errbackr� r� r r �r r rV r! r r r r� r r r' r r# r� r2 r r1 r �$test_errbackAddedBeforeTimeoutCustom s z<DeferredAddTimeoutTests.test_errbackAddedBeforeTimeoutCustomc s~ t � }t�� }dg� � fdd�}|�|� |�d|t� |�d� | �� d tj � | �� d j tj � | � d| � |�� dS )a An errback added before a timeout is added with a custom timeout function errbacks with a L{defer.CancelledError} when the timeout fires. The timeout function runs if the errback suppresses the L{defer.CancelledError}. Nc s | � d< d S rI r r r1 r r rk . s zcDeferredAddTimeoutTests.test_errbackAddedBeforeTimeoutSuppressesCancellationCustom.<locals>.errbackr� r� r r r5 r2 r r1 r �:test_errbackAddedBeforeTimeoutSuppressesCancellationCustom" s zRDeferredAddTimeoutTests.test_errbackAddedBeforeTimeoutSuppressesCancellationCustomc st t � }d�t��fdd��}dg� � fdd�}|�|� |�d|� |�d� | �� d �� | ��| �|�� dS ) a* Given a deferred with a cancellation function that resumes the callback chain, a callback that is added to the deferred before a timeout is added to runs when the timeout fires. The deferred completes successfully, without a L{defer.TimeoutError}. r� c s | � � �S r7 r r� r� r r r� F r� zSDeferredAddTimeoutTests.test_callbackAddedToCancelerBeforeTimeout.<locals>.<lambda>Nc s | � d< | S rI r �r' �r r r r J s zSDeferredAddTimeoutTests.test_callbackAddedToCancelerBeforeTimeout.<locals>.callbackr� r� r ) r r rV rW r r r# r1 r� �r( r� r� r r �r r� r �)test_callbackAddedToCancelerBeforeTimeout< s zADeferredAddTimeoutTests.test_callbackAddedToCancelerBeforeTimeoutc sx t � }d�t��fdd��}dg� � fdd�}|�|� |jd|td� |�d � | �� d �� | �d | �|�� dS ) ad Given a deferred with a cancellation function that resumes the callback chain, a callback that is added to the deferred before a timeout is added to runs when the timeout fires. The deferred completes successfully, without a L{defer.TimeoutError}. The timeout's custom timeout function also runs. r� c s | � � �S r7 r r� r� r r r� c r� zYDeferredAddTimeoutTests.test_callbackAddedToCancelerBeforeTimeoutCustom.<locals>.<lambda>Nc s | � d< | S rI r r8 r9 r r r g s zYDeferredAddTimeoutTests.test_callbackAddedToCancelerBeforeTimeoutCustom.<locals>.callbackr� r r� r r ) r r rV rW r r r r# r� r: r r; r �/test_callbackAddedToCancelerBeforeTimeoutCustomX s zGDeferredAddTimeoutTests.test_callbackAddedToCancelerBeforeTimeoutCustomN)r r r r, r r r r! r" r$ r& r( r+ r. r/ r0 r3 r4 r6 r7 r< r= r r r r r � s& !""#"" r c @ s e Zd ZdZdd� Zdd� ZdS )�EnsureDeferredTestsz= Tests for L{twisted.internet.defer.ensureDeferred}. c C s" t �� }t �|�}| �||� dS )zQ L{defer.ensureDeferred} will pass through a Deferred unchanged. N)r rV �ensureDeferredr1 r� r r r �test_passesThroughDeferreds{ s z/EnsureDeferredTests.test_passesThroughDeferredsc C s$ | � t�� t�d� W 5 Q R X dS )zx Passing L{defer.ensureDeferred} a non-coroutine and a non-Deferred will raise a L{ValueError}. Z somethingN)rq r� r r? rG r r r �'test_willNotAllowNonDeferredOrCoroutine� s z;EnsureDeferredTests.test_willNotAllowNonDeferredOrCoroutineN)r r r r, r@ rA r r r r r> v s r> c @ s e Zd ZdZdd� ZdS )�TimeoutErrorTestsz1 L{twisted.internet.defer} timeout code. c C sj t �� }t �|� | �|t j� | �| jg�}| �t|�d� | � |d d t � | �|d d d� dS )zB L{twisted.internet.defer.timeout} is deprecated. r r r* r+ z~twisted.internet.defer.timeout was deprecated in Twisted 17.1.0; please use twisted.internet.defer.Deferred.addTimeout insteadN) r rV r� r� r� r, �test_deprecatedTimeoutr# r$ r1 r- )r( r Z warningsShownr r r rC � s �z(TimeoutErrorTests.test_deprecatedTimeoutN)r r r r, rC r r r r rB � s rB c C s | � | j� | �� dS )z� Tickle an asyncio event loop to call all of the things scheduled with call_soon, inasmuch as this can be done via the public API. @param loop: The asyncio event loop to flush the previously-called C{call_soon} entries from. N)Z call_soon�stopZ run_forever��loopr r r �callAllSoonCalls� s rG c @ sH e Zd ZeZdd� Zdd� Zdd� Zdd� Zd d � Z d d � Z d d� Z dS )�DeferredFutureAdapterTestsc C s` t �� }t� }|�|�}| �|�� d� |�d� t|� | �| �|�d� | �|� � d� dS )z� L{defer.Deferred.asFuture} returns a L{asyncio.Future} which fires when the given L{defer.Deferred} does. Fre N) r rV r �asFuturer# r� r rG r� r3 �r( r� rF �aFuturer r r � test_asFuture� s z(DeferredFutureAdapterTests.test_asFuturec sn � fdd�� d� _ t�� �}t� }|�|�}|�� t|� | �� j d� | �| �|�d� | � t |j � dS )z� L{defer.Deferred.asFuture} returns a L{asyncio.Future} which, when cancelled, will cancel the original L{defer.Deferred}. c s d� _ d S ri r �Zdprime��cancelerr r rO � s zFDeferredFutureAdapterTests.test_asFutureCancelFuture.<locals>.cancelerFTN) r r rV r rI r� rG r# r� rq r r3 rJ r rN r �test_asFutureCancelFuture� s z4DeferredFutureAdapterTests.test_asFutureCancelFuturec C sV dd� }t �|�}t� }|�|�}|�� t|� | �| �|�d� | �t |j � dS )z� While Futures don't support succeeding in response to cancellation, Deferreds do; if a Deferred is coerced into a success by a Future cancellation, that should just be ignored. c S s | � d� d S )Nrf r rM r r r rO � s zGDeferredFutureAdapterTests.test_asFutureSuccessCancel.<locals>.cancelerN) r rV r rI r� rG r# r� rq r r3 )r( rO r� rF rK r r r �test_asFutureSuccessCancel� s z5DeferredFutureAdapterTests.test_asFutureSuccessCancelc C sP t �� }t�t� �}t� }|�|�}t|� |�|� t|� | � t|j � dS )z� L{defer.Deferred.asFuture} makes a L{asyncio.Future} fire with an exception when the given L{defer.Deferred} does. N) r rV r r r� r rI rG rk rq r3 )r( r� Z theFailurerF Zfuturer r r �test_asFutureFailure� s z/DeferredFutureAdapterTests.test_asFutureFailurec C sN t � }t|d�}tj�|�}| �|� |�d� t|� | �| � |�d� dS )z� L{defer.Deferred.fromFuture} returns a L{defer.Deferred} that fires when the given L{asyncio.Future} does. rE � N) r r r rV � fromFuturer� Z set_resultrG r# r� )r( rF rK r� r r r �test_fromFuture� s z*DeferredFutureAdapterTests.test_fromFuturec C sN t � }t|d�}tj�|�}|�� t|� | �t|j � | � |�� t� dS )z� L{defer.Deferred.fromFuture} makes a L{defer.Deferred} fire with an L{asyncio.CancelledError} when the given L{asyncio.Future} is cancelled. rE N) r r r rV rT r� rG rq r r3 r� r6 �r( rF � cancelledr� r r r � test_fromFutureFutureCancelled s z9DeferredFutureAdapterTests.test_fromFutureFutureCancelledc C s^ t � }t|d�}tj�|�}|�� t|� | �|�� d� | � t |j � | � |�� t � dS )z� L{defer.Deferred.fromFuture} makes a L{defer.Deferred} which, when cancelled, cancels the L{asyncio.Future} it was created from. rE TN)r r r rV rT r� rG r# rW rq r r3 r� r6 rV r r r � test_fromFutureDeferredCancelled s z;DeferredFutureAdapterTests.test_fromFutureDeferredCancelledN) r r r � asyncSkip�skiprL rP rQ rR rU rX rY r r r r rH � s rH )0r, Z __future__r r r4 r� r= r. Ztwisted.python.compatr Zasyncior r r rZ Ztwisted.pythonr r Ztwisted.internetr r Ztwisted.internet.taskr Z twisted.trialr r r r r r� r ZTestCaser- ZSynchronousTestCaser@ ra rh r� r� r� r� r� r r r> rB rG rH r r r r �<module> sf . $D ! s S
Save File
Cancel