HEX
Server: Apache/2.4.52 (Ubuntu)
System: Linux spn-python 5.15.0-89-generic #99-Ubuntu SMP Mon Oct 30 20:42:41 UTC 2023 x86_64
User: arjun (1000)
PHP: 8.1.2-1ubuntu2.20
Disabled: NONE
$ pwd: /usr/lib/python3/dist-packages/twisted/test/__pycache__/
Upload Files
File: //usr/lib/python3/dist-packages/twisted/test/__pycache__/ignore_test_failure.cpython-310.pyc
o

^h�b�z�@s0dZddlZddlZddlZddlZddlZddlmZddlmZddl	m
Z
ddlmZddl
mZmZddlmZd	d
�ZGdd�de�ZGd
d�de�ZGdd�de�ZGdd�deed�ZGdd�de�ZGdd�de�Zdd�ZGdd�de�ZGdd�de�ZGdd�de�ZGd d!�d!e�ZdS)"z6
Test cases for the L{twisted.python.failure} module.
�N)�StringIO��FrameSummary)�skipIf)�raiser)�failure�reflect)�SynchronousTestCasecOs4zddW|Stytj|i|��}Y|Sw)z�
    Make a C{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)�
BaseExceptionr�Failure)�args�kwargs�f�r�B/usr/lib/python3/dist-packages/twisted/test/ignore_test_failure.py�getDivisionFailures
��rc@seZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dd�Z
dBdd�ZdCdd�ZdCdd�Z
dd�Zdd�Zdd�Zdd�Zdd �Zd!d"�Zd#d$�Zd%d&�Zd'd(�Zd)d*�Zd+d,�Zd-d.�Zd/d0�Zd1d2�Zd3d4�Zd5d6�Zd7d8�Zd9d:�Zd;d<�Z d=d>�Z!d?d@�Z"dAS)D�FailureTestsz'
    Tests for L{failure.Failure}.
    cCsNztd��tyt��}Ynw|�tt�}|�|t�|�|jt�dS)z(
        Trapping a L{Failure}.
        �testN)	�NotImplementedErrorrrr�trap�
SystemExit�RuntimeError�assertEqual�type)�selfr�errorrrr�test_failAndTrap+s�zFailureTests.test_failAndTrapcCsFt�}z|�tyt��}Ynw|�t|jt�}|�||�dS)z�
        If the wrapped C{Exception} is not a subclass of one of the
        expected types, L{failure.Failure.trap} raises the wrapped
        C{Exception}.
        N)�
ValueErrorrrr�assertRaisesr�
OverflowError�assertIs)r�	exceptionr�	untrappedrrr�test_trapRaisesWrappedException7s�z,FailureTests.test_trapRaisesWrappedExceptioncCs,t�}t�|�}t�|�}|�|j|�dS)z�
        A L{failure.Failure} constructed from another
        L{failure.Failure} instance, has its C{value} property set to
        the value of that L{failure.Failure} instance.
        N)rrrr!�value�rr"�f1�f2rrr�test_failureValueFromFailureFs

z)FailureTests.test_failureValueFromFailurecCsLt�}t�|�}z|�t�Wn
tyt��}Ynw|�|j|�dS)z�
        A L{failure.Failure} constructed without a C{exc_value}
        argument, will search for an "original" C{Failure}, and if
        found, its value will be used as the value for the new
        C{Failure}.
        N)rrrrr rr!r%r&rrr�!test_failureValueFromFoundFailureQs
�z.FailureTests.test_failureValueFromFoundFailurecC� |�|�|�|�d|���dS)z�
        Assert that C{s} starts with a particular C{prefix}.

        @param s: The input string.
        @type s: C{str}
        @param prefix: The string that C{s} should start with.
        @type prefix: C{str}
        z is not the start of N)�
assertTrue�
startswith)r�s�prefixrrr�assertStartsWitha� 	zFailureTests.assertStartsWithcCr+)z�
        Assert that C{s} end with a particular C{suffix}.

        @param s: The input string.
        @type s: C{str}
        @param suffix: The string that C{s} should end with.
        @type suffix: C{str}
        z is not the end of N)r,�endswith)rr.�suffixrrr�assertEndsWithlr1zFailureTests.assertEndsWithcCs|�||�|�||�dS)ac
        Assert that the C{tb} traceback contains a particular C{prefix} and
        C{suffix}.

        @param tb: The traceback string.
        @type tb: C{str}
        @param prefix: The string that C{tb} should start with.
        @type prefix: C{str}
        @param suffix: The string that C{tb} should end with.
        @type suffix: C{str}
        N)r0r4)r�tbr/r3rrr�assertTracebackFormatwsz"FailureTests.assertTracebackFormatFcCs�|rd}|t|d�}t�}|r|��|�|�|��}d|j|jr%dp&df}d�t�	|j
�t�|j�|j�}|�
|||�dd�|��D�}	|r`|�g|	�|rVd	}
nd
}
|�|
|	�dS|�g|	�|�d|�dS)
a�
        Assert that L{printDetailedTraceback} produces and prints a detailed
        traceback.

        The detailed traceback consists of a header::

          *--- Failure #20 ---

        The body contains the stacktrace::

          /twisted/trial/_synctest.py:1180: _run(...)
          /twisted/python/util.py:1076: runWithWarningsSuppressed(...)
          --- <exception caught here> ---
          /twisted/test/test_failure.py:39: getDivisionFailure(...)

        If C{captureVars} is enabled the body also includes a list of
        globals and locals::

           [ Locals ]
             exampleLocalVar : 'xyz'
             ...
           ( Globals )
             ...

        Or when C{captureVars} is disabled::

           [Capture of Locals and Globals disabled (use captureVars=True)]

        When C{cleanFailure} is enabled references to other objects are removed
        and replaced with strings.

        And finally the footer with the L{Failure}'s value::

          exceptions.ZeroDivisionError: float division
          *--- End of Failure #20 ---

        @param captureVars: Enables L{Failure.captureVars}.
        @type captureVars: C{bool}
        @param cleanFailure: Enables L{Failure.cleanFailure}.
        @type cleanFailure: C{bool}
        �xyz��captureVarsz*--- Failure #%d%s---
z (pickled) � z#{}: {}
*--- End of Failure #{} ---
cSsg|]	}|�d�r|�qS)z  )r-)�.0�linerrr�
<listcomp>�sz8FailureTests.assertDetailedTraceback.<locals>.<listcomp>z  exampleLocalVar : "'xyz'"z  exampleLocalVar : 'xyz'zA [Capture of Locals and Globals disabled (use captureVars=True)]
N)rr�cleanFailure�printDetailedTraceback�getvalue�count�pickled�formatr�qualr�safe_strr%r6�
splitlines�assertNotEqual�assertInr)rr9r>�exampleLocalVarr�outr5�start�end�
linesWithVarsr<rrr�assertDetailedTraceback�s>*

�

��z$FailureTests.assertDetailedTracebackc
Cs�|rd}|t�}t�}|�|�|��}d}|jD]\}}}	}
}||�d|	�d|�d�7}qtt�}|�|d|�d�tj	�d|���|rQ|�
t�d|��dSdS)	a`
        Assert that L{printBriefTraceback} produces and prints a brief
        traceback.

        The brief traceback consists of a header::

          Traceback: <type 'exceptions.ZeroDivisionError'>: float division

        The body with the stacktrace::

          /twisted/trial/_synctest.py:1180:_run
          /twisted/python/util.py:1076:runWithWarningsSuppressed

        And the footer::

          --- <exception caught here> ---
          /twisted/test/test_failure.py:39:getDivisionFailure

        @param captureVars: Enables L{Failure.captureVars}.
        @type captureVars: C{bool}
        �abcde��:�
zTraceback: z: zexampleLocalVar.*abcdeN)
rr�printBriefTracebackr@�frames�repr�ZeroDivisionErrorr6r�EXCEPTION_CAUGHT_HERE�assertIsNone�re�search)
rr9rIrrJr5�stack�method�filename�lineno�	localVars�
globalVars�zderrr�assertBriefTraceback�s&

��z!FailureTests.assertBriefTracebackcCs�|rd}|t|d�}t�}|�|�|��}d}|jD]#\}}}	}
}|d|�d|	�d|�d�7}|dt�||	����d�7}q|�|d	d
t	j
|t�|j
�t�|j�f�|rc|�t�d|��dSdS)
a�
        Assert that L{printTraceback} produces and prints a default traceback.

        The default traceback consists of a header::

          Traceback (most recent call last):

        The body with traceback::

          File "/twisted/trial/_synctest.py", line 1180, in _run
             runWithWarningsSuppressed(suppress, method)

        And the footer::

          --- <exception caught here> ---
            File "twisted/test/test_failure.py", line 39, in getDivisionFailure
              1 / 0
            exceptions.ZeroDivisionError: float division

        @param captureVars: Enables L{Failure.captureVars}.
        @type captureVars: C{bool}
        �xyzzyr8rPz  File "z", line z, in rRz    z"Traceback (most recent call last):z%s
%s%s: %s
zexampleLocalVar.*xyzzyN)rr�printTracebackr@rT�	linecache�getline�stripr6rrWrrDrrEr%rXrYrZ)rr9rIrrJr5r[r\r]r^r_r`rrr�assertDefaultTracebacks2



����z#FailureTests.assertDefaultTracebackcC�|��dS)zr
        L{printDetailedTraceback} returns a detailed traceback including the
        L{Failure}'s count.
        N�rN�rrrr�test_printDetailedTraceback<sz(FailureTests.test_printDetailedTracebackcCri)zC
        L{printBriefTraceback} returns a brief traceback.
        N�rbrkrrr�test_printBriefTracebackC�z%FailureTests.test_printBriefTracebackcCri)z8
        L{printTraceback} returns a traceback.
        N�rhrkrrr�test_printTracebackIroz FailureTests.test_printTracebackcC�|jdd�dS)z�
        L{printDetailedTraceback} captures the locals and globals for its
        stack frames and adds them to the traceback, when called on a
        L{Failure} constructed with C{captureVars=True}.
        Tr8Nrjrkrrr�'test_printDetailedTracebackCapturedVarsOsz4FailureTests.test_printDetailedTracebackCapturedVarscCrr)z�
        L{printBriefTraceback} returns a brief traceback when called on a
        L{Failure} constructed with C{captureVars=True}.

        Local variables on the stack can not be seen in the resulting
        traceback.
        Tr8Nrmrkrrr�$test_printBriefTracebackCapturedVarsW�z1FailureTests.test_printBriefTracebackCapturedVarscCrr)z�
        L{printTraceback} returns a traceback when called on a L{Failure}
        constructed with C{captureVars=True}.

        Local variables on the stack can not be seen in the resulting
        traceback.
        Tr8Nrprkrrr�test_printTracebackCapturedVarsaruz,FailureTests.test_printTracebackCapturedVarscCs|jddd�dS)z�
        C{printDetailedTraceback} includes information about local variables on
        the stack after C{cleanFailure} has been called.
        T)r9r>Nrjrkrrr�.test_printDetailedTracebackCapturedVarsCleanedksz;FailureTests.test_printDetailedTracebackCapturedVarsCleanedcCs|jttjdddd�dS)zu
        L{failure.format_frames} raises a L{ValueError} if the supplied
        C{detail} level is unknown.
        N�noisia��detail)rrr�
format_framesrkrrr�test_invalidFormatFramesDetailrs
�z+FailureTests.test_invalidFormatFramesDetailcCs,t�}t�|�}|�t�|�|j|�dS�N)rrrrrr%)r�errrr�test_ExplictPass{s

zFailureTests.test_ExplictPasscCsDz	|��Wtd��ty!t�t��d�}|ddYSw)N����z3f.raiseException() didn't raise ZeroDivisionError!?)�raiseExceptionrV�	traceback�
extract_tb�sys�exc_info�	Exception)rrr5rrr�_getInnermostFrameLine�s
��z#FailureTests._getInnermostFrameLinecCs t�}|�|�}|�|d�dS)N�1 / 0)rr�r)rr�	innerlinerrr�test_RaiseExceptionWithTB�s
z&FailureTests.test_RaiseExceptionWithTBcCs$|�ttjd�}|�dt|��dS)z�
        Constructing a C{Failure} with a string as its exception value raises
        a C{TypeError}, as this is no longer supported as of Python 2.6.
        zono!z$Strings are not supported by FailureN)r�	TypeErrorrrrH�str)r�excrrr� test_stringExceptionConstruction�sz-FailureTests.test_stringExceptionConstructioncCs|�tjtj�dS)z�
        Creating a Failure with no arguments causes it to try to discover the
        current interpreter exception state.  If no such state exists, creating
        the Failure should raise a synchronous exception.
        N)rr�NoCurrentExceptionErrorrrkrrr�test_ConstructionFails�sz#FailureTests.test_ConstructionFailscCst�}|�|��|j�dS)z�
        If the C{Failure} has not been cleaned, then C{getTracebackObject}
        returns the traceback object that captured in its constructor.
        N)rr�getTracebackObjectr5�rrrrr�test_getTracebackObject�sz$FailureTests.test_getTracebackObjectcCsJzddWntyt��}tjdd�}Ynw|�|��|j�dS)zc
        C{captureVars=True} has no effect on the result of
        C{getTracebackObject}.
        r
rTr8N)rVrrrr�r5)r�
noVarsFailure�varsFailurerrr�&test_getTracebackObjectFromCaptureVars�s�z3FailureTests.test_getTracebackObjectFromCaptureVarscCsDt�}t�|���}|��t�|���}|�|�|�||�dS)z�
        If the Failure has been cleaned, then C{getTracebackObject} returns an
        object that looks the same to L{traceback.extract_tb}.
        N)rr�r�r�r>�assertIsNotNoner�rr�expected�observedrrr� test_getTracebackObjectFromClean�s
z-FailureTests.test_getTracebackObjectFromCleancCs>tdd�}t�|���}|��t�|���}|�||�dS)z�
        If the Failure was created with captureVars, then C{getTracebackObject}
        returns an object that looks the same to L{traceback.extract_tb}.
        Tr8N)rr�r�r�r>rr�rrr�.test_getTracebackObjectFromCaptureVarsAndClean�s

z;FailureTests.test_getTracebackObjectFromCaptureVarsAndCleancCs t�td��}|�|���dS)a
        L{failure.Failure}s need not be constructed with traceback objects. If
        a C{Failure} has no traceback information at all, C{getTracebackObject}
        just returns None.

        None is a good value, because traceback.extract_tb(None) -> [].
        z
some errorN)rrr�rXr�r�rrr�'test_getTracebackObjectWithoutTraceback�sz4FailureTests.test_getTracebackObjectWithoutTracebackcCsJzddWntyt��\}}}Ynwt�|�}|�|j|�dS)z�
        If a L{failure.Failure} is constructed with an exception but no
        traceback in Python 3, the traceback will be extracted from the
        exception's C{__traceback__} attribute.
        r
rN)rr�r�rrr!r5)r�klassr"r5rrrr�$test_tracebackFromExceptionInPython3�s�
z1FailureTests.test_tracebackFromExceptionInPython3cCs>t�}|�|j�|�|jj|j�|��|�|jj�dS)z�
        L{failure.Failure.cleanFailure} sets the C{__traceback__} attribute of
        the exception to L{None} in Python 3.
        N)rr�r5r!r%�
__traceback__r>rXr�rrr�*test_cleanFailureRemovesTracebackInPython3�s
z7FailureTests.test_cleanFailureRemovesTracebackInPython3cCs*t�}t�t�}|�t|�d|f�dS)z�
        The C{repr} of a L{failure.Failure} shows the type and string
        representation of the underlying exception.
        z5<twisted.python.failure.Failure %s: division by zero>N)rr�fullyQualifiedNamerVrrU)rr�typeNamerrr�	test_repr�s
�zFailureTests.test_reprN)FF)F)#�__name__�
__module__�__qualname__�__doc__rr$r)r*r0r4r6rNrbrhrlrnrqrsrtrvrwr|rr�r�r�r�r�r�r�r�r�r�r�r�rrrrr&sB

S
.5

		
rc@�eZdZdZdefdd�ZdS)�	BrokenStrzb
    An exception class the instances of which cannot be presented as strings
    via L{str}.
    �returncCs|�r}rrkrrr�__str__szBrokenStr.__str__N�r�r�r�r�r�r�rrrrr���r�c@r�)�BrokenExceptionMetaclassza
    A metaclass for an exception type which cannot be presented as a string via
    L{str}.
    r�cCstd��)Nz#You cannot make a string out of me.)rrkrrrr�sz BrokenExceptionMetaclass.__str__Nr�rrrrr�r�r�c@seZdZdZdS)�BrokenExceptionTypeza
    The aforementioned exception type which cannot be presented as a string via
    L{str}.
    N)r�r�r�r�rrrrr�sr�)�	metaclassc@sPeZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dd�Z
dd�ZdS)�GetTracebackTestsz,
    Tests for L{Failure.getTraceback}.
    cCs,t�}t�|�}|j|d�}|�|t�dS)z�
        Construct a L{Failure} with an exception that raises an exception from
        its C{__str__} method and then call C{getTraceback} with the specified
        detail and verify that it returns a string.
        ryN)r�rr�getTraceback�assertIsInstancer�)rrz�xrr�rrr�_brokenValueTests
z"GetTracebackTests._brokenValueTestcC�|�d�dS)z�
        A L{Failure} might wrap an exception with a C{__str__} method which
        raises an exception.  In this case, calling C{getTraceback} on the
        failure with the C{"brief"} detail does not raise an exception.
        �briefN�r�rkrrr�test_brokenValueBriefDetail'sz-GetTracebackTests.test_brokenValueBriefDetailcCr�)�Y
        Like test_brokenValueBriefDetail, but for the C{"default"} detail case.
        �defaultNr�rkrrr�test_brokenValueDefaultDetail/�z/GetTracebackTests.test_brokenValueDefaultDetailcCr�)r��verboseNr�rkrrr�test_brokenValueVerboseDetail5r�z/GetTracebackTests.test_brokenValueVerboseDetailcCs(t�t��}|j|d�}|�|t�dS)z�
        Construct a L{Failure} with an exception type that raises an exception
        from its C{__str__} method and then call C{getTraceback} with the
        specified detail and verify that it returns a string.
        ryN)rrr�r�r�r�)rrzrr�rrr�_brokenTypeTest;sz!GetTracebackTests._brokenTypeTestcCr�)a
        A L{Failure} might wrap an exception the type object of which has a
        C{__str__} method which raises an exception.  In this case, calling
        C{getTraceback} on the failure with the C{"brief"} detail does not raise
        an exception.
        r�N�r�rkrrr�test_brokenTypeBriefDetailEsz,GetTracebackTests.test_brokenTypeBriefDetailcCr�)zX
        Like test_brokenTypeBriefDetail, but for the C{"default"} detail case.
        r�Nr�rkrrr�test_brokenTypeDefaultDetailNr�z.GetTracebackTests.test_brokenTypeDefaultDetailcCr�)zX
        Like test_brokenTypeBriefDetail, but for the C{"verbose"} detail case.
        r�Nr�rkrrr�test_brokenTypeVerboseDetailTr�z.GetTracebackTests.test_brokenTypeVerboseDetailN)r�r�r�r�r�r�r�r�r�r�r�r�rrrrr�s
	r�c@sFeZdZdZdd�Zdd�Zdd�Zdd	�Zee	d
ud�dd
��Z
d
S)�FindFailureTestszE
    Tests for functionality related to L{Failure._findFailure}.
    cCs@zddWnty|�tj���YdSw|�d�dS)z�
        Within an exception handler, _findFailure should return
        L{None} in case no Failure is associated with the current
        exception.
        r
rzNo exception raised from 1/0!?N)rrXrr�_findFailure�failrkrrr�$test_findNoFailureInExceptionHandler`s�z5FindFailureTests.test_findNoFailureInExceptionHandlercCs&|�t��d�|�tj���dS)zS
        Outside of an exception handler, _findFailure should return None.
        r�N)rXr�r�rrr�rkrrr�test_findNoFailuremsz#FindFailureTests.test_findNoFailurecCsPt�}|��z|��Wnty |�tj��|�YdSw|�d�dS)z�
        Within an exception handler, it should be possible to find the
        original Failure that caused the current exception (if it was
        caused by raiseException).
        �)No exception raised from raiseException!?N)	rr>r�rrrrr�r�r�rrr�test_findFailurets�z!FindFailureTests.test_findFailurec	Cs�t�}|��z|��Wn.ty;t��}|����}|����}|�||�|�	|dd�|dd��YdSw|�
d�dS)ax
        When a Failure is constructed in the context of an exception
        handler that is handling an exception raised by
        raiseException, the new Failure should be chained to that
        original Failure.
        Means the new failure should still show the same origin frame,
        but with different complete stack trace (as not thrown at same place).
        ���Nr�)rr>r�rrrr�rFrGrr�)rr�newFr5�new_tbrrr�,test_failureConstructionFindsOriginalFailure�s	"�z=FindFailureTests.test_failureConstructionFindsOriginalFailureNzraiser extension not availablecCsLzt��Wntjyt��}|�|�tj��YdSw|�d�dS)z�
        Pyrex and Cython are known to insert fake stack frames so as to give
        more Python-like tracebacks. These stack frames with empty code objects
        should not break extraction of the exception.
        z$No exception raised from extension?!N)rr��RaiserExceptionrrr,�checkr�r�rrr�/test_failureConstructionWithMungedStackSucceeds�s�z@FindFailureTests.test_failureConstructionWithMungedStackSucceeds)r�r�r�r�r�r�r�r�rrr�rrrrr�[s
r�cCst|||�Sr}r)�fnr^�name�textrrr�_tb�sr�c@s eZdZdZdd�Zdd�ZdS)�FormattableTracebackTestsa
    Whitebox tests that show that L{failure._Traceback} constructs objects that
    can be used by L{traceback.extract_tb}.

    If the objects can be used by L{traceback.extract_tb}, then they can be
    formatted using L{traceback.format_tb} and friends.
    cCs:t�gdddiigg�}|�t�|�tdddd�g�dS)z�
        A C{_Traceback} object constructed with a single frame should be able
        to be passed to L{traceback.extract_tb}, and we should get a singleton
        list containing a (filename, lineno, methodname, line) tuple.
        r\�filename.py�{N)r�
_Tracebackrr�r�r��rr5rrr�test_singleFrame�s�z*FormattableTracebackTests.test_singleFramec
Cs�t�dddiigdddiiggdddiigddd	iigg�}|�t�|�tdddd
�tdd	dd
�g�|�t�|j�tdddd
�tdddd
�tdddd
�g�d
S)z�
        A C{_Traceback} object constructed with multiple frames should be able
        to be passed to L{traceback.extract_tb}, and we should get a list
        containing a tuple for each frame.
        �caller1r���caller2��method1r��method2��N)rr�rr�r�r��
extract_stack�tb_framer�rrr�test_manyFrames�s*���
��	
��z)FormattableTracebackTests.test_manyFramesN)r�r�r�r�r�r�rrrrr��sr�c@seZdZdZdd�ZdS)�FrameAttributesTestszq
    _Frame objects should possess some basic attributes that qualify them as
    fake python Frame objects.
    cCs<t�dd�}|�|jt�|�|jt�|�|jtj�dS)z�
        L{_Frame} instances have the C{f_globals} and C{f_locals} attributes
        bound to C{dict} instance.  They also have the C{f_code} attribute
        bound to something like a code object.
        )�	dummyname�
dummyfilenameNNNN)r�_Framer��	f_globals�dict�f_locals�f_code�_Code)r�framerrr�test_fakeFrameAttributes�sz-FrameAttributesTests.test_fakeFrameAttributesN)r�r�r�r�r�rrrrr��sr�c@s(eZdZdZdd�Zdd�Zdd�ZdS)	�DebugModeTestszF
    Failure's debug mode should allow jumping into the debugger.
    csBtj�tjj���fdd�}|�|�g|_|jjt_t��dS)zK
        Override pdb.post_mortem so we can make sure it's called.
        cs�t_�tj_dSr})�pdb�post_mortemrr�__init__r��origInitr�rr�restore
sz%DebugModeTests.setUp.<locals>.restoreN)	r�r�rrr��
addCleanup�result�append�startDebugMode)rr�rr�r�setUps

zDebugModeTests.setUpcCsVzddWntyt��\}}}t��}Ynw|�|j|g�|�|j�dS)z~
        If startDebugMode() is called, calling Failure() will first call
        pdb.post_mortem with the traceback.
        r
rN)	rr�r�rrrr��assertFalser9�r�typr�r5rrrr�test_regularFailures�z"DebugModeTests.test_regularFailurecCsZzddWntyt��\}}}tjdd�}Ynw|�|j|g�|�|j�dS)zk
        If startDebugMode() is called, passing captureVars to Failure() will
        not blow up.
        r
rTr8N)	rr�r�rrrr�r,r9rrrr�test_captureVars!s�zDebugModeTests.test_captureVarsN)r�r�r�r�r�rrrrrrr��s

r�c@s@eZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dS)�ExtendedGeneratorTestszU
    Tests C{failure.Failure} support for generator features added in Python 2.5
    cCs2z|�|�Wn
tyYdSw|�d�dS)Nz<throwExceptionIntoGenerator should have raised StopIteration)�throwExceptionIntoGenerator�
StopIterationr�)rr�grrr�_throwIntoGenerator4s�z*ExtendedGeneratorTests._throwIntoGeneratorcs�g���fdd�}|�}t�}t|���||����ddt����ddt���t��dd�ddd�dS)	zr
        It should be possible to throw the exception that a Failure
        represents into a generator.
        c3s>�zdVWnty��t���YdSw��d�dS)Nz$Yield should have yielded exception.)rr�r�r�r�r�r�stuffrr�	generatorC��
�zJExtendedGeneratorTests.test_throwExceptionIntoGenerator.<locals>.generatorrr
r�r�r�N)r�nextr	rrVr�r�r��rrrrrr
r� test_throwExceptionIntoGenerator<s&z7ExtendedGeneratorTests.test_throwExceptionIntoGeneratorcsLt�}|��g���fdd�}|�}t|���||����|g�dS)z�
        Within an exception handler, it should be possible to find the
        original Failure that caused the current exception (if it was
        caused by throwExceptionIntoGenerator).
        c3s@�zdVWnty��tj���YdSw��d�dS�NzNo exception sent to generator)rr�rrr�r�r��
foundFailuresrrrr_s�
�zEExtendedGeneratorTests.test_findFailureInGenerator.<locals>.generatorN)rr>rr	r)rrrrrrr�test_findFailureInGeneratorUsz2ExtendedGeneratorTests.test_findFailureInGeneratorcs�t�}|��|��}g���fdd�}|�}t|���||���t��d���||������d��|�����d�d�����	d|���dS)z�
        When a Failure is constructed in the context of an exception
        handler that is handling an exception raised by
        throwExceptionIntoGenerator, the new Failure should be chained to that
        original Failure.
        c3s>�zdVWnty��t���YdSw��d�dSr)rr�rrr�r��newFailuresrrrrzr
zVExtendedGeneratorTests.test_failureConstructionFindsOriginalFailure.<locals>.generatorr
rrN)
rr>r�rr	r�lenrGrH�assertNotIn)rr�original_failure_strrrrrrr�mszCExtendedGeneratorTests.test_failureConstructionFindsOriginalFailurecs0�fdd�}|�}t|�t�}��||�dS)z�
        When a generator reraises a different exception,
        L{Failure._findFailure} inside the generator should find the reraised
        exception rather than original one.
        c3sX�zzdVWWdStygdYWdSwty+��t��jt�YdSw�Nr
)rr�rrr%�
IndexErrorrrkrrr�s���zJExtendedGeneratorTests.test_ambiguousFailureInGenerator.<locals>.generatorN)rrr	rrrkr� test_ambiguousFailureInGenerator�s
	z7ExtendedGeneratorTests.test_ambiguousFailureInGeneratorcCsVdd�}|�}t|�t�}z	|�||�WdSty*|�t��jt�YdSw)z�
        When a generator reraises a different exception,
        L{Failure._findFailure} above the generator should find the reraised
        exception rather than original one.
        css,�zdVWdStygdYdSwr)rrrrrr�s��zLExtendedGeneratorTests.test_ambiguousFailureFromGenerator.<locals>.generatorN)	rrr	rr�rrr%rrrrr�"test_ambiguousFailureFromGenerator�s�z9ExtendedGeneratorTests.test_ambiguousFailureFromGeneratorN)
r�r�r�r�r	rrr�rrrrrrr/s$r) r�rer�rYr�r��iorr�unittestr�cython_test_exception_raiserr�twisted.pythonrr�twisted.trial.unittestr	rrr�r�rr�r�r�r�r�r�r�r�rrrrr�<module>s6W
DR:2
@ Telegram