U n5{iÊ@sdZddlmZddlZddlZddlZddlZddlZddlZddl m Z ddl m Z ddlm Z ddlmZddlmZmZmZdd lmZdd lmZdd lmZmZdd lmZGd ddeZdddddddZGdddeZ GdddeZ!Gddde"Z#Gdddee#dZ$Gdd d eZ%Gd!d"d"eZ&d#d$d#d%d&d'd(d)Z'Gd*d+d+eZ(Gd,d-d-eZ)Gd.d/d/eZ*Gd0d1d1eZ+dS)2z6 Test cases for the L{twisted.python.failure} module. ) annotationsN)distb)StringIO FrameSummary) TracebackType)Any Generatorcast)skipIf)raiser)failurereflect)SynchronousTestCasec@s eZdZdZdddddZdS)ComparableExceptionz+An exception that can be compared by value.objectbool)otherreturncCs|j|jko|jtt|jkSN) __class__argsr r)selfrr=/tmp/pip-unpacked-wheel-mnhg7r0q/twisted/test/test_failure.py__eq__s zComparableException.__eq__N)__name__ __module__ __qualname____doc__rrrrrrsrF captureVarsrfailure.Failurer!rcCs>|r d}|z ddWn tk r8tj|d}YnX|S)z6 Make a C{Failure} of a divide-by-zero error. Zxyzrr ) BaseExceptionr Failure)r!exampleLocalVarfrrrgetDivisionFailure%s r)c@sDeZdZdZddddZddddZdddd Zddd d Zd d dd ddZd d ddddZ d d d ddddZ d]ddddddZ d^dddddZ d_dddddZ ddd d!Zddd"d#Zddd$d%Zddd&d'Zddd(d)Zddd*d+Zddd,d-Zddd.d/Zddd0d1Zd2d3d4d5d6Zddd7d8Zddd9d:Zddd;d<Zddd=d>Zddd?d@ZdddAdBZdddCdDZdddEdFZdddGdHZ dddIdJZ!dddKdLZ"dddMdNZ#dddOdPZ$dddQdRZ%d2ddSdTdUZ&dddVdWZ'dddXdYZ(dddZd[Z)d\S)` FailureTestsz' Tests for L{failure.Failure}. NonercCsTz tdWntk r(t}YnX|tt}||t||jtdS)z( Trapping a L{Failure}. testN) NotImplementedErrorr%r r&trap SystemExit RuntimeError assertEqualtype)rr(errorrrrtest_failAndTrap;s   zFailureTests.test_failAndTrapcCsLt}z|Wntk r*t}YnX|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) ValueErrorr%r r& assertRaisesr/ OverflowErrorassertIs)r exceptionr(Z untrappedrrrtest_trapRaisesWrappedExceptionGsz,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)r6r r&r9valuerr:f1f2rrrtest_failureValueFromFailureVs  z)FailureTests.test_failureValueFromFailurecCsNt}t|}z|tWntk r:t}YnX||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)r6r r&r/r8r%r9r<r=rrr!test_failureValueFromFoundFailureas z.FailureTests.test_failureValueFromFoundFailurestr)sprefixrcCs ||||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)rrCrDrrrassertStartsWithqs zFailureTests.assertStartsWith)rCsuffixrcCs ||||d|dS)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)rEendswith)rrCrHrrrassertEndsWith|s zFailureTests.assertEndsWith)tbrDrHrcCs||||||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)rGrJ)rrKrDrHrrrassertTracebackFormats z"FailureTests.assertTracebackFormatFr)r! cleanFailurerc Cst|d}t}|r||||}d|j|jr>dp@df}dt |j t |j |j}| |||dd|D}|r|g||rd} nd } || |n|g||d |d S) aV 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/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} r z*--- Failure #%d%s--- z (pickled)  z#{}: {} *--- End of Failure #{} --- cSsg|]}|dr|qS)z )rF).0linerrr s z8FailureTests.assertDetailedTraceback..z exampleLocalVar : "'xyz'"z exampleLocalVar : 'xyz'zA [Capture of Locals and Globals disabled (use captureVars=True)] N)r)rrMZprintDetailedTracebackgetvaluecountpickledformatrqualr3safe_strr<rL splitlinesassertNotEqualassertInr2) rr!rMr(outrKstartendZ linesWithVarsrPrrrassertDetailedTracebacks8)       z$FailureTests.assertDetailedTracebackr#c Cs|r d}|t}t}|||}d}|jD](\}}} } } ||d| d|d7}q4tt} ||d| d||r|t d|dS) a Assert that L{printBriefTraceback} produces and prints a brief traceback. The brief traceback consists of a header:: Traceback: : float division And the footer:: /twisted/test/test_failure.py:39:getDivisionFailure @param captureVars: Enables L{Failure.captureVars}. @type captureVars: C{bool} Zabcde: z Traceback: z: zexampleLocalVar.*abcdeN) r)rZprintBriefTracebackrRframesreprZeroDivisionErrorrL assertIsNoneresearch) rr!r'r(r[rKstackmethodfilenamelineno localVars globalVarsZzderrrassertBriefTracebacks$  z!FailureTests.assertBriefTracebackc Cs|r d}|t|d}t}|||}d}|jD]F\}}} } } |d|d| d|d7}|dt|| d7}q8||d d |t |j t |j f|r|td |d S) a Assert that L{printTraceback} produces and prints a default traceback. The default traceback consists of a header:: Traceback (most recent call last): And the footer:: 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} Zxyzzyr r_z File "z", line z, in raz z"Traceback (most recent call last):z %s%s: %s zexampleLocalVar.*xyzzyN)r)rZprintTracebackrRrb linecachegetlinestriprLrrVr3rWr<rerfrg) rr!r'r(r[rKrhrirjrkrlrmrrrassertDefaultTraceback s.     z#FailureTests.assertDefaultTracebackcCs |dS)zr L{printDetailedTraceback} returns a detailed traceback including the L{Failure}'s count. Nr^rrrrtest_printDetailedTraceback8sz(FailureTests.test_printDetailedTracebackcCs |dS)zC L{printBriefTraceback} returns a brief traceback. Nrnrtrrrtest_printBriefTraceback?sz%FailureTests.test_printBriefTracebackcCs |dS)z8 L{printTraceback} returns a traceback. Nrrrtrrrtest_printTracebackEsz FailureTests.test_printTracebackcCs|jdddS)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}. Tr Nrsrtrrr'test_printDetailedTracebackCapturedVarsKsz4FailureTests.test_printDetailedTracebackCapturedVarscCs|jdddS)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. Tr Nrvrtrrr$test_printBriefTracebackCapturedVarsSsz1FailureTests.test_printBriefTracebackCapturedVarscCs|jdddS)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. Tr Nrxrtrrrtest_printTracebackCapturedVars]sz,FailureTests.test_printTracebackCapturedVarscCs|jddddS)z C{printDetailedTraceback} includes information about local variables on the stack after C{cleanFailure} has been called. T)r!rMNrsrtrrr.test_printDetailedTracebackCapturedVarsCleanedgsz;FailureTests.test_printDetailedTracebackCapturedVarsCleanedcCs|jttjdddddS)zu L{failure.format_frames} raises a L{ValueError} if the supplied C{detail} level is unknown. NZnoisiadetail)r7r6r Z format_framesrtrrrtest_invalidFormatFramesDetailnsz+FailureTests.test_invalidFormatFramesDetailcCs,t}t|}|t||j|dSr)r1r r&r/r2r<)rer(rrrtest_ExplictPassws  zFailureTests.test_ExplictPassr"z str | None)r(rcCsJz |Wn0tk r<ttd}|djYSXtddS)Nz3f.raiseException() didn't raise ZeroDivisionError!?)raiseExceptionrd traceback extract_tbsysexc_inforP Exception)rr(rKrrr_getInnermostFrameLine}s  z#FailureTests._getInnermostFrameLinecCs t}||}||ddS)N1 / 0)r)rr2)rr(Z innerlinerrrtest_RaiseExceptionWithTBs z&FailureTests.test_RaiseExceptionWithTBcCs|tjtjdS)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)r7r ZNoCurrentExceptionErrorr&rtrrrtest_ConstructionFailssz#FailureTests.test_ConstructionFailscCst}|||jdS)z If the C{Failure} has not been cleaned, then C{getTracebackObject} returns the traceback object that captured in its constructor. N)r)r2getTracebackObjectrKrr(rrrtest_getTracebackObjectsz$FailureTests.test_getTracebackObjectcCsLz ddWn(tk r4t}tjdd}YnX|||jdS)zc C{captureVars=True} has no effect on the result of C{getTracebackObject}. r$rTr N)rdr r&r2rrK)rZ noVarsFailureZ varsFailurerrr&test_getTracebackObjectFromCaptureVarss  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)r)rrrrMassertIsNotNoner2rr(expectedZobservedrrr test_getTracebackObjectFromCleans  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}. Tr N)r)rrrrMr2rrrr.test_getTracebackObjectFromCaptureVarsAndCleans  z;FailureTests.test_getTracebackObjectFromCaptureVarsAndCleancCs ttd}||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)r r&rrerrrrr'test_getTracebackObjectWithoutTracebacksz4FailureTests.test_getTracebackObjectWithoutTracebackcCsLz ddWn"tk r.t\}}}YnXt|}||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)r%rrr r&r9rK)rklassr:rKr(rrr$test_tracebackFromExceptionInPython3s   z1FailureTests.test_tracebackFromExceptionInPython3cCs>t}||j||jj|j|||jjdS)z L{failure.Failure.cleanFailure} sets the C{__traceback__} attribute of the exception to L{None} in Python 3. N)r)rrKr9r< __traceback__rMrerrrr*test_cleanFailureRemovesTracebackInPython3s  z7FailureTests.test_cleanFailureRemovesTracebackInPython3cCs0t}t}t||d|d|dS)z The traceback captured by a L{Failure} is compatible with the stdlib L{dis.distb} function as used in post-mortem debuggers. Specifically, it doesn't cause that function to raise an exception. )filez --> N)r)rrrrZrR)rr(bufrrr test_distbszFailureTests.test_distbcCs*t}tt}|t|d|fdS)z The C{repr} of a L{failure.Failure} shows the type and string representation of the underlying exception. z5N)r)rZfullyQualifiedNamerdr2rc)rr(ZtypeNamerrr test_reprs  zFailureTests.test_reprcCsNt}|j|_|}|t|dk|ddD]}|d|dq4dS)zL C{Failure.stack} is gettable and settable, but depreacted. r$NzFtwisted.python.failure.Failure.stack was deprecated in Twisted 24.10.0message)r)rhZ flushWarningsrElenr2)rr(warningswrrrtest_stackDeprecationsz"FailureTests.test_stackDeprecationcCshtd}t|j}tj|}||tj|j}||dd|d|||dS)ze C{Failure._withoutTraceback(exc)} gives the same result as C{Failure(exc)}. hellorSr$N) rdr r&__dict__copy_withoutTracebackassertIsInstancer2pop)rexcZdict1failure2Zdict2rrrtest_failureWithoutTracebacks  z)FailureTests.test_failureWithoutTracebackcCsjtd}t|}||tj|}||z tdWntk rZt}YnX||dS)zm C{Failure(exc)} and C{Failure._withoutTraceback(exc)} can be pickled and unpickled. rZbooN)rr r&assertPicklingRoundtripsrr%)rrZfailure1rZfailure3rrrtest_failurePicklings     z!FailureTests.test_failurePickling)original_failurercCsTtt|}|j}d|d<d|d<|j}|||||j|jdS)z{ The failure can be pickled and unpickled, and the C{parents} attribute is included in the pickle. r$rTNrK)pickleloadsdumpsrrr2rb)rrrrresultrrrr/s   z%FailureTests.assertPicklingRoundtripscCs(ttd}||d|jdS)z? C{Failure.parents} is included in the pickle. rparentsN)r r&rr2 __getstate__rrrrr#test_failurePicklingIncludesParents<sz0FailureTests.test_failurePicklingIncludesParentscCsXtt}|jdd|_tt|}|jdd|_||j|jdddS)zO C{Failure.frames} can be set, both before and after pickling. Nr)r r&r)rbrrrr2rrrrrrtest_settableFramesCs  z FailureTests.test_settableFramescCsBttd}|jdd|_tt|}|jdd|_dS)zs C{Failure.parents} can be set, both before and after pickling. This is used by Foolscap. rN)r r&rrrrrrrrrtest_settableParentsMsz!FailureTests.test_settableParentsN)FF)F)F)*rrrrr5r;r@rArGrJrLr^rnrrrurwryrzr{r|r}rrrrrrrrrrrrrrrrrrrrrrrrrr*6sR    L(.              r*c@seZdZdZddddZdS) BrokenStrzb An exception class the instances of which cannot be presented as strings via L{str}. rBr,cCs|dSrrrtrrr__str___szBrokenStr.__str__NrrrrrrrrrrYsrc@seZdZdZddddZdS)BrokenExceptionMetaclassza A metaclass for an exception type which cannot be presented as a string via L{str}. rBr,cCs tddS)Nz#You cannot make a string out of me.)r6rtrrrrjsz BrokenExceptionMetaclass.__str__Nrrrrrrdsrc@seZdZdZdS)BrokenExceptionTypeza The aforementioned exception type which cannot be presented as a string via L{str}. N)rrrrrrrrrnsr) metaclassc@seZdZdZdddddZdddd Zddd d Zddd d ZdddddZddddZ ddddZ ddddZ dS)GetTracebackTestsz, Tests for L{Failure.getTraceback}. rBr+)rrcCs,t}t|}|j|d}||tdS)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. r~N)rr r& getTracebackrrB)rrxr(rrrr_brokenValueTest{s  z"GetTracebackTests._brokenValueTestr,cCs|ddS)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. briefNrrtrrrtest_brokenValueBriefDetailsz-GetTracebackTests.test_brokenValueBriefDetailcCs|ddS)Y Like test_brokenValueBriefDetail, but for the C{"default"} detail case. defaultNrrtrrrtest_brokenValueDefaultDetailsz/GetTracebackTests.test_brokenValueDefaultDetailcCs|ddS)rverboseNrrtrrrtest_brokenValueVerboseDetailsz/GetTracebackTests.test_brokenValueVerboseDetailcCs(tt}|j|d}||tdS)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. r~N)r r&rrrrB)rrr(rrrr_brokenTypeTests  z!GetTracebackTests._brokenTypeTestcCs|ddS)aQ A L{Failure} might wrap an newPublisher(evt) xception 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. rNrrtrrrtest_brokenTypeBriefDetails z,GetTracebackTests.test_brokenTypeBriefDetailcCs|ddS)zX Like test_brokenTypeBriefDetail, but for the C{"default"} detail case. rNrrtrrrtest_brokenTypeDefaultDetailsz.GetTracebackTests.test_brokenTypeDefaultDetailcCs|ddS)zX Like test_brokenTypeBriefDetail, but for the C{"verbose"} detail case. rNrrtrrrtest_brokenTypeVerboseDetailsz.GetTracebackTests.test_brokenTypeVerboseDetailN) rrrrrrrrrrrrrrrrrvs   rc@s,eZdZdZeedkdddddZdS)FindFailureTestszH Tests for functionality related to identifying the C{Failure}. Nzraiser extension not availabler+r,cCsLz tWn0tjk r<t}||tjYn X|ddS)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)r rZRaiserExceptionr r&rEcheckfailrrrr/test_failureConstructionWithMungedStackSucceedss  z@FindFailureTests.test_failureConstructionWithMungedStackSucceeds)rrrrr r rrrrrrs rrBintr+r)fnrknametextrcCs t|||Srr)rrkrrrrr_tbsrc@s,eZdZdZddddZddddZdS) 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. r+r,cCs8tdddiigg}|t|tddddgdS)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. ri filename.py{N)r _Tracebackr2rrrrrKrrrtest_singleFrames z*FormattableTracebackTests.test_singleFramec Csptdddiigdddiigg}|t|tddddtddddg|t|jtddddgdS)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. Zmethod1rrZmethod2N)r rr2rrr extract_stacktb_framerrrrtest_manyFramess        z)FormattableTracebackTests.test_manyFramesN)rrrrrrrrrrrsrc@s:eZdZdZddddZddddZdddd Zd S) FakeAttributesTestsaR _Frame, _Code and _TracebackFrame objects should possess some basic attributes that qualify them as fake python objects, allowing the return of _Traceback to be used as a fake traceback. The attributes that have zero or empty values are there so that things expecting them find them (e.g. post mortem debuggers). r+r,cCstdd}ddi}ddi}tddd||f|}||j|||j|||jtj||j|||j t ||j t ||j d||jtddS) 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. )Z dummyparentZdummyparentfileoNNNZ local_var*Z global_vard dummyname dummyfilename)r _Framer2 f_globalsf_localsrf_code_Codef_back f_builtinsdictf_lastirf_linenof_tracer3)rZ back_frameZ fake_localsZ fake_globalsframerrrtest_fakeFrameAttributess.  z,FakeAttributesTests.test_fakeFrameAttributescCstdd}||jd||jd||jt||jt ||j t ||j t ||j t||jt||jt ||jt ||jt||jt||jt ||jt||jt||jt||t dS)N See L{FakeAttributesTests} for more details about this test. rrN)r rr2co_name co_filenamer co_argcountrco_codebytes co_cellvarstuple co_constsco_firstlinenoco_flags co_lnotab co_freevarsco_posonlyargcountco_kwonlyargcountco_names co_nlocals co_stacksize co_varnameslistZ co_positions)rcoderrrtest_fakeCodeAttributes;s$ z+FakeAttributesTests.test_fakeCodeAttributescCs^tdddiifd}t|}||j|||jd||jt| t |ddS)rrrrNtb_next) r rZ_TracebackFramer2r tb_linenortb_lastirrEhasattr)rrZtraceback_framerrrtest_fakeTracebackFrameRs  z+FakeAttributesTests.test_fakeTracebackFrameN)rrrrrrrrrrrr s%rc@s:eZdZdZddddZddddZdddd Zd S) DebugModeTestszF Failure's debug mode should allow jumping into the debugger. r+r,csZtjtjjddfdd }|g_d dddfdd }|t_tdS) zK Override pdb.post_mortem so we can make sure it's called. r+r,cst_tj_dSr)pdb post_mortemr r&__init__r)origInitrrrrestorensz%DebugModeTests.setUp..restoreNzTracebackType | None)trcsj|dSr)rappend)rrtrrlogging_post_mortemvsz1DebugModeTests.setUp..logging_post_mortem)N)rrr r&rZ addCleanuprZstartDebugMode)rrrr)rrrrsetUpfs zDebugModeTests.setUpcCsXz ddWn*tk r6t\}}}t}YnX||j|g||jdS)z~ If startDebugMode() is called, calling Failure() will first call pdb.post_mortem with the traceback. r$rN) r%rrr r&r2rZ assertFalser!rtyprrKr(rrrtest_regularFailure|s z"DebugModeTests.test_regularFailurecCs\z ddWn.tk r:t\}}}tjdd}YnX||j|g||jdS)zk If startDebugMode() is called, passing captureVars to Failure() will not blow up. r$rTr N) r%rrr r&r2rrEr!rrrrtest_captureVarss zDebugModeTests.test_captureVarsN)rrrrrr!r"rrrrras rc@sZeZdZdZddddddZddd d Zddd d Zddd dZddddZdS)ExtendedGeneratorTestszU Tests C{failure.Failure} support for generator features added in Python 2.5 r"zGenerator[Any, Any, Any]r+)r(grcCs2z||Wntk r"Yn X|ddS)Nz.generatorrr$rrrN)r)nextr&r2rdrrrrr*r$r(rr(r test_throwExceptionIntoGenerators z7ExtendedGeneratorTests.test_throwExceptionIntoGeneratorcst}||}gddfdd }|}t|||td||d|dd 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. r'r,c3s<z dVWn"tk r,tYn XddS)NzNo exception sent to generator)r%rr r&rrZ newFailuresrrrr*s  zVExtendedGeneratorTests.test_failureConstructionFindsOriginalFailure..generatorr$rr*N) r)rMrr+r&r2rrYrZZ assertNotIn)rr(Zoriginal_failure_strr*r$rr.r,test_failureConstructionFindsOriginalFailures zCExtendedGeneratorTests.test_failureConstructionFindsOriginalFailurecs6ddfdd }|}t|t}||dS)z When a generator reraises a different exception, creating a L{Failure} inside the generator should find the reraised exception rather than original one. r'r,c3sXz,z dVWntk r(gdYnXWn&tk rRtjtYnXdSNr$)r%rr r&r< IndexErrorrrtrrr*s zJExtendedGeneratorTests.test_ambiguousFailureInGenerator..generatorN)r+r)r&r,rrtr test_ambiguousFailureInGenerators  z7ExtendedGeneratorTests.test_ambiguousFailureInGeneratorcCs^dddd}|}t|t}z|||Wn&tk rX|tjtYnXdS)z When a generator reraises a different exception, creating a L{Failure} above the generator should find the reraised exception rather than original one. r'r,css,z dVWntk r&gdYnXdSr0)r%rrrrr*s zLExtendedGeneratorTests.test_ambiguousFailureFromGenerator..generatorN) r+r)r&r%rr r&r<r1r,rrr"test_ambiguousFailureFromGeneratorsz9ExtendedGeneratorTests.test_ambiguousFailureFromGeneratorN) rrrrr&r-r/r2r3rrrrr#s  $r#),r __future__rrorrrfrrdisriorrtypesrtypingrr r Zunittestr Zcython_test_exception_raiserr Ztwisted.pythonr rZtwisted.trial.unittestrrrr)r*rr3rrrrrrrrr#rrrrsB         '  F4T6