YfdZddlZddlZddlZddlZddlmZddlmZm Z ddl m Z ddl m ZmZmZddlmZmZmZmZddlmZdd lmZdd lmZmZmZm Z mZdd l m!Z!m"Z"dd l#m$Z$m%Z%dd l&m'Z'm(Z(m)Z)ddl*m+Z+m,Z,m-Z-ddl.m/Z/GddZ0Gdde j1Z2Gdde j1Z3Gdde3Z4Gdde2Z5Gdde5Z6Gdde j1Z7Gd d!e2Z8Gd"d#e j1Z9Gd$d%e j1Z:Gd&d'e j1Z;Gd(d)e j1Z<Gd*d+e<Z=Gd,d-e j1Z>Gd.d/e>Z?Gd0d1Z@Gd2d3e j1ZAGd4d5e j1ZBGd6d7eBZCGd8d9e j1ZDGd:d;eBZEGd<d=e j1ZFGd>d?eCZGGd@dAejHZIGdBdCe j1ZJGdDdEZKGdFdGe j1ZLGdHdIe j1ZMdS)Jz& Tests for L{twisted.trial.reporter}. N)getmro)BytesIOStringIO)Type)TestCase TestSuiteexpectedFailure) assert_thatequal_tohas_item has_lengthlog)Failure)itrialreporterrunnerunittestutil)UncleanWarningsReporterWrapper _ExitWrapper) erroneoussample)SkipTestTodomakeTodo) isFailurematches_result similarFrame)afterc,eZdZdZdZdZdZdZdZdS) BrokenStreamz Stream-ish object that raises a signal interrupt error. We use this to make sure that Trial still manages to write what it needs to write. Fc||_dSN)fObj)selfr's R/var/www/html/env/lib/python3.11/site-packages/twisted/trial/test/test_reporter.py__init__zBrokenStream.__init__,  c|jr|j|Sd|_ttjd)NTzInterrupted write)writtenr'writeOSErrorerrnoEINTR)r(ss r)r/zBrokenStream.write/s: < &9??1%% % ek#6777r,c|jr|jSd|_ttjd)NTzInterrupted flush)flushedr'flushr0r1r2r(s r)r6zBrokenStream.flush5s8 < %9??$$ $ ek#6777r,N) __name__ __module__ __qualname____doc__r.r5r*r/r6r,r)r$r$#sW GG888 88888r,r$ceZdZdZdS) StringTestc ttd|}|t|t|kdt|t|fzt t jd}tt||D]\}\}}| t|tr| ||d|||fz>t||r5|| |d||j |fztd|dS)Nz2Must have more observed than expectedlines %d < %dzLine %d: %r not in %rz#Line %d: %r did not match string %rz"don't know what to do with object )listfilter assertTruelentyperecompile enumeratezip isinstancestrassertSubstringmatchpattern TypeError)r(expectoutputREGEX_PATTERN_TYPE line_numberexpouts r)stringComparisonzStringTest.stringComparison=shfT6**++  KK3v;; & "6{{CKK8 9   ""*R..11'0VV1D1D'E'E N N #K#s{C%% N$$5c38OOC!344 NIIcNN9"CK56  LS L LMMM N Nr,N)r8r9r:rVr<r,r)r>r><s(NNNNNr,r>c&eZdZdZdZdZdZdS)TestResultTestsc6tj|_dSr&)r TestResultresultr7s r)setUpzTestResultTests.setUpWs)++ r,cV td#t$r8}|}|j|tjYd}~nd}~wwxYw|jjdd}|||j|t|jdSNfoorr!) RuntimeErrorr[addErrorsysexc_infoerrors assertEqualvaluerEr(eexcValuefailures r)test_pyunitAddErrorz#TestResultTests.test_pyunitAddErrorZs 7u%% % 7 7 7H K s|~~ 6 6 6 6 6 6 6 6 7+$Q'* 7=111 w|44444s A.AAcb |d#|j$r8}|}|j|tjYd}~nd}~wwxYw|jjdd}|||j||j|jdSr^) failureExceptionr[ addFailurerbrcfailuresrerfrErgs r)test_pyunitAddFailurez%TestResultTests.test_pyunitAddFailurees 9''.. .$ 9 9 9H K " "4 8 8 8 8 8 8 8 8 9+&q)!, 7=111 . =====s A.AAc|t5|j|ddddn #1swxYwY|t5|j|t ddddn #1swxYwY|t5|j|tt dddfdddn #1swxYwY|t5|j|tt dfddddS#1swxYwYdS)z L{reporter.TestResult.addError} raises L{TypeError} if it is called with an error that is neither a L{sys.exc_info}-like three-tuple nor a L{Failure}. zan errorNextra) assertRaisesrOr[ra Exceptionr7s r)test_somethingElsez"TestResultTests.test_somethingElsepsZ   y ) ) 3 3 K z 2 2 2 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3   y ) ) > > K y'<'< = = = > > > > > > > > > > > > > > >   y ) )   K y)J"7"7wG                    y ) ) K K K  9Z3H3H'I J J J K K K K K K K K K K K K K K K K K KsGAA A()BB!$B!2DDD%0E""E&)E&N)r8r9r:r\rkrprur<r,r)rXrXVsU,,, 5 5 5 > > >KKKKKr,rXceZdZdZdS)ReporterRealtimeTestscXt}tj|d|_dS)NT)realtime)rrReporterr[r(rQs r)r\zReporterRealtimeTests.setUps&'>>> r,N)r8r9r:r\r<r,r)rwrws#?????r,rwcpeZdZejdZd dZdZdede j fdZ dZ d Z d Zd d ZdS) ErrorReportingTestsz^=+$returnNctj|_t|_t j|j|_dSr&)r TestLoaderloaderrrQrrzr[r7s r)r\zErrorReportingTests.setUps5')) jj )1):4;)G)G r,c||}||jSr&) getResultdonerQgetvalue)r(suiter[s r) getOutputzErrorReportingTests.getOutputs4&& {##%%%r,rcD||j|jSr&)runr[r(rs r)rzErrorReportingTests.getResults $+{r,c Ptj}|j|}||}|jddtjdtjdd|j d|j dg}| ||dS) z A test method which runs and has an error recorded against it is reported in the output stream with the I{ERROR} tag along with a summary of what error was reported and the ID of the test. z[ERROR]"Traceback (most recent call last):z.^\s+File .*erroneous\.py., line \d+, in setUp$z5^\s+raise FoolishError..I am a broken setUp method..$zEtwisted.trial.test.erroneous.FoolishError: I am a broken setUp method.z .test_noopN) rSynchronousTestFailureInSetUpr loadClassr splitlinesdoubleSeparatorrFrGr9r8rV)r(clsrrQrMs r)test_formatErroredMethodz,ErrorReportingTests.test_formatErroredMethods 5 %%c**&&1133   0 JH I I JS T T-~ 8 8 8 8 8   eV,,,,,r,c|jd}||}|jddt jdt jdddg}|||dS)z A test method which runs and has a failure recorded against it is reported in the output stream with the I{FAIL} tag along with a summary of what failure was reported and the ID of the test. z6twisted.trial.test.erroneous.TestRegularFail.test_failz[FAIL]rz2^\s+File .*erroneous\.py., line \d+, in test_fail$z^\s+self\.fail\("I fail"\)$z'twisted.trial.unittest.FailTest: I failN)r loadByNamerrrrFrGrV)r(rrQrMs r)test_formatFailedMethodz+ErrorReportingTests.test_formatFailedMethods  && D  &&1133   0 JL M M J5 6 6 5 D  eV,,,,,r,cddlm}tj|j|t j}||}d}ddd|fD]}| ||| tj d|d|j tjd g}|||d S) z A problem encountered while running a doctest is reported in the output stream with a I{FAIL} or I{ERROR} tag along with a summary of what problem was encountered and the ID of the test. r)rz0twisted.trial.test.erroneous.unexpectedExceptionz1/0ZeroDivisionErrorzException raised:zFail(ed|ure in) example:z;Couldn't match 'Failure in example: ' or 'Failed example: 'z\[(ERROR|FAIL)\]N)twisted.trial.testrrdecorater loadDoctestsr ITestCaserrLrCrFsearchrrGrVr)r(rrrQpath substringrPs r)test_doctestErrorz%ErrorReportingTests.test_doctestErrors 100000!$+":":9"E"EvGWXX&&A!46I4P 4 4I  F 3 3 3 3  I0& 9 9 L   & 3F(G(GH ff&7&7&9&9:::::r,c >tjd}|t|g}t |t t dt d|j\\}}t |t|t |ttttttdttdd|j\\}}t |t|t |tt|jtttdttddd S) a When a function scheduled using L{IReactorTime.callLater} in a test method raises an exception that exception is added to the test result as an error. This happens even if the test also fails and the test failure is also added to the test result as a failure. Only really necessary for testing the deprecated style of tests that use iterate() directly. See L{erroneous.DelayedCall.testHiddenException} for more details. testHiddenExceptionr!)rdrozsomething blew upgoz erroneous.py)rErfframesz/Deliberate failure to mask the hidden exceptionN)r DelayedCallrPyUnitTestSuiter rr rdr rr`r"rKr r rorm)r(testr[ actualCaseerrorrjs r)test_hiddenExceptionz(ErrorReportingTests.test_hiddenExceptions$%:;; 7 788 N*Q--*Q--PPP   !'  *eD(:..///  l++C*=!>!>?? T> B BCC      #)/ *gD(:..///  d344"STT -BN S STT     r,r~N)r8r9r:rFrGrr\rrrrzrrrrrr<r,r)r}r}s bj))OHHHH &&& 83D---.---*;;;() ) ) ) ) ) r,r}c4eZdZdZddZdedejfdZdS)(UncleanWarningWrapperErrorReportingTestsz Tests that the L{UncleanWarningsReporterWrapper} can sufficiently proxy IReporter failure and error reporting methods to a L{reporter.Reporter}. r~Nctj|_t|_t j|j|_t|j|_dSr&) rrrrrQrrzrr[r7s r)r\z.UncleanWarningWrapperErrorReportingTests.setUp sF')) jj +3+eZdZdZdZdZdZdZdZdZ dZ d S) TracebackHandlingTestscdt}tj|}|||j|jz}|t|d||dd|||ddj S)z Run the given C{test}, make sure it fails and return the trimmed frames. @param test: The test case to run. @return: The C{list} of frames trimmed. r!r) rrrzrrordrerD _trimFramesr)r(rstreamr[badss r)getErrorFramesz%TracebackHandlingTests.getErrorFramess"6** . TA&&& aT***!!$q'!*"3444r,ct||D]\}}||d|dtj|ddtj}|dd}||t| d||t|t|dS)Nrr!/)rIreosrsplitextsplitseprD)r(observedFramesexpectedFramesobservedexpected observedSegs expectedSegss r) checkFramesz"TracebackHandlingTests.checkFrames(s"%nn"E"E O O Hh   Xa[(1+ 6 6 67++HQK88;AA"&IIL#A;,,S11L   \3|+<+<*<*>*>? N N N N ^,,c..A.ABBBBBr,ctjd}||}||dgdS)N test_fail)rtwisted/trial/test/erroneousrTestRegularFailrrr(rrs r) test_basicz!TracebackHandlingTests.test_basic0sE(55$$T** "O!PQQQQQr,ctjd}||}||ddgdS)N test_subfail)rr) subroutinerrrs r)test_subroutinez&TracebackHandlingTests.test_subroutine5sU(88$$T**  @>      r,ctjd}||}||dgdS)z C{_trimFrames} removes traces of C{_runCallbacks} when getting an error in a callback returned by a C{TestCase} based test. r)cbztwisted/internet/taskNrTestAsynchronousFailrrrs r) test_deferredz$TracebackHandlingTests.test_deferred@sV -k::$$T**  0      r,ctjd}|g|gdSr&rrzrerr(r[s r) test_noFramesz$TracebackHandlingTests.test_noFramesPs<"4(( V//3344444r,ctjd}|dg|dgdS)Nz fake framerrs r) test_oneFramez$TracebackHandlingTests.test_oneFrameTs@"4(( ,););\N)K)KLLLLLr,ctjd}||}||dgdS)z C{_trimFrames} removes traces of C{runWithWarningsSuppressed} from C{utils} when a synchronous exception happens in a C{TestCase} based test. test_exception)rrNrrs r)rz%TracebackHandlingTests.test_exceptionXsH -.>??$$T** "T!UVVVVVr,N) r8r9r:rrrrrrrrr<r,r)rrs555"CCCRRR       555MMMWWWWWr,rc&eZdZdZdZdZdZdS)FormatFailuresTestsc td#t$rt|_YnwxYwddddgdggddddgd ggg|j_t |_t j|j|_dS) Nr_z foo/bar.py)xr)yorangequx )atwo)bMCMXCIX) r`rfrrrrrzr[r7s r)r\zFormatFailuresTests.setUpds u%% %   YYDFFF L!hZ/1B C L"|n7G6H I  jj ' 44 s 11c |j|j}|ddt jddt jddg|dS)Nrz# File "foo/bar.py", line 5, in fooz^\s*$z$ File "foo/bar.py", line 10, in quxzRuntimeError: foo)r[_formatFailureTracebackrrVrFrGr)r(tbs r)test_formatDefaultz&FormatFailuresTests.test_formatDefaultpss [ 0 0 8 8 45 8$$6 8$$#   MMOO r,cnd}d}|j|}|||dS)Nz File "twisted/trial/unittest.py", line 256, in failUnlessSubstring return self.failUnlessIn(substring, astring, msg) exceptions.TypeError: iterable argument required z File "twisted/trial/unittest.py", line 256, in failUnlessSubstring return self.failUnlessIn(substring, astring, msg) exceptions.TypeError: iterable argument required )r[rre)r(rr formatteds r)test_formatStringz%FormatFailuresTests.test_formatString~sC  K77;;  9-----r,c|jjdd}|j|j||jj|dSr&)rrr[rre)r(rs r) test_mutationz!FormatFailuresTests.test_mutationsLqqq! ++DF333 /////r,N)r8r9r:r\rrrr<r,r)rrcsP 5 5 5     . . .00000r,rc8eZdZdZdZdZdZdZdZdZ dS) PyunitNamesTestsc^t|_tjd|_dSNtest_foo)rrr PyunitTestrr7s r)r\zPyunitNamesTests.setUps#jj %j11 r,ctj|j}||j|j}||ddS)Nz2twisted.trial.test.sample.PyunitTest.test_foo ... )rVerboseTextReporterr startTestrrrer(r[rQs r)test_verboseReporterz%PyunitNamesTests.test_verboseReportersZ-dk::###%%'' !UVVVVVr,cXtj|j}||j|j}|d}||| |jdzdSNz ... r TreeReporterrrrrrstripregetDescriptionrs r)test_treeReporterz"PyunitNamesTests.test_treeReporter&t{33###%%''""$$R(..00 !6!6ty!A!AF!JKKKKKr,ctj|j}||j}||ddSrrrrrrrers r)test_getDescriptionz$PyunitNamesTests.test_getDescriptionE&t{33&&ty11 ,,,,,r,cPtj|j}|j|||jd}| |ddgddS)a The summary of L{reporter.MinimalReporter} is a simple list of numbers, indicating how many tests ran, how many failed etc. The numbers represents: * the run time of the tests * the number of tests run, printed 2 times for legacy reasons * the number of errors * the number of failures * the number of skips  r!N)1r 0rr) rMinimalReporterrrr _printSummaryrrrrers r)test_minimalReporterz%PyunitNamesTests.test_minimalReporters)$+66 f%%''--//55c:: %>%>%>?????r,cjgdtj|j}fd|_|j|||j d}|d}| |ddS)zt L{reporter.MinimalReporter} reports the time to run the tests as first data in its output. )g?g333333?g?gffffff?c.dSNr)pop)timessr)z;PyunitNamesTests.test_minimalReporterTime..s%))A,,r,r rz0.7N) rrr_getTimerrrrrrre)r(r[rQtimerrs @r)test_minimalReporterTimez)PyunitNamesTests.test_minimalReporterTimes %$$)$+66.... f%%''--//55c::q  &&&&&r,c tj|j}||jd}||gddS)zv The summary of L{reporter.MinimalReporter} is a list of zeroes when no test is actually run. r )rrrrrrN)rrrrrrrrers r)test_emptyMinimalReporterz*PyunitNamesTests.test_emptyMinimalReportersx )$+66%%''--//55c:: !?!?!?@@@@@r,N) r8r9r:r\rrr rrrr<r,r)rrs222WWW LLL--- @@@$ ' ' 'AAAAAr,rc0eZdZdZdZdZdZdZdZdS)DirtyReactorTestsz The trial script has an option to treat L{DirtyReactorAggregateError}s as warnings, as a migration tool for test authors. It causes a wrapper to be placed around reporters that replaces L{DirtyReactorAggregatErrors} with warnings. cttjdgdg|_t |_t d|_dS)Nr_bartest_errorByDefault)rrDirtyReactorAggregateError dirtyErrorrrQrrr7s r)r\zDirtyReactorTests.setUpsA!$"A5'E7"S"STTjj %&;<< r,c"tj|j}||j|j|t|jd||jdd|jdS)zj L{DirtyReactorAggregateError}s are reported as errors with the default Reporter. rr!rN) rrzrQrarr#rerDrdrs r)r!z%DirtyReactorTests.test_errorByDefaults{ "$+666 4?333 V]++Q/// q)!,do>>>>>r,cttj|j}|t |jtj|j |j |jdS)z L{DirtyReactorAggregateError}s are reported as warnings when using the L{UncleanWarningsReporterWrapper}. r%N) rrrzrQ assertWarns UserWarningr#getErrorMessage__file__rarrs r)test_warningsEnabledz&DirtyReactorTests.test_warningsEnabledsl 00A0U0U0UVV   O + + - -   O I O      r,c2ttj|j}|t |jtj|j |j |j| |j j gdS)z L{DirtyReactorAggregateError}s are I{not} reported as errors if the L{UncleanWarningsReporterWrapper} is used. r%N)rrrzrQr'r(r#r)r*rarre_originalReporterrdrs r)test_warningsMaskErrorsz)DirtyReactorTests.test_warningsMaskErrorss 00A0U0U0UVV   O + + - -   O I O     18"=====r,cttj|j}||j|jj|jjdf| t|j j d| |j j ddj|jj| |j j ddj|jjdS)a Some annoying stuff can pass three-tuples to addError instead of Failures (like PyUnit). The wrapper, of course, handles this case, since it is a part of L{twisted.trial.itrial.IReporter}! But it does not convert L{DirtyReactorAggregateError} to warnings in this case, because nobody should be passing those in the form of three-tuples. r%Nr!r) rrrzrQrarr#rErfrerDr-rdrs r)test_dealsWithThreeTuplesz+DirtyReactorTests.test_dealsWithThreeTuples s00A0U0U0UVV DO$8$/:OQU#VWWW V5<==qAAA   $ +A .q 1 68L      $ +A .q 1 79N     r,N) r8r9r:r;r\r!r+r.r0r<r,r)rrsi=== ???    >>>      r,rc,eZdZdZdZdZdZdZdS)TrialNamesTestsc^t|_tjd|_dSr)rrrFooTestrr7s r)r\zTrialNamesTests.setUp s"jj N:.. r,ctj|j}||j|j}|||jdzdS)Nz ... )rrrrrrreidrs r)rz$TrialNamesTests.test_verboseReporter$sh-dk::###%%'' '!9:::::r,cXtj|j}||j|j}|d}||| |jdzdSrrrs r)rz!TrialNamesTests.test_treeReporter*rr,ctj|j}|||ddS)z A docstringtest_treeReporterWithDocstringsN)rrrrerrs r)r9z/TrialNamesTests.test_treeReporterWithDocstrings1s?&t{33 ..t446WXXXXXr,ctj|j}||j}||ddSrrrs r)r z#TrialNamesTests.test_getDescription6r r,N)r8r9r:r\rrr9r r<r,r)r2r2se///;;; LLLYYY -----r,r2cBeZdZdZdZdZdZdZdZdZ dZ d Z d S) SkipTestsz= Tests for L{reporter.Reporter}'s handling of skips. ct|_tj|j|_t jd|_dSrrrrrzr[rr4rr7s r)r\zSkipTests.setUpA6jj ' 44 N:.. r,c*t|jS)zF Get the number of skips that happened to a reporter. )rDskipsrs r) _getSkipszSkipTests._getSkipsFs6<   r,c|j|jd|||jddS)N some reasonr!)r[addSkiprrerBr7s r)test_accumulationzSkipTests.test_accumulationLsF DI}555  44a88888r,c|j|jd|d|jdS)NrDT)r[rErre wasSuccessfulr7s r) test_successzSkipTests.test_successPsF DI}555 t{88::;;;;;r,c|j|jd|j|jd}d}|||| |t|d ddS)z The summary of a successful run with skips indicates that the test suite passed and includes the number of skips. rDrPASSED Nz (skips=1)) r[rErrrrrrC startswithrerDrr(rQprefixs r) test_summaryzSkipTests.test_summaryTs DI}555 %%''2244R8 ))&11222 F .4466 DDDDDr,c*|j|jd|j|jd}||ddS)zw The output at the end of a test run with skips includes the reasons for skipping those tests. rDN) r[rErrrrrrerr{s r)test_basicErrorszSkipTests.test_basicErrors`sz DI}555 %%''2244Q7 77777r,c|j|jd|j|jd}||ddS)z Tests can be skipped without specifying a reason by setting the 'skip' attribute to True. When this happens, the test output includes 'True' as the reason. TrQTrueN)r[rErrrrrrer{s r)test_booleanSkipzSkipTests.test_booleanSkipjsr DIt,,, %%''2244Q7 (((((r,c ddz n#t$r }|}Yd}~nd}~wwxYw|j|j||jd|jdd }| |t|dS)z Skips can be raised as errors. When this happens, the error is included in the summary at the end of the test suite. r!rN rQr) rtr[rErrjoinrrrrrerKr(rhrrQs r)test_exceptionSkipzSkipTests.test_exceptionSkipus   EEE   EEEEEE  DIu--- 4;//11<<>>qsCDDJJLL U,,,,, N) r8r9r:r;r\rBrFrIrOrRrUrZr<r,r)r<r<<s/// !!! 999<<< E E E888 ) ) ) - - - - -r,r<ceZdZdZdZdZdS)UncleanWarningSkipTestszh Tests for skips on a L{reporter.Reporter} wrapped by an L{UncleanWarningsReporterWrapper}. clt|t|j|_dSr&)r<r\rr[r7s r)r\zUncleanWarningSkipTests.setUp)4T[AA r,c4t|jjS)z} Get the number of skips that happened to a reporter inside of an unclean warnings reporter wrapper. )rDr-rArs r)rBz!UncleanWarningSkipTests._getSkipss 6+1222r,N)r8r9r:r;r\rBr<r,r)r]r]s? BBB33333r,r]cfeZdZdZdZdZdZdZdZdZ dZ d Z d Z d Z d Zd ZdZdZdS) TodoTestsz= Tests for L{reporter.Reporter}'s handling of todos. ct|_tj|j|_t jd|_dSrr>r7s r)r\zTodoTests.setUpr?r,c|jS)zH Get the expected failures that happened to a reporter. )expectedFailuresrs r) _getTodoszTodoTests._getTodoss &&r,c|jS)zK Get the unexpected successes that happened to a reporter. )unexpectedSuccessesrs r)_getUnexpectedSuccessesz!TodoTests._getUnexpectedSuccessess ))r,c |j|jtt t d|t||jddS)zh L{reporter.Reporter} accumulates the expected failures that it is notified of. todo!r!N) r[addExpectedFailurerrrtrrerDrfr7s r)rFzTodoTests.test_accumulationso && Iwy{{++Xg->->    T^^DK88991=====r,ctt}|j|j|||j\\}}}|||j||||t|ttddS)z If no C{Todo} is provided to C{addExpectedFailure}, then L{reporter.Reporter} makes up a sensible default. This allows standard Python unittests to use Twisted reporters. Test expected to failN) rrtr[rlrrfrereprr)r(rjrrtodos r)test_noTodoProvidedzTodoTests.test_noTodoProvideds)++&& &&ty'::: $t{ ; ; $t ty))) ((( dT(3J*K*K%L%LMMMMMr,c|j|jtt t d|d|jdS)zU A test run is still successful even if there are expected failures. rkTN)r[rlrrrtrrerHr7s r)rIzTodoTests.test_successsg && Iwy{{++Xg->->    t{88::;;;;;r,c0|j|jtd|d|j|t ||jddS)z A test which is marked as todo but succeeds will have an unexpected success reported to its result. A test run is still successful even when this happens. zHeya!Tr!N)r[addUnexpectedSuccessrrrerHrDrir7s r)test_unexpectedSuccessz TodoTests.test_unexpectedSuccesss~ ((HW4E4EFFF t{88::;;; T99$+FFGGKKKKKr,c2|j|j||j\\}}|||j|t |t t ddS)aL A test which is marked as todo but succeeds will have an unexpected success reported to its result. A test run is still successful even when this happens. If no C{Todo} is provided, then we make up a sensible default. This allows standard Python unittests to use Twisted reporters. rnN)r[rtrrirerorr(rrps r)test_unexpectedSuccessNoTodoz&TodoTests.test_unexpectedSuccessNoTodos ((33355dkBB$ ty))) dT(3J*K*K%L%LMMMMMr,c|j|jtt t d|j|j d}d}| | || |t|dddS)z{ The reporter's C{printSummary} method should print the number of expected failures that occurred. rDrrKNz(expectedFailures=1))r[rlrrrtrrrrrrCrLrerDrrMs r)rOzTodoTests.test_summarys && Iwy{{++Xm-D-D    %%''2244R8 ))&11222 F .44668NOOOOOr,cx|j|jtt t d|j|j d }| |ddS)zd The reporter's L{printErrors} method should include the value of the Todo. rDrQzReason: 'some reason'N) r[rlrrrtrrrrrrrer{s r)rRzTodoTests.test_basicErrorss && Iwy{{++Xm-D-D    %%''2244Q7==?? !899999r,c|j|jtt d|t|jjdS)z Booleans CAN'T be used as the value of a todo. Maybe this sucks. This is a test for current behavior, not a requirement. TN)r[rlrrrtrsrr7s r)test_booleanTodozTodoTests.test_booleanTodosM &&ty')++2F2FMMM )T[%566666r,c ddz n#t$r }|}Yd}~nd}~wwxYw|j|jt |t d|jd|j dd }| t||vdS)zk The exception for expected failures should be shown in the C{printErrors} output. r!rNrkrWrQ)rtr[rlrrrrrXrrrrrCrKrYs r)test_exceptionTodozTodoTests.test_exceptionTodos   EEE   EEEEEE  &&ty'%..(7BSBSTTT 4;//11<<>>qrrBCCIIKK E f,-----r[cGddt}|d}||j|t ||jddS)t Tests that use the standard library C{expectedFailure} feature worth with Trial reporters. c$eZdZedZdS)@TodoTests.test_standardLibraryCompatibilityFailure..Testc0|ddS)Nrj)failr7s r)rzJTodoTests.test_standardLibraryCompatibilityFailure..Test.test_fails )$$$$$r,N)r8r9r:r rr<r,r)Testrs-  % %_ % % %r,rrr!N)StdlibTestCaserr[rerDrfr(rrs r)(test_standardLibraryCompatibilityFailurez2TodoTests.test_standardLibraryCompatibilityFailures  % % % % %> % % % tK    T^^DK88991=====r,cGddt}|d}||j|t ||jddS)rc$eZdZedZdS)@TodoTests.test_standardLibraryCompatibilitySuccess..TestcdSr&r<r7s r)rIzMTodoTests.test_standardLibraryCompatibilitySuccess..Test.test_success+sr,N)r8r9r:r rIr<r,r)rr*s-   _   r,rrIr!N)rrr[rerDrirs r)(test_standardLibraryCompatibilitySuccessz2TodoTests.test_standardLibraryCompatibilitySuccess$s      >    tN##  T99$+FFGGKKKKKr,N)r8r9r:r;r\rfrirFrqrIrurxrOrRr|r~rrr<r,r)rbrbs/// ''' *** >>> N N N<<<LLL N N N P P P : : :777 . . . > > > L L L L Lr,rbc$eZdZdZdZdZdZdS)UncleanWarningTodoTestszJ Tests for L{UncleanWarningsReporterWrapper}'s handling of todos. clt|t|j|_dSr&)rbr\rr[r7s r)r\zUncleanWarningTodoTests.setUp9r_r,c|jjS)zt Get the todos that happened to a reporter inside of an unclean warnings reporter wrapper. )r-rers r)rfz!UncleanWarningTodoTests._getTodos=s '88r,c|jjS)z Get the number of unexpected successes that happened to a reporter inside of an unclean warnings reporter wrapper. )r-rhrs r)riz/UncleanWarningTodoTests._getUnexpectedSuccessesDs ';;r,N)r8r9r:r;r\rfrir<r,r)rr4sNBBB999<<<<|j||fdSr&)rappend)r(textcolors r)r/zMockColorizer.writeTs   &&&&&r,N)r8r9r:r;r*r/r<r,r)rrLs<'''''r,rc8eZdZdZdZdZdZdZdZdZ dS) TreeReporterTestsctjd|_t|_t j|j|_t|j|j_ |jj j |_ dSr) rr4rrrrrr[r _colorizerrr7s r)r\zTreeReporterTests.setUpYsYN:.. jj +DK88 !.t{!;!; ;)-r,cP ddz n#t$rt}YnwxYw|S)Nr!r)rr)r(rs r) makeErrorzTreeReporterTests.makeError`s?  EEE     AAA s ##c~|j|j|j||jd|jjdf||j d ddS)zw The summary in case of success should have a good count of successes and be colored properly. r!PASSEDrz (successes=1)N) r[ addSuccessrrrerSUCCESSrrrrr7s r)test_summaryColoredSuccessz,TreeReporterTests.test_summaryColoredSuccessgs ty)))  !t{':H&EFFF  K " " - - / / 3 9 9 ; ;_     r,c td#t$r/|j|tjYnwxYw|j||jd|jjdf||j d ddS)zt The summary in case of failure should have a good count of errors and be colored properly. r_r!FAILEDrz (errors=1)N) r`r[rarbrcrrerFAILURErrrrr7s r)test_summaryColoredFailurez,TreeReporterTests.test_summaryColoredFailuress  7u%% % 7 7 7 K s|~~ 6 6 6 6 6 7  !t{':H&EFFF --//::<.formattersq66D= r,rrFOOr!rzW%(double separator)s FOO 1 %(first)s %(second)s %(double separator)s FOO 2 %(third)s )zdouble separatorfirstsecondthirdN) rr4rr[ _printResultsrerr_doubleSeparatorr6)r(rrrrs r)test_printResultsz#TreeReporterTests.test_printResultss ! ! !z** ++!*-- !! UAJ eQZ8)     K " " %)K$@ ))++       r,N) r8r9r:r\rrrrrrr<r,r)rrXs...     X X X E E E111,# # # # # r,rcleZdZUdZejZeej e d<dZ dZ dZ dZdZdZd Zd S) ReporterInterfaceTestsas Tests for the bare interface of a trial reporter. Subclass this test case and provide a different 'resultFactory' to test that a particular reporter implementation will work with the rest of Trial. @cvar resultFactory: A callable that returns a reporter to be tested. The callable must take the same parameters as L{reporter.Reporter}. resultFactoryctjd|_t|_t j|_||j|j|_ dS)Nr publisher) rr4rrrr LogPublisherrrr[r7s r)r\zReporterInterfaceTests.setUpsPN:.. jj )++(((OO r,cF|d|jjdS)z4 shouldStop is False to begin with. FN)rer[ shouldStopr7s r)test_shouldStopInitiallyFalsez4ReporterInterfaceTests.test_shouldStopInitiallyFalses%  677777r,cx|j|d|jjdS)zG shouldStop becomes True soon as someone calls stop(). TN)r[stoprerr7s r)test_shouldStopTrueAfterStopz3ReporterInterfaceTests.test_shouldStopTrueAfterStops9  t{566666r,c`|d|jdS)zS wasSuccessful() is True when there have been no results reported. TN)rer[rHr7s r)test_wasSuccessfulInitiallyTruez6ReporterInterfaceTests.test_wasSuccessfulInitiallyTrues. t{88::;;;;;r,c|j|j|d|jdS)zg wasSuccessful() is True when there have been only successes, False otherwise. TN)r[rrrerHr7s r)$test_wasSuccessfulTrueAfterSuccessesz;ReporterInterfaceTests.test_wasSuccessfulTrueAfterSuccessessF ty))) t{88::;;;;;r,c ddz nA#t$r4|j|jt jYnwxYw|d|jdS)zP wasSuccessful() becomes False after errors have been reported. r!rFN)rr[rarrbrcrerHr7s r)"test_wasSuccessfulFalseAfterErrorsz9ReporterInterfaceTests.test_wasSuccessfulFalseAfterErrorss} < EEE  < < < K CLNN ; ; ; ; ; <  9 9 ; ;<<<< IIe    $ > > > K " "49clnn = = = = = >  9 9 ; ;<<<<>#3F3Fr3JG T T     r,cV||dS)zj A warning emitted twice within a single test is only written to the stream once. N)rr7s r)test_duplicateWarningSuppressedz-ReporterTests.test_duplicateWarningSuppressed>s0  r,cN|d}|j||jd|j||jd|j|j||j||jd|j|dS)zn A warning emitted again after a new test has started is written to the stream again. test_warningEmittedForNewTestrN) __class__r[rrrrrrr(rs r)rz+ReporterTests.test_warningEmittedForNewTestIs  ~~=>> d###      T""" d###   r,cN|j|jd|j|jtdddd||j ddS) zl L{reporter.Reporter} stops observing log events when its C{done} method is called. rz some messagerz file/name.pyrr@N) r[rrrrrrrrerr7s r)test_stopObservingz ReporterTests.test_stopObservingis    ">220#    --//44444r,N) r8r9r:r;r\rrrrrrrr<r,r)rr s--- <<< C C C   "   @55555r,rceZdZdZdS)SafeStreamTestsct}t|}tj|}|d||ddS)z Test that L{reporter.SafeStream} successfully write to its original stream even if an interrupt happens during the write. rN)rr$r SafeStreamr/rer)r(rbrokensafes r) test_safezSafeStreamTests.test_safe{sb f%%"6** 7 **G44444r,N)r8r9r:rr<r,r)rrzs# 5 5 5 5 5r,rceZdZUdZejZeej e d<dZ dZ dZ dZdZdZd Zd Zd Zd Zd ZdZdZdZdZdS)SubunitReporterTestszx Tests for the subunit reporter. This just tests that the subunit reporter implements the basic interface. rctjtdtjd|_t |_tj |_ | |j|j |_ dS)Nz2Subunit not installed, cannot test SubunitReporterrr) rTestProtocolClientrrr4rrrrrrrr[r7s r)r\zSubunitReporterTests.setUpsh  & .OPP PN:.. ii )++(((OO r,cZt}tj|}t|||i|}|}t|j||i|}||||||jdS)a Assert that 'methodName' on L{SubunitReporter} forwards to the equivalent method on subunit. Checks that the return value from subunit is returned from the L{SubunitReporter} and that the reporter writes the same data to its stream as subunit does to its own. Assumes that the method on subunit has the same name as the method on L{SubunitReporter}. N)rrrgetattrrr[rer) r( methodNameargskwargsr subunitClient subunitReturn subunitOutputreporterReturns r)assertForwardsToSubunitz,SubunitReporterTests.assertForwardsToSubunits 3F;; : z::DKFKK )) 9j994J6JJ 777  (<(<(>(>?????r,ct||d}|dSt|D]I} t|||t|||1#t t f$rYdSwxYwdS)a Remove 'methodName' from 'klass'. If 'klass' does not have a method named 'methodName', then 'removeMethod' succeeds silently. If 'klass' does have a method named 'methodName', then it is removed using delattr. Also, methods of the same name are removed from all base classes of 'klass', thus removing the method entirely. @param klass: The class to remove the method from. @param methodName: The name of the method to remove. N)rrdelattr addCleanupsetattrAttributeErrorrO)r(klassrmethodbases r) removeMethodz!SubunitReporterTests.removeMethods D11 > F5MM C CD Cj)))z6BBBB#I.     C CsAA,+A,c|tjd ddz nB#t$r5|j|jtjdYnwxYw|j }|j d|j d|j |j|j }|||dS)z Some versions of subunit don't have "addExpectedFailure". For these versions, we report expected failures as successes. rlr!rrpN)rrrrr[rlrrbrcrrrrrre)r(expectedFailureOutput successOutputs r).test_subunitWithoutAddExpectedFailureInstalledzCSubunitReporterTests.test_subunitWithoutAddExpectedFailureInstalleds (57KLLL N EEE  N N N K * *49clnnf M M M M M N $ 4 4 6 6 Q  ty))) ,,..  (=>>>>>s(.addExpectedFailures! # * *D%= 9 9 9 9 9r,r!rrpN)r[_subunitrlrrbrcrre)r(rlrcr$s @r)$test_addExpectedFailurePassedThroughz9SubunitReporterTests.test_addExpectedFailurePassedThroughs #% : : : : : 3E / H EEE  H H H|~~H K * *49h G G G G G H 0DIx3H2IJJJJJs!>A"!A"cgfd}||jj_|j|jd||jdfgdS)z Some versions of subunit have "addSkip". For these versions, when we call 'addSkip' on the test result, we pass the test and reason through to the subunit client. c6||fdSr&r#)rr addSkipCallss r)rEzESubunitReporterTests.test_addSkipSendsSubunitAddSkip..addSkips!   v / / / / /r,rN)r[r%rErre)r(rEr)s @r)test_addSkipSendsSubunitAddSkipz4SubunitReporterTests.test_addSkipSendsSubunitAddSkipsr   0 0 0 0 0 (/ $ DIx000 H(='>?????r,c|j|d|jdS)z The subunit reporter doesn't need to print out a summary -- the stream of results is everything. Thus, done() does nothing. r,N)r[rrerrr7s r)test_doneDoesNothingz)SubunitReporterTests.test_doneDoesNothing sB  dk224455555r,c<|d|jdS)zT SubunitReporter.startTest() sends the subunit 'startTest' message. rNrrr7s r)#test_startTestSendsSubunitStartTestz8SubunitReporterTests.test_startTestSendsSubunitStartTests" $$[$)<<<<t}tj|}||j|}|j|j|||j dS)z SubunitReporter.addFailure() sends the subunit 'addSuccess' message, since subunit doesn't model unexpected success. N) rrrrrrr[rtrer)r(rr r s r)/test_addUnexpectedSuccessSendsSubunitAddSuccesszDSubunitReporterTests.test_addUnexpectedSuccessSendsSubunitAddSuccess:s  3F;;   +++))  ((333  (<(<(>(>?????r,ctjd}||j|j}|d|dS)zC Load-time errors are reported like normal errors. doesntexists doesntexistN)rrrrr[rrassertIn)r(rrQs r)test_loadTimeErrorsz(SubunitReporterTests.test_loadTimeErrorsFsc ""--m<< %%'' nf-----r,N)r8r9r:r;rSubunitReporterrrrrrr\rrrr r&r*r,r/r1r3r5r8r:r>r<r,r)rrs6 -5,DM4()DDDPPP@@@*CCC2???" 4 4 4KKK*@@@"666=== <<< >>> CCCGGG @ @ @ . . . . .r,rceZdZdZdZdS) SubunitReporterNotInstalledTestszD Test behaviour when the subunit reporter is not installed. ct}|tdd|ttj|}|dt|dS)z If subunit is not installed, TestProtocolClient will be None, and SubunitReporter will raise an error when you try to construct it. rNzSubunit not available)rpatchrrsrtr?rerK)r(rrhs r)test_subunitNotInstalledz9SubunitReporterNotInstalledTests.test_subunitNotInstalledWsa  814888   i)A6 J J 0#a&&99999r,N)r8r9r:r;rDr<r,r)rArARs-:::::r,rAc>eZdZUejZeeje d<dS)TimingReporterTestsrN) r8r9r:rTimingTextReporterrrrrrr<r,r)rFrFbs-,4,GM4()GGGGGr,rFcFeZdZdZdZdZd dZdZdZd dZ d Z d Z dS) LoggingReporterzJ Simple reporter that stores the last test that was passed to it. cHtjj|g|Ri|d|_dSr&)rrzr*r)r(r r s r)r*zLoggingReporter.__init__ks1"49$999&999 r,c||_dSr&r)r(rrs r)razLoggingReporter.addErroror+r,Nc||_dSr&rL)r(rrjrps r)rlz"LoggingReporter.addExpectedFailurerr+r,c||_dSr&rL)r(rrjs r)rnzLoggingReporter.addFailureur+r,c||_dSr&rL)r(rskips r)rEzLoggingReporter.addSkipxr+r,c||_dSr&rLrws r)rtz$LoggingReporter.addUnexpectedSuccess{r+r,c||_dSr&rLrs r)rzLoggingReporter.startTest~r+r,c||_dSr&rLrs r)rzLoggingReporter.stopTestr+r,r&) r8r9r:r;r*rarlrnrErtrrr<r,r)rIrIfsr,rIcfeZdZdZdZdZdZdZdZdZ dZ d Z d Z d Z d Zd ZdZdZdS)AdaptedReporterTestsz L{reporter._AdaptedReporter} is a reporter wrapper that wraps all of the tests it receives before passing them on to the original reporter. c8||_dSr&)getWrappedResult wrappedResultr7s r)r\zAdaptedReporterTests.setUps!2244r,c*|Sr&)r6rs r) _testAdapterz!AdaptedReporterTests._testAdapterswwyyr,cl||jj||dSr&)rer-rrZ)r(rXrs r) assertWrappedz"AdaptedReporterTests.assertWrappeds3 8=t?P?PQU?V?VWWWWWr,cD |#t$rtcYSwxYw)z Return a L{Failure} from raising the given exception. @param exceptionInstance: The exception to raise. @return: L{Failure} ) BaseExceptionr)r(exceptionInstances r) getFailurezAdaptedReporterTests.getFailures8 # #   99    s cRt}tj||jSr&)rIr_AdaptedReporterrZrs r)rWz%AdaptedReporterTests.getWrappedResults# ""(1BCCCr,c|j||t||j|dS)zG C{addError} wraps its test with the provided adapter. N)rXrar`r`r\r7s r) test_addErrorz"AdaptedReporterTests.test_addErrorsL ##D$//,..*I*IJJJ 4-t44444r,c|j||t||j|dS)zI C{addFailure} wraps its test with the provided adapter. N)rXrnr`AssertionErrorr\r7s r)test_addFailurez$AdaptedReporterTests.test_addFailuresN %%dDOONAnsiColorizerTests.test_supportedSetupTerm..fakecursesrc&|xjdz c_dSrr\r7s r) setuptermzHAnsiColorizerTests.test_supportedSetupTerm..fakecurses.setupterm a r,c<|jrdS|)NrQ)r\rr(rfs r)tigetnumzGAnsiColorizerTests.test_supportedSetupTerm..fakecurses.tigetnums:'1**,,&r,Nr8r9r:r`rr\rrr<r,r) fakecursesrs< EE    ' ' ' ' 'r,rrr!N) rbrrCrrrrxrer\r(rs r)test_supportedSetupTermz*AnsiColorizerTests.test_supportedSetupTerms ' ' ' ' ' ' ' '!+  H /99*,,GGHHH /99*,,GGHHH X.4a88888r,cGdd}|tjd<|tjt dS)z L{reporter._AnsiColorizer.supported} returns C{False} and doesn't try to call C{curses.setupterm} if C{curses.tigetnum} returns something different than C{curses.error}. ceZdZeZdZdS)GAnsiColorizerTests.test_supportedTigetNumWrongError..fakecursesctr&) ValueErrorrs r)rzPAnsiColorizerTests.test_supportedTigetNumWrongError..fakecurses.tigetnum5s  ll"r,Nr8r9r:r`rrr<r,r)rr2s( E # # # # #r,rrNrrs r) test_supportedTigetNumWrongErrorz3AnsiColorizerTests.test_supportedTigetNumWrongError+sm # # # # # # # # !+  H 0:::<<HHIIIIIr,cGdd}|tjd<|tjt dS)z L{reporter._AnsiColorizer.supported} returns C{False} if C{curses.tigetnum} returns less than 2 supported colors. ceZdZeZdZdS)KAnsiColorizerTests.test_supportedTigetNumNotEnoughColor..fakecursescdSrr<rs r)rzTAnsiColorizerTests.test_supportedTigetNumNotEnoughColor..fakecurses.tigetnumDsqr,Nrr<r,r)rrAs( E     r,rrNrrs r)$test_supportedTigetNumNotEnoughColorz7AnsiColorizerTests.test_supportedTigetNumNotEnoughColor;sm          !+  H 0:::<<HHIIIIIr,c Gdd}|tjd<|tjt |tjdjddS)z L{reporter._AnsiColorizer.supported} returns C{False} if C{curses.tigetnum} raises an error, and calls C{curses.setupterm} once. c"eZdZeZdZdZdZdS)CAnsiColorizerTests.test_supportedTigetNumErrors..fakecursesrc&|xjdz c_dSrrr7s r)rzMAnsiColorizerTests.test_supportedTigetNumErrors..fakecurses.setuptermTrr,c*|r&)rrs r)rzLAnsiColorizerTests.test_supportedTigetNumErrors..fakecurses.tigetnumWsjjll"r,Nrr<r,r)rrPs< EE    # # # # #r,rrr!N) rbrrrrrrxrer\rs r)test_supportedTigetNumErrorsz/AnsiColorizerTests.test_supportedTigetNumErrorsJs  # # # # # # # #!+  H 0:::<<HHIII X.4a88888r,N) r8r9r:r;r\rrrrrrrr<r,r)rrs///...OOOJJJ9996JJJ J J J99999r,rc*eZdZdZdZdZdZdZdS)ExitWrapperTestsz- Tests for L{reporter._ExitWrapper}. cttd|_tjd|_t j|_t|j|_ | |j j dS)NzI am a Failurer) rrtrjrr4rrrZr[rwrappedrrr7s r)r\zExitWrapperTests.setUpdsky)9::;; N:.. )++ #DK00  011111r,c|j|j|j||jj||jj|j|jfgdS)zm L{reporter._ExitWrapper} causes a wrapped reporter to stop after its first failure. N) rrnrrjrCrrer[ror7s r)test_stopOnFailurez#ExitWrapperTests.test_stopOnFailureksd  4<888  /000 -DL0I/JKKKKKr,c|j|j|j||jj||jj|j|jfgdS)zk L{reporter._ExitWrapper} causes a wrapped reporter to stop after its first error. N) rrarrjrCrrer[rdr7s r)test_stopOnErrorz!ExitWrapperTests.test_stopOnErrortsd di666  /000 +ty$,.G-HIIIIIr,c|j|j|j||jj||jj|j|jfgdS)zy L{reporter._ExitWrapper} does not cause a wrapped reporter to stop after an unexpected success. N) rrtrrjrrrer[rhr7s r)#test_doesNotStopOnUnexpectedSuccessz4ExitWrapperTests.test_doesNotStopOnUnexpectedSuccess}sf ))$)T\BBB 0111 8DIt|;T:UVVVVVr,N)r8r9r:r;r\rrrr<r,r)rr_se222LLLJJJWWWWWr,r)Nr;r1rrFrbinspectriorrtypingrrrrrrr hamcrestr r r r twisted.pythonrtwisted.python.failurer twisted.trialrrrrtwisted.trial.reporterrrrrrtwisted.trial.unittestrrr_dist.test.matchersrrr matchersr"r$SynchronousTestCaser>rXrwr}rrrrrr2r<r]rbrrrrrrrrArFrzrIrUrxrrr<r,r)rs    A@@@@@@@@@@@******BBBBBBBBBBBBBBOOOOOOOO00000000;;;;;;;;;;IIIIIIIIII888888882NNNNN-NNN4)K)K)K)K)Kh2)K)K)KX?????O??? z z z z z *z z z z/B"JWJWJWJWJWX9JWJWJWZ.0.0.0.0.0*.0.0.0b?A?A?A?A?Ax3?A?A?ADF F F F F 4F F F R-----h2---:E-E-E-E-E-,E-E-E-P33333i333$[L[L[L[L[L,[L[L[L|<<<<^5^5^5^5^587^5^5^5B        g9g9g9g9g95g9g9g9T%W%W%W%W%Wx3%W%W%W%W%Wr,