403Webshell
Server IP : 138.197.176.125  /  Your IP : 216.73.217.54
Web Server : Apache/2.4.41 (Ubuntu)
System : Linux SuiteCRM-8 5.4.0-216-generic #236-Ubuntu SMP Fri Apr 11 19:53:21 UTC 2025 x86_64
User : root ( 0)
PHP Version : 8.3.19
Disable Function : NONE
MySQL : OFF  |  cURL : ON  |  WGET : ON  |  Perl : ON  |  Python : ON  |  Sudo : ON  |  Pkexec : ON
Directory :  /lib/python3/dist-packages/twisted/trial/test/__pycache__/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Command :

[ Back ]     

Current File : /lib/python3/dist-packages/twisted/trial/test/__pycache__/test_reporter.cpython-38.pyc
U

��W[T��@s�dZddlmZmZddlZddlZddlZddlZddlm	Z	ddl
mZddl
mZ
ddlmZmZddlmZdd	lmZdd
lmZm
Z
mZmZmZddlmZmZddlmZdd
lm Z m!Z!m"Z"ddlm#Z#ddl$m%Z%m&Z&e&r�ddl'm(Z(nddl)m)Z(Gdd�de*�Z+Gdd�de
j,�Z-Gdd�de
j,�Z.Gdd�de.�Z/Gdd�de-�Z0Gdd�de0�Z1Gdd�de
j,�Z2Gd d!�d!e-�Z3Gd"d#�d#e
j,�Z4Gd$d%�d%e
j,�Z5Gd&d'�d'e
j,�Z6Gd(d)�d)e
j,�Z7Gd*d+�d+e7�Z8Gd,d-�d-e
j,�Z9Gd.d/�d/e9�Z:Gd0d1�d1e*�Z;Gd2d3�d3e
j,�Z<Gd4d5�d5e
j,�Z=Gd6d7�d7e=�Z>Gd8d9�d9e
j,�Z?Gd:d;�d;e=�Z@Gd<d=�d=e
j,�ZAGd>d?�d?e>�ZBGd@dA�dAejC�ZDGdBdC�dCe
j,�ZEGdDdE�dEe*�ZFGdFdG�dGe
j,�ZGGdHdI�dIe
j,�ZHdS)Jz&
Tests for L{twisted.trial.reporter}.
�)�absolute_import�divisionN)�getmro)�expectedFailure)�TestCase)�log�reflect��Failure)�qual)�itrial�unittest�runner�reporter�util)�_ExitWrapper�UncleanWarningsReporterWrapper��	erroneous)�makeTodo�SkipTest�Todo)�sample)�NativeStringIO�_PY3)�BytesIO)�StringIOc@s0eZdZdZdZdZdd�Zdd�Zdd�Zd	S)
�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.
    FcCs
||_dS�N)�fObj)�selfr�r!�B/usr/lib/python3/dist-packages/twisted/trial/test/test_reporter.py�__init__0szBrokenStream.__init__cCs(|jr|j�|�Sd|_ttjd��dS)NTzInterrupted write)�writtenr�write�IOError�errno�EINTR)r �sr!r!r"r%3szBrokenStream.writecCs&|jr|j��Sd|_ttjd��dS)NTzInterrupted flush)�flushedr�flushr&r'r(�r r!r!r"r+9s
zBrokenStream.flushN)	�__name__�
__module__�__qualname__�__doc__r$r*r#r%r+r!r!r!r"r(src@seZdZdd�ZdS)�
StringTestc	Cs�ttd|��}|�t|�t|�kdt|�t|�f�tt�d��}tt||��D]t\}\}}|dkrjqRqRt	|t
�r�|�||d|||f�qRt	||�r�|�|�|�d||j
|f�qRtd|f��qRdS)Nz2Must have more observed than expectedlines %d < %d�zLine %d: %r not in %rz#Line %d: %r did not match string %rz$don't know what to do with object %r)�list�filter�
assertTrue�len�type�re�compile�	enumerate�zip�
isinstance�str�assertSubstring�match�pattern�	TypeError)r �expect�outputZREGEX_PATTERN_TYPEZline_numberZexp�outr!r!r"�stringComparisonAs.��

�

���zStringTest.stringComparisonN)r-r.r/rEr!r!r!r"r1@sr1c@s$eZdZdd�Zdd�Zdd�ZdS)�TestResultTestscCst��|_dSr)r�
TestResult�resultr,r!r!r"�setUpWszTestResultTests.setUpc
Csvztd��Wn8tk
rD}z|}|j�|t���W5d}~XYnX|jjdd}|�||j�|�t|j�dS�N�foor�)	�RuntimeErrorrH�addError�sys�exc_info�errors�assertEqual�valuer7�r �eZexcValue�failurer!r!r"�test_pyunitAddErrorZs$z#TestResultTests.test_pyunitAddErrorc
Cs|z|�d��Wn:|jk
rH}z|}|j�|t���W5d}~XYnX|jjdd}|�||j�|�|j|j�dSrJ)	�failureExceptionrH�
addFailurerOrP�failuresrRrSr7rTr!r!r"�test_pyunitAddFailurees$z%TestResultTests.test_pyunitAddFailureN)r-r.r/rIrWr[r!r!r!r"rFVsrFc@seZdZdd�ZdS)�ReporterRealtimeTestscCst�}tj|dd�|_dS)NT)Zrealtime)rr�ReporterrH�r rCr!r!r"rIrszReporterRealtimeTests.setUpN)r-r.r/rIr!r!r!r"r\qsr\c@sNeZdZe�d�Zdd�Zdd�Zdd�Zdd	�Z	d
d�Z
dd
�Zdd�ZdS)�ErrorReportingTestsz^=+$cCs$t��|_t�|_t�|j�|_dSr)r�
TestLoader�loaderrrCrr]rHr,r!r!r"rIzs
zErrorReportingTests.setUpcCs|�|�}|��|j��Sr)�	getResult�donerC�getvalue)r �suiterHr!r!r"�	getOutputs
zErrorReportingTests.getOutputcCs|�|j�|jSr)�runrH)r rer!r!r"rb�szErrorReportingTests.getResultc	Cs\tj}|j�|�}|�|���}|jddt�d�t�d�dd|j	|j
fg}|�||�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.
        �[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 methodz%s.%s.test_noopN)rZSynchronousTestFailureInSetUpraZ	loadClassrf�
splitlines�doubleSeparatorr8r9r.r-rE)r �clsrerCr?r!r!r"�test_formatErroredMethod�s�
z,ErrorReportingTests.test_formatErroredMethodcCsJ|j�d�}|�|���}|jddt�d�t�d�ddg}|�||�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_fail�[FAIL]riz2^\s+File .*erroneous\.py., line \d+, in test_fail$z^\s+self\.fail\("I fail"\)$z'twisted.trial.unittest.FailTest: I failN)ra�
loadByNamerfrjrkr8r9rE)r rerCr?r!r!r"�test_formatFailedMethod�s��	z+ErrorReportingTests.test_formatFailedMethodcCs�ddlm}t�|j�|�tj�}|�|�}d}ddd|fD]}|�	||�q<|�
t�d|�d�|j
t�d	�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.
        rrz0twisted.trial.test.erroneous.unexpectedExceptionz1/0�ZeroDivisionErrorzException raised:zFail(ed|ure in) example:z;Couldn't match 'Failure in example: ' or 'Failed example: 'z\[(ERROR|FAIL)\]N)�twisted.trial.testrr
ZdecorateraZloadDoctestsrZ	ITestCaserfr>r5r8�searchrkr9rErj)r rrerC�pathZ	substringrBr!r!r"�test_doctestError�s&
�
���z%ErrorReportingTests.test_doctestErrorcCs�ddlm}t�|��d�r&|�d��t�d�}|�|��	�}tt
�}|jddt�
d�t�
d	�d
d|jddt�
d
�t�
d�t�
d�t�
d�|ddg}|�||�dS)a-
        Check that errors in C{DelayedCall}s get reported, even if the
        test already has a failure.

        Only really necessary for testing the deprecated style of tests that
        use iterate() directly. See
        L{erroneous.DelayedCall.testHiddenException} for more details.
        r)�reactorztwisted.internet.asyncioreactorzhThis test does not work on the asyncio reactor, as the traceback comes from inside asyncio, not Twisted.ZtestHiddenExceptionrnriz<^\s+File .*erroneous\.py., line \d+, in testHiddenException$zD^\s+self\.fail\("Deliberate failure to mask the hidden exception"\)$zPtwisted.trial.unittest.FailTest: Deliberate failure to mask the hidden exceptionz<twisted.trial.test.erroneous.DelayedCall.testHiddenExceptionrhz^\s+File .* in runUntilCurrentz^\s+.*z*^\s+File .*erroneous\.py", line \d+, in goz1^\s+raise RuntimeError\(self.hiddenExceptionMsg\)z: something blew upN)Ztwisted.internetrvrr�
startswithZskipTestrZDelayedCallrfrjrMrkr8r9rE)r rv�testrCZ	errorQualr?r!r!r"�test_hiddenException�s4	�
�z(ErrorReportingTests.test_hiddenExceptionN)
r-r.r/r8r9rkrIrfrbrmrpruryr!r!r!r"r_ws
r_c@seZdZdZdd�ZdS)�(UncleanWarningWrapperErrorReportingTestsz�
    Tests that the L{UncleanWarningsReporterWrapper} can sufficiently proxy
    IReporter failure and error reporting methods to a L{reporter.Reporter}.
    cCs(t��|_t�|_tt�|j��|_dSr)	rr`rarrCrrr]rHr,r!r!r"rI�s


�z.UncleanWarningWrapperErrorReportingTests.setUpN)r-r.r/r0rIr!r!r!r"rz�srzc@sLeZdZdd�Zdd�Zdd�Zdd�Zd	d
�Zdd�Zd
d�Z	dd�Z
dS)�TracebackHandlingTestscCs^t�}t�|�}|�|�|j|j}|�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.
        rLr)
rrr]rgrZrQrRr6�_trimFrames�frames)r rx�streamrHZbadsr!r!r"�getErrorFramess	

z%TracebackHandlingTests.getErrorFramescCs�t||�D]`\}}|�|d|d�tj�|d�d�tj�}|d�d�}|�|t|�d�|�q
|�t|�t|��dS)NrrL�/)r;rR�osrt�splitext�split�sepr6)r ZobservedFramesZexpectedFramesZobserved�expectedZobservedSegsZexpectedSegsr!r!r"�checkFramess�z"TracebackHandlingTests.checkFramescCs&t�d�}|�|�}|�|dg�dS)N�	test_fail)r��twisted/trial/test/erroneous�rZTestRegularFailrr��r rxr}r!r!r"�
test_basics


�z!TracebackHandlingTests.test_basiccCs(t�d�}|�|�}|�|ddg�dS)N�test_subfail)r�r�)Z
subroutiner�r�r�r!r!r"�test_subroutine"s

��z&TracebackHandlingTests.test_subroutinecCs&t�d�}|�|�}|�|dg�dS)z�
        C{_trimFrames} removes traces of C{_runCallbacks} when getting an error
        in a callback returned by a C{TestCase} based test.
        r�)Z_laterr�N�rZTestAsynchronousFailrr�r�r!r!r"�
test_deferred)s


�z$TracebackHandlingTests.test_deferredcCs t�d�}|�g|�g��dSr�rr]rRr|�r rHr!r!r"�
test_noFrames3s
z$TracebackHandlingTests.test_noFramescCs$t�d�}|�dg|�dg��dS)Nz
fake framer�r�r!r!r"�
test_oneFrame7s
z$TracebackHandlingTests.test_oneFramecCs&t�d�}|�|�}|�|dg�dS)z�
        C{_trimFrames} removes traces of C{runWithWarningsSuppressed} from
        C{utils} when a synchronous exception happens in a C{TestCase}
        based test.
        �test_exception)r�r�Nr�r�r!r!r"r�;s


�z%TracebackHandlingTests.test_exceptionN)r-r.r/rr�r�r�r�r�r�r�r!r!r!r"r{s	
r{c@s,eZdZdd�Zdd�Zdd�Zdd�Zd	S)
�FormatFailuresTestscCslztd��Wntk
r(t�|_YnXddddgdggddddgd	ggg|j_t�|_t�|j�|_dS)
NrKz
foo/bar.py�)�xr�)�yZorangeZqux�
)�aZtwo)�bZMCMXCIX)	rMr
�fr}rr~rr]rHr,r!r!r"rIHs�zFormatFailuresTests.setUpc	Cs:|j�|j�}|�ddt�d�dt�d�dg|���dS)Nriz#  File "foo/bar.py", line 5, in fooz^\s*$z$  File "foo/bar.py", line 10, in quxzRuntimeError: foo)rH�_formatFailureTracebackr�rEr8r9rj)r �tbr!r!r"�test_formatDefaultTs��z&FormatFailuresTests.test_formatDefaultcCs$d}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
)rHr�rR)r r�r�Z	formattedr!r!r"�test_formatString^sz%FormatFailuresTests.test_formatStringcCs2|jjdd�}|j�|j�|�|jj|�dSr)r�r}rHr�rR)r r}r!r!r"�
test_mutationmsz!FormatFailuresTests.test_mutationN)r-r.r/rIr�r�r�r!r!r!r"r�Gs
r�c@sDeZdZdd�Zdd�Zdd�Zdd�Zd	d
�Zdd�Zd
d�Z	dS)�PyunitNamesTestscCst�|_t�d�|_dS�N�test_foo)rr~r�
PyunitTestrxr,r!r!r"rIuszPyunitNamesTests.setUpcCs2t�|j�}|�|j�|j��}|�|d�dS)Nz2twisted.trial.test.sample.PyunitTest.test_foo ... )r�VerboseTextReporterr~�	startTestrxrdrR�r rHrCr!r!r"�test_verboseReporterys
�z%PyunitNamesTests.test_verboseReportercCsNt�|j�}|�|j�|j��}|��d��}|�||�	|j�d�dS�N���z ...�
r�TreeReporterr~r�rxrdrj�striprR�getDescriptionr�r!r!r"�test_treeReporter�s

z"PyunitNamesTests.test_treeReportercCs(t�|j�}|�|j�}|�|d�dSr��rr�r~r�rxrRr�r!r!r"�test_getDescription�sz$PyunitNamesTests.test_getDescriptioncCsVt�|j�}|j�|�|��|j�����d�}|�	|dd�dddddg�dS)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
        � rLN�1�0)
r�MinimalReporterr~rxrg�
_printSummaryrdr�r�rRr�r!r!r"�test_minimalReporter�s
z%PyunitNamesTests.test_minimalReportercsfddddg�t�|j�}�fdd�|_|j�|�|��|j�����	d�}|d}|�
|d	�d
S)zt
        L{reporter.MinimalReporter} reports the time to run the tests as first
        data in its output.
        g�?g333333�?g�?gffffff�?cs
��d�S�Nr)�popr!��timesr!r"�<lambda>��z;PyunitNamesTests.test_minimalReporterTime.<locals>.<lambda>r�rz0.7N)rr�r~�_getTimerxrgr�rdr�r�rR)r rHrCZtimerr!r�r"�test_minimalReporterTime�sz)PyunitNamesTests.test_minimalReporterTimec	CsDt�|j�}|��|j�����d�}|�|ddddddg�dS)zv
        The summary of L{reporter.MinimalReporter} is a list of zeroes when no
        test is actually run.
        r�r�N)rr�r~r�rdr�r�rRr�r!r!r"�test_emptyMinimalReporter�sz*PyunitNamesTests.test_emptyMinimalReporterN)
r-r.r/rIr�r�r�r�r�r�r!r!r!r"r�tsr�c@s8eZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�ZdS)
�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.
    cCs,tt�dgdg��|_t�|_td�|_dS)NrK�bar�test_errorByDefault)r
rZDirtyReactorAggregateError�
dirtyErrorrrCr�rxr,r!r!r"rI�s
�zDirtyReactorTests.setUpcCsLtj|jd�}|�|j|j�|�t|j�d�|�|jdd|j�dS)zj
        L{DirtyReactorAggregateError}s are reported as errors with the default
        Reporter.
        �r~rLrN)	rr]rCrNrxr�rRr6rQr�r!r!r"r��sz%DirtyReactorTests.test_errorByDefaultcCs8ttj|jd��}|�t|j��tj|j	|j
|j�dS)z�
        L{DirtyReactorAggregateError}s are reported as warnings when using
        the L{UncleanWarningsReporterWrapper}.
        r�N)rrr]rC�assertWarns�UserWarningr��getErrorMessage�__file__rNrxr�r!r!r"�test_warningsEnabled�s��z&DirtyReactorTests.test_warningsEnabledcCsHttj|jd��}|�t|j��tj|j	|j
|j�|�|jj
g�dS)z�
        L{DirtyReactorAggregateError}s are I{not} reported as errors if the
        L{UncleanWarningsReporterWrapper} is used.
        r�N)rrr]rCr�r�r�r�r�rNrxrR�_originalReporterrQr�r!r!r"�test_warningsMaskErrors�s��z)DirtyReactorTests.test_warningsMaskErrorscCs�ttj|jd��}|�|j|jj|jjdf�|�	t
|jj�d�|�	|jjddj|jj�|�	|jjddj|jj�dS)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�NrLr)
rrr]rCrNrxr�r7rSrRr6r�rQr�r!r!r"�test_dealsWithThreeTuples�s����z+DirtyReactorTests.test_dealsWithThreeTuplesN)	r-r.r/r0rIr�r�r�r�r!r!r!r"r��s
r�c@s4eZdZdd�Zdd�Zdd�Zdd�Zd	d
�ZdS)�TrialNamesTestscCst�|_t�d�|_dSr�)rr~r�FooTestrxr,r!r!r"rIszTrialNamesTests.setUpcCs<t�|j�}|�|j�|j��}|�||j��d�dS)Nz ... )rr�r~r�rxrdrR�idr�r!r!r"r�s
z$TrialNamesTests.test_verboseReportercCsNt�|j�}|�|j�|j��}|��d��}|�||�	|j�d�dSr�r�r�r!r!r"r�s

z!TrialNamesTests.test_treeReportercCs"t�|j�}|�|�|�d�dS)zA docstring�test_treeReporterWithDocstringsN)rr�r~rRr�r�r!r!r"r�s�z/TrialNamesTests.test_treeReporterWithDocstringscCs(t�|j�}|�|j�}|�|d�dSr�r�r�r!r!r"r�sz#TrialNamesTests.test_getDescriptionN)r-r.r/rIr�r�r�r�r!r!r!r"r�s
r�c@sPeZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dd�Z
dd�ZdS)�	SkipTestsz=
    Tests for L{reporter.Reporter}'s handling of skips.
    cCs&t�|_t�|j�|_t�d�|_dSr��rr~rr]rHrr�rxr,r!r!r"rI%szSkipTests.setUpcCs
t|j�S)zF
        Get the number of skips that happened to a reporter.
        )r6�skipsr�r!r!r"�	_getSkips*szSkipTests._getSkipscCs(|j�|jd�|�|�|j�d�dS)N�some reasonrL)rH�addSkiprxrRr�r,r!r!r"�test_accumulation0szSkipTests.test_accumulationcCs&|j�|jd�|�d|j���dS)Nr�T)rHr�rxrR�
wasSuccessfulr,r!r!r"�test_success4szSkipTests.test_successcCs`|j�|jd�|j��|j����d}d}|�|�|��|�	|t
|�d���d�dS)z�
        The summary of a successful run with skips indicates that the test
        suite passed and includes the number of skips.
        r�r��PASSED Nz	(skips=1))rHr�rxrcr~rdrjr5rwrRr6r��r rC�prefixr!r!r"�test_summary9s
zSkipTests.test_summarycCs@|j�|jd�|j��|j����d}|�|��d�dS)zw
        The output at the end of a test run with skips includes the reasons
        for skipping those tests.
        r��N)	rHr�rxrcr~rdrjrRr�r^r!r!r"�test_basicErrorsFs
zSkipTests.test_basicErrorscCs<|j�|jd�|j��|j����d}|�|d�dS)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.
        Tr��TrueN)rHr�rxrcr~rdrjrRr^r!r!r"�test_booleanSkipQs
zSkipTests.test_booleanSkipc
Cs�zddWn&tk
r2}z|}W5d}~XYnX|j�|j|�|j��d�|j����dd���	�}|�
|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.
        rLrN�
r�r�)�	ExceptionrHr�rxrc�joinr~rdrjr�rRr=�r rU�errorrCr!r!r"�test_exceptionSkip]s
 zSkipTests.test_exceptionSkipN)r-r.r/r0rIr�r�r�r�r�r�r�r!r!r!r"r�!s
r�c@s eZdZdZdd�Zdd�ZdS)�UncleanWarningSkipTestszh
    Tests for skips on a L{reporter.Reporter} wrapped by an
    L{UncleanWarningsReporterWrapper}.
    cCst�|�t|j�|_dSr)r�rIrrHr,r!r!r"rIqs
zUncleanWarningSkipTests.setUpcCst|jj�S)z}
        Get the number of skips that happened to a reporter inside of an
        unclean warnings reporter wrapper.
        )r6r�r�r�r!r!r"r�usz!UncleanWarningSkipTests._getSkipsN)r-r.r/r0rIr�r!r!r!r"r�lsr�c@s�eZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dd�Z
dd�Zdd�Zdd�Z
dd�Zdd�Zdd�Zdd�ZdS)�	TodoTestsz=
    Tests for L{reporter.Reporter}'s handling of todos.
    cCs&t�|_t�|j�|_t�d�|_dSr�r�r,r!r!r"rI�szTodoTests.setUpcCs|jS)zH
        Get the expected failures that happened to a reporter.
        )�expectedFailuresr�r!r!r"�	_getTodos�szTodoTests._getTodoscCs|jS)zK
        Get the unexpected successes that happened to a reporter.
        )�unexpectedSuccessesr�r!r!r"�_getUnexpectedSuccesses�sz!TodoTests._getUnexpectedSuccessescCs8|j�|jtt��td��|�t|�|j��d�dS)zh
        L{reporter.Reporter} accumulates the expected failures that it
        is notified of.
        �todo!rLN)	rH�addExpectedFailurerxr
r�rrRr6r�r,r!r!r"r��s�zTodoTests.test_accumulationcCsdtt��}|j�|j|�|�|j�\\}}}|�||j�|�||�|�t|�ttd���dS)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)	r
r�rHr�rxr�rR�reprr)r rVrxr��todor!r!r"�test_noTodoProvided�s
zTodoTests.test_noTodoProvidedcCs2|j�|jtt��td��|�d|j���dS)zU
        A test run is still successful even if there are expected failures.
        r�TN)rHr�rxr
r�rrRr�r,r!r!r"r��s�zTodoTests.test_successcCsB|j�|jtd��|�d|j���|�t|�|j��d�dS)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!TrLN)rH�addUnexpectedSuccessrxrrRr�r6r�r,r!r!r"�test_unexpectedSuccess�sz TodoTests.test_unexpectedSuccesscCsJ|j�|j�|�|j�\\}}|�||j�|�t|�ttd���dS)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.
        r�N)rHr�rxr�rRr�r�r rxr�r!r!r"�test_unexpectedSuccessNoTodo�s	z&TodoTests.test_unexpectedSuccessNoTodocCsl|j�|jtt��td��|j��|j���	�d}d}|�
|�|��|�|t
|�d���d�dS)z{
        The reporter's C{printSummary} method should print the number of
        expected failures that occurred.
        r�r�r�Nz(expectedFailures=1))rHr�rxr
r�rrcr~rdrjr5rwrRr6r�r�r!r!r"r��s�
�zTodoTests.test_summarycCsL|j�|jtt��td��|j��|j���	�d�
�}|�|d�dS)zd
        The reporter's L{printErrors} method should include the value of the
        Todo.
        r�r�zReason: 'some reason'N)rHr�rxr
r�rrcr~rdrjr�rRr^r!r!r"r��s�
zTodoTests.test_basicErrorscCs,|j�|jtt��d�|�t|jj�dS)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)rHr�rxr
r��assertRaisesrcr,r!r!r"�test_booleanTodo�szTodoTests.test_booleanTodoc
Cs�zddWn&tk
r2}z|}W5d}~XYnX|j�|jt|�td��|j��d�|j�	��
�dd����}|�t
|�|k�dS)zk
        The exception for expected failures should be shown in the
        C{printErrors} output.
        rLrNr�r�r�)r�rHr�rxr
rrcr�r~rdrjr�r5r=r�r!r!r"�test_exceptionTodo�s�
 zTodoTests.test_exceptionTodocCs@Gdd�dt�}|d�}|�|j�|�t|�|j��d�dS)�t
        Tests that use the standard library C{expectedFailure} feature worth
        with Trial reporters.
        c@seZdZedd��ZdS)z@TodoTests.test_standardLibraryCompatibilityFailure.<locals>.TestcSs|�d�dS)NrV)�failr,r!r!r"r�
szJTodoTests.test_standardLibraryCompatibilityFailure.<locals>.Test.test_failN)r-r.r/rr�r!r!r!r"�Testsr�r�rLN)�StdlibTestCasergrHrRr6r��r r�rxr!r!r"�(test_standardLibraryCompatibilityFailuresz2TodoTests.test_standardLibraryCompatibilityFailurecCs@Gdd�dt�}|d�}|�|j�|�t|�|j��d�dS)r�c@seZdZedd��ZdS)z@TodoTests.test_standardLibraryCompatibilitySuccess.<locals>.TestcSsdSrr!r,r!r!r"r�szMTodoTests.test_standardLibraryCompatibilitySuccess.<locals>.Test.test_successN)r-r.r/rr�r!r!r!r"r�sr�r�rLN)rrgrHrRr6r�rr!r!r"�(test_standardLibraryCompatibilitySuccesssz2TodoTests.test_standardLibraryCompatibilitySuccessN)r-r.r/r0rIr�r�r�r�r�r�r�r�r�r�r�rrr!r!r!r"r�~s
		r�c@s(eZdZdZdd�Zdd�Zdd�ZdS)	�UncleanWarningTodoTestszJ
    Tests for L{UncleanWarningsReporterWrapper}'s handling of todos.
    cCst�|�t|j�|_dSr)r�rIrrHr,r!r!r"rI+s
zUncleanWarningTodoTests.setUpcCs|jjS)zt
        Get the  todos that happened to a reporter inside of an unclean
        warnings reporter wrapper.
        )r�r�r�r!r!r"r�0sz!UncleanWarningTodoTests._getTodoscCs|jjS)z�
        Get the number of unexpected successes that happened to a reporter
        inside of an unclean warnings reporter wrapper.
        )r�r�r�r!r!r"r�8sz/UncleanWarningTodoTests._getUnexpectedSuccessesN)r-r.r/r0rIr�r�r!r!r!r"r&src@s eZdZdZdd�Zdd�ZdS)�
MockColorizerzR
    Used by TreeReporterTests to make sure that output is colored correctly.
    cCs
g|_dSr)r)r r~r!r!r"r#FszMockColorizer.__init__cCs|j�||f�dSr)r�append)r �textZcolorr!r!r"r%JszMockColorizer.writeN)r-r.r/r0r#r%r!r!r!r"rAsrc@sDeZdZdd�Zdd�Zdd�Zdd�Zd	d
�Zdd�Zd
d�Z	dS)�TreeReporterTestscCs@t�d�|_t�|_t�|j�|_t|j�|j_	|jj	j
|_
dSr�)rr�rxrr~rr�rHrZ
_colorizerrr,r!r!r"rIPs
zTreeReporterTests.setUpcCs,zddWntk
r&t�}YnX|S)NrLr)rqr
)r r�r!r!r"�	makeErrorWs
zTreeReporterTests.makeErrorcCsT|j�|j�|j��|�|jd|jjdf�|�|j���	�d�
�d�dS)zw
        The summary in case of success should have a good count of successes
        and be colored properly.
        rLZPASSEDr�z
(successes=1)N)rH�
addSuccessrxrcrRr�SUCCESSr~rdrjr�r,r!r!r"�test_summaryColoredSuccess_s
�z,TreeReporterTests.test_summaryColoredSuccesscCszztd��Wn&tk
r2|j�|t���YnX|j��|�|jd|jjdf�|�|j	�
���d��d�dS)zt
        The summary in case of failure should have a good count of errors
        and be colored properly.
        rKrLZFAILEDr�z
(errors=1)N)
rMrHrNrOrPrcrRr�FAILUREr~rdrjr�r,r!r!r"�test_summaryColoredFailureks
�z,TreeReporterTests.test_summaryColoredFailurecCs^|�ddg|j�d��|�ddg|j�d��|�dg|j�d��|�g|j�d��dS)z�
        The tree needs to get the segments of the test ID that correspond
        to the module and class that it belongs to.
        zfoo.barZbazzfoo.bar.baz.quxrKr�zfoo.bar.bazN)rRrHZ_getPreludeSegmentsr,r!r!r"�test_getPreludezs
�
�
�z!TreeReporterTests.test_getPreludecCs�ztd��Wn:tk
rF|j�|t���|j�|jt���YnXztd��Wn0tk
r�t�d�}|j�|t���YnX|j��|j�	|jj
|jj�}|�|dd||jg�|�|dd|g�dS)z�
        If two different tests have the same error, L{Reporter._groupResults}
        includes them together in one of the tuples in the list it returns.
        rKr��test_barrrLN)
rMrHrNrOrPrxrr�rcZ
_groupResultsrQr�rR)r ZextraZgroupedr!r!r"�test_groupResults�s"

�z#TreeReporterTests.test_groupResultsc	Cs|dd�}t�d�}t�d�}t�d�}|j�d|df|df|dfg|�|�|j��d|jj|�	�|�	�|�	�d	��d
S)z�
        L{Reporter._printResults} uses the results list and formatter callable
        passed to it to produce groups of results to write to its output
        stream.
        cSst|�dS)Nr�)r=)�nr!r!r"�	formatter�sz6TreeReporterTests.test_printResults.<locals>.formatterr�rZFOOrL�zW%(double separator)s
FOO
1

%(first)s
%(second)s
%(double separator)s
FOO
2

%(third)s
)zdouble separator�first�second�thirdN)
rr�r�rHZ
_printResultsrRr~rdZ_doubleSeparatorr�)r rrrrr!r!r"�test_printResults�s&


����z#TreeReporterTests.test_printResultsN)
r-r.r/rIr	rrrrrr!r!r!r"rOsrc@sNeZdZdZejZdd�Zdd�Zdd�Z	dd	�Z
d
d�Zdd
�Zdd�Z
dS)�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}.
    cCs6t�d�|_t�|_t��|_|j|j|jd�|_	dS)Nr���	publisher)
rr�rxrr~r�LogPublisherr�
resultFactoryrHr,r!r!r"rI�s
zReporterInterfaceTests.setUpcCs|�d|jj�dS)z4
        shouldStop is False to begin with.
        FN)rRrH�
shouldStopr,r!r!r"�test_shouldStopInitiallyFalse�sz4ReporterInterfaceTests.test_shouldStopInitiallyFalsecCs|j��|�d|jj�dS)zG
        shouldStop becomes True soon as someone calls stop().
        TN)rH�stoprRrr,r!r!r"�test_shouldStopTrueAfterStop�s
z3ReporterInterfaceTests.test_shouldStopTrueAfterStopcCs|�d|j���dS)zS
        wasSuccessful() is True when there have been no results reported.
        TN)rRrHr�r,r!r!r"�test_wasSuccessfulInitiallyTrue�sz6ReporterInterfaceTests.test_wasSuccessfulInitiallyTruecCs$|j�|j�|�d|j���dS)zg
        wasSuccessful() is True when there have been only successes, False
        otherwise.
        TN)rHr
rxrRr�r,r!r!r"�$test_wasSuccessfulTrueAfterSuccesses�sz;ReporterInterfaceTests.test_wasSuccessfulTrueAfterSuccessescCsLzddWn(tk
r4|j�|jt���YnX|�d|j���dS)zP
        wasSuccessful() becomes False after errors have been reported.
        rLrFN)rqrHrNrxrOrPrRr�r,r!r!r"�"test_wasSuccessfulFalseAfterErrors�s
z9ReporterInterfaceTests.test_wasSuccessfulFalseAfterErrorscCsPz|�d�Wn*|jk
r8|j�|jt���YnX|�d|j���dS)zR
        wasSuccessful() becomes False after failures have been reported.
        rKFN)	r�rXrHrYrxrOrPrRr�r,r!r!r"�$test_wasSuccessfulFalseAfterFailuress
z;ReporterInterfaceTests.test_wasSuccessfulFalseAfterFailuresN)r-r.r/r0rr]rrIrr!r"r#r$r%r!r!r!r"r�s	rc@sPeZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dd�Z
dd�ZdS)�
ReporterTestsz8
    Tests for the base L{reporter.Reporter} class.
    cCst�|�d|_|j|j_dSr�)rrI�_timerr�rHr,r!r!r"rIs
zReporterTests.setUpcCs|jd7_|jS�NrL)r'r,r!r!r"r�szReporterTests._getTimecCsT|j�|j�|j�|j�|�|jjdk�|�|jjd�|�|j��d�dS)NrrLT)	rHr�rx�stopTestr5Z	_lastTimerRZtestsRunr�r,r!r!r"�test_startStops
zReporterTests.test_startStopcCsh|jt|j�d�}|�d�|�|j��d�|j�d�|j�d�|�dd�|�|j��d�dS)	zE
        Test that the reporter safely writes to its stream.
        r��HellozHello
rz	Hello %s!ZWorldz
Hello World!
N)rrr~Z_writelnrRrd�truncate�seekr�r!r!r"�test_brokenStream&s
zReporterTests.test_brokenStreamc	CsTtd�}d}d}d}|jj||||d�|�|j��d|||�d�d|f�d	S)
z�
        L{reporter.Reporter} observes warnings emitted by the Twisted log
        system and writes them to its output stream.
        zsome warning text�exceptions.RuntimeWarningzpath/to/some/file.py�G�Zwarning�category�filename�linenoz%s:%d: %s: %s
�.r�N)�RuntimeWarningr�msgrRr~rdr�)r �messager2r3r4r!r!r"�test_warning3s&���zReporterTests.test_warningcCs|��|��dS)zj
        A warning emitted twice within a single test is only written to the
        stream once.
        N)r9r,r!r!r"�test_duplicateWarningSuppressedEsz-ReporterTests.test_duplicateWarningSuppressedcCs�|�d�}|j�|�|j�d�|j��|��|j�d�|j��|j�|�|j�|�|j�d�|j��|��dS)zn
        A warning emitted again after a new test has started is written to the
        stream again.
        �test_warningEmittedForNewTestrN)�	__class__rHr�r~r-r,r9r)�r rxr!r!r"r;Qs



z+ReporterTests.test_warningEmittedForNewTestcCsN|j��|j�d�|j��|jjtd�dddd�|�|j�	�d�dS)	zl
        L{reporter.Reporter} stops observing log events when its C{done} method
        is called.
        rzsome messager/zfile/name.py�r1r2N)
rHrcr~r-r,rr7r6rRrdr,r!r!r"�test_stopObservingrs

�z ReporterTests.test_stopObservingN)r-r.r/r0rIr�r*r.r9r:r;r?r!r!r!r"r&s
!r&c@seZdZdd�ZdS)�SafeStreamTestscCs6t�}t|�}t�|�}|�d�|�|��d�dS)z�
        Test that L{reporter.SafeStream} successfully write to its original
        stream even if an interrupt happens during the write.
        r+N)rrrZ
SafeStreamr%rRrd)r r~ZbrokenZsafer!r!r"�	test_safe�s


zSafeStreamTests.test_safeN)r-r.r/rAr!r!r!r"r@�sr@c@s�eZdZdZejZdd�Zdd�Zdd�Z	dd	�Z
d
d�Zdd
�Zdd�Z
dd�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd�Zd S)!�SubunitReporterTestszx
    Tests for the subunit reporter.

    This just tests that the subunit reporter implements the basic interface.
    cCsHtjdkrtd��t�d�|_t�|_t�	�|_
|j|j|j
d�|_dS)Nz2Subunit not installed, cannot test SubunitReporterr�r)
r�TestProtocolClientrrr�rxrr~rrrrrHr,r!r!r"rI�s
�
zSubunitReporterTests.setUpc	Os\t�}t�|�}t||�||�}|��}t|j|�||�}|�||�|�||j���dS)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)rrrC�getattrrdrHrRr~)	r �
methodName�args�kwargsr~�
subunitClientZ
subunitReturn�
subunitOutputZreporterReturnr!r!r"�assertForwardsToSubunit�s
z,SubunitReporterTests.assertForwardsToSubunitc
Csht||d�}|dkrdSt|�D]B}zt||�Wnttfk
rPYqdYq X|�t|||�q dS)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)rDr�delattr�AttributeErrorrAZ
addCleanup�setattr)r �klassrE�method�baser!r!r"�removeMethod�sz!SubunitReporterTests.removeMethodcCs�|�tjd�zddWn*tk
rD|j�|jt��d�YnX|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.
        r�rLrr�N)rQrrCrqrHr�rxrOrPr~rdr,r-r
rR)r ZexpectedFailureOutput�
successOutputr!r!r"�.test_subunitWithoutAddExpectedFailureInstalled�s

zCSubunitReporterTests.test_subunitWithoutAddExpectedFailureInstalledcCsh|�tjd�|j�|jd�|j��}|j�d�|j�	d�|j�
|j�|j��}|�||�dS)zz
        Some versions of subunit don't have "addSkip". For these versions, we
        report skips as successes.
        r��reasonrN)rQrrCrHr�rxr~rdr,r-r
rR)r Z
skipOutputrRr!r!r"�#test_subunitWithoutAddSkipInstalled�s

z8SubunitReporterTests.test_subunitWithoutAddSkipInstalledcsng��fdd�}||jj_zddWn.tk
rTt��}|j�|j|d�YnX|��|j|fg�dS)z�
        Some versions of subunit have "addExpectedFailure". For these
        versions, when we call 'addExpectedFailure' on the test result, we
        pass the error and test through to the subunit client.
        cs��||f�dSr�r)rxr��ZaddExpectedFailureCallsr!r"r��szUSubunitReporterTests.test_addExpectedFailurePassedThrough.<locals>.addExpectedFailurerLrr�N)rH�_subunitr�rqrOrPrxrR)r r�rPr!rWr"�$test_addExpectedFailurePassedThrough�s
z9SubunitReporterTests.test_addExpectedFailurePassedThroughcsBg��fdd�}||jj_|j�|jd�|��|jdfg�dS)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.
        cs��||f�dSrrV)rxrT�ZaddSkipCallsr!r"r�szESubunitReporterTests.test_addSkipSendsSubunitAddSkip.<locals>.addSkiprTN)rHrXr�rxrR)r r�r!rZr"�test_addSkipSendsSubunitAddSkips

z4SubunitReporterTests.test_addSkipSendsSubunitAddSkipcCs |j��|�d|j���dS)z�
        The subunit reporter doesn't need to print out a summary -- the stream
        of results is everything. Thus, done() does nothing.
        r�N)rHrcrRr~rdr,r!r!r"�test_doneDoesNothings
z)SubunitReporterTests.test_doneDoesNothingcCs|�d|j�dS)zT
        SubunitReporter.startTest() sends the subunit 'startTest' message.
        r�N�rJrxr,r!r!r"�#test_startTestSendsSubunitStartTest%sz8SubunitReporterTests.test_startTestSendsSubunitStartTestcCs|�d|j�dS)zR
        SubunitReporter.stopTest() sends the subunit 'stopTest' message.
        r)Nr]r,r!r!r"�!test_stopTestSendsSubunitStopTest,sz6SubunitReporterTests.test_stopTestSendsSubunitStopTestcCs|�d|j�dS)zV
        SubunitReporter.addSuccess() sends the subunit 'addSuccess' message.
        r
Nr]r,r!r!r"�%test_addSuccessSendsSubunitAddSuccess3sz:SubunitReporterTests.test_addSuccessSendsSubunitAddSuccesscCs>zddWntk
r(t��}YnX|�d|j|�dS)zR
        SubunitReporter.addError() sends the subunit 'addError' message.
        rLrrNN)rqrOrPrJrx)r r�r!r!r"�!test_addErrorSendsSubunitAddError:s
z6SubunitReporterTests.test_addErrorSendsSubunitAddErrorcCsBz|�d�Wn|jk
r,t��}YnX|�d|j|�dS)zV
        SubunitReporter.addFailure() sends the subunit 'addFailure' message.
        ZhellorYN)r�rXrOrPrJrx)r rVr!r!r"�%test_addFailureSendsSubunitAddFailureEs
z:SubunitReporterTests.test_addFailureSendsSubunitAddFailurecCsHt�}t�|�}|�|j�|��}|j�|j�|�||j	���dS)z�
        SubunitReporter.addFailure() sends the subunit 'addSuccess' message,
        since subunit doesn't model unexpected success.
        N)
rrrCr
rxrdrHr�rRr~)r r~rHrIr!r!r"�/test_addUnexpectedSuccessSendsSubunitAddSuccessPs
zDSubunitReporterTests.test_addUnexpectedSuccessSendsSubunitAddSuccesscCs4t���d�}|�|j�|j��}|�d|�dS)zC
        Load-time errors are reported like normal errors.
        ZdoesntexistsdoesntexistN)rr`rorgrHr~rdZassertIn)r rxrCr!r!r"�test_loadTimeErrors]s
z(SubunitReporterTests.test_loadTimeErrorsN)r-r.r/r0r�SubunitReporterrrIrJrQrSrUrYr[r\r^r_r`rarbrcrdr!r!r!r"rB�s"	
rBc@seZdZdZdd�ZdS)� SubunitReporterNotInstalledTestszD
    Test behaviour when the subunit reporter is not installed.
    cCs8t�}|�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.
        rCNzSubunit not available)rZpatchrr�r�rerRr=)r r~rUr!r!r"�test_subunitNotInstalledosz9SubunitReporterNotInstalledTests.test_subunitNotInstalledN)r-r.r/r0rgr!r!r!r"rfjsrfc@seZdZejZdS)�TimingReporterTestsN)r-r.r/rZTimingTextReporterrr!r!r!r"rh{srhc@sTeZdZdZdd�Zdd�Zddd�Zd	d
�Zdd�Zdd
d�Z	dd�Z
dd�ZdS)�LoggingReporterzJ
    Simple reporter that stores the last test that was passed to it.
    cOstjj|f|�|�d|_dSr)rr]r#rx)r rFrGr!r!r"r#�szLoggingReporter.__init__cCs
||_dSr�rx)r rxr�r!r!r"rN�szLoggingReporter.addErrorNcCs
||_dSrrj)r rxrVr�r!r!r"r��sz"LoggingReporter.addExpectedFailurecCs
||_dSrrj)r rxrVr!r!r"rY�szLoggingReporter.addFailurecCs
||_dSrrj)r rx�skipr!r!r"r��szLoggingReporter.addSkipcCs
||_dSrrjr�r!r!r"r��sz$LoggingReporter.addUnexpectedSuccesscCs
||_dSrrjr=r!r!r"r��szLoggingReporter.startTestcCs
||_dSrrjr=r!r!r"r)�szLoggingReporter.stopTest)N)N)r-r.r/r0r#rNr�rYr�r�r�r)r!r!r!r"ri�s

ric@s�eZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dd�Z
dd�Zdd�Zdd�Z
dd�Zdd�Zdd�Zdd�ZdS)�AdaptedReporterTestsz�
    L{reporter._AdaptedReporter} is a reporter wrapper that wraps all of the
    tests it receives before passing them on to the original reporter.
    cCs|��|_dSr)�getWrappedResult�
wrappedResultr,r!r!r"rI�szAdaptedReporterTests.setUpcCs|��Sr)r�r=r!r!r"�_testAdapter�sz!AdaptedReporterTests._testAdaptercCs|�|jj|�|��dSr)rRr�rxro)r rnrxr!r!r"�
assertWrapped�s
�z"AdaptedReporterTests.assertWrappedcCs z|�Wnt�YSXdS)z�
        Return a L{Failure} from raising the given exception.

        @param exceptionInstance: The exception to raise.
        @return: L{Failure}
        Nr	)r ZexceptionInstancer!r!r"�
getFailure�szAdaptedReporterTests.getFailurecCst�}t�||j�Sr)rirZ_AdaptedReporterror�r!r!r"rm�sz%AdaptedReporterTests.getWrappedResultcCs(|j�||�t���|�|j|�dS)zG
        C{addError} wraps its test with the provided adapter.
        N)rnrNrqrMrpr,r!r!r"�
test_addError�sz"AdaptedReporterTests.test_addErrorcCs(|j�||�t���|�|j|�dS)zI
        C{addFailure} wraps its test with the provided adapter.
        N)rnrYrq�AssertionErrorrpr,r!r!r"�test_addFailure�sz$AdaptedReporterTests.test_addFailurecCs*|j�||�td���|�|j|�dS)zF
        C{addSkip} wraps its test with the provided adapter.
        �	no reasonN)rnr�rqrrpr,r!r!r"�test_addSkip�s
�z!AdaptedReporterTests.test_addSkipcCs|j�|�|�|j|�dS)zH
        C{startTest} wraps its test with the provided adapter.
        N)rnr�rpr,r!r!r"�test_startTest�sz#AdaptedReporterTests.test_startTestcCs|j�|�|�|j|�dS)zG
        C{stopTest} wraps its test with the provided adapter.
        N)rnr)rpr,r!r!r"�
test_stopTest�sz"AdaptedReporterTests.test_stopTestcCs.|j�||�t��td��|�|j|�dS)zQ
        C{addExpectedFailure} wraps its test with the provided adapter.
        ruN)rnr�rqrMrrpr,r!r!r"�test_addExpectedFailure�s
�z,AdaptedReporterTests.test_addExpectedFailurecCs(|j�||�t���|�|j|�dS)z@
        C{addExpectedFailure} works without a C{Todo}.
        N)rnr�rqrMrpr,r!r!r"�test_expectedFailureWithoutTodo�s

�z4AdaptedReporterTests.test_expectedFailureWithoutTodocCs$|j�|td��|�|j|�dS)zS
        C{addUnexpectedSuccess} wraps its test with the provided adapter.
        ruN)rnr�rrpr,r!r!r"�test_addUnexpectedSuccesssz.AdaptedReporterTests.test_addUnexpectedSuccesscCs|j�|�|�|j|�dS)zB
        C{addUnexpectedSuccess} works without a C{Todo}.
        N)rnr�rpr,r!r!r"�!test_unexpectedSuccessWithoutTodosz6AdaptedReporterTests.test_unexpectedSuccessWithoutTodoN)r-r.r/r0rIrorprqrmrrrtrvrwrxryrzr{r|r!r!r!r"rl�s
			rlc@s"eZdZdZddd�Zdd�ZdS)	�
FakeStreamz�
    A fake stream which C{isatty} method returns some predictable.

    @ivar tty: returned value of C{isatty}.
    @type tty: C{bool}
    TcCs
||_dSr��tty)r rr!r!r"r#szFakeStream.__init__cCs|jSrr~r,r!r!r"�isattyszFakeStream.isattyN)T)r-r.r/r0r#r�r!r!r!r"r}s
r}c@sPeZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dd�Z
dd�ZdS)�AnsiColorizerTestsz/
    Tests for L{reporter._AnsiColorizer}.
    cCstj��|_dSr)rO�modules�copy�savedModulesr,r!r!r"rI'szAnsiColorizerTests.setUpcCstj��tj�|j�dSr)rOr��clear�updater�r,r!r!r"�tearDown+s
zAnsiColorizerTests.tearDowncCs|�tj�td���dS)zq
        L{reporter._AnsiColorizer.supported} returns C{False} if the given
        stream is not a TTY.
        FN)�assertFalser�_AnsiColorizer�	supportedr}r,r!r!r"�test_supportedStdOutTTY0sz*AnsiColorizerTests.test_supportedStdOutTTYcCs"dtjd<|�tj�t���dS)zw
        L{reporter._AnsiColorizer.supported} returns C{False} if the curses
        module can't be imported.
        N�curses)rOr�r�rr�r�r}r,r!r!r"�test_supportedNoCurses8s
z)AnsiColorizerTests.test_supportedNoCursescCs\Gdd�dt�}|�tjd<|�tj�t���|�tj�t���|�tjdj	d�dS)a
        L{reporter._AnsiColorizer.supported} returns C{True} if
        C{curses.tigetnum} returns more than 2 supported colors. It only tries
        to call C{curses.setupterm} if C{curses.tigetnum} previously failed
        with a C{curses.error}.
        c@s$eZdZeZdZdd�Zdd�ZdS)z>AnsiColorizerTests.test_supportedSetupTerm.<locals>.fakecursesrcSs|jd7_dSr(�rIr,r!r!r"�	setuptermLszHAnsiColorizerTests.test_supportedSetupTerm.<locals>.fakecurses.setuptermcSs|jr
dS|���dS)Nr�)rIr��r rSr!r!r"�tigetnumOszGAnsiColorizerTests.test_supportedSetupTerm.<locals>.fakecurses.tigetnumN�r-r.r/rMr�rIr�r�r!r!r!r"�
fakecursesHsr�r�rLN)
�objectrOr�r5rr�r�r}rRrI�r r�r!r!r"�test_supportedSetupTermAs

z*AnsiColorizerTests.test_supportedSetupTermcCs4Gdd�dt�}|�tjd<|�tj�t���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}.
        c@seZdZeZdd�ZdS)zGAnsiColorizerTests.test_supportedTigetNumWrongError.<locals>.fakecursescSs
t��dSr)�
ValueErrorr�r!r!r"r�eszPAnsiColorizerTests.test_supportedTigetNumWrongError.<locals>.fakecurses.tigetnumN�r-r.r/rMr�r�r!r!r!r"r�bsr�r�N�r�rOr�r�rr�r�r}r�r!r!r"� test_supportedTigetNumWrongError\sz3AnsiColorizerTests.test_supportedTigetNumWrongErrorcCs4Gdd�dt�}|�tjd<|�tj�t���dS)z�
        L{reporter._AnsiColorizer.supported} returns C{False} if
        C{curses.tigetnum} returns less than 2 supported colors.
        c@seZdZeZdd�ZdS)zKAnsiColorizerTests.test_supportedTigetNumNotEnoughColor.<locals>.fakecursescSsdSr(r!r�r!r!r"r�tszTAnsiColorizerTests.test_supportedTigetNumNotEnoughColor.<locals>.fakecurses.tigetnumNr�r!r!r!r"r�qsr�r�Nr�r�r!r!r"�$test_supportedTigetNumNotEnoughColorlsz7AnsiColorizerTests.test_supportedTigetNumNotEnoughColorcCsHGdd�dt�}|�tjd<|�tj�t���|�tjdj	d�dS)z�
        L{reporter._AnsiColorizer.supported} returns C{False} if
        C{curses.tigetnum} raises an error, and calls C{curses.setupterm} once.
        c@s$eZdZeZdZdd�Zdd�ZdS)zCAnsiColorizerTests.test_supportedTigetNumErrors.<locals>.fakecursesrcSs|jd7_dSr(r�r,r!r!r"r��szMAnsiColorizerTests.test_supportedTigetNumErrors.<locals>.fakecurses.setuptermcSs|���dSr)r�r�r!r!r"r��szLAnsiColorizerTests.test_supportedTigetNumErrors.<locals>.fakecurses.tigetnumNr�r!r!r!r"r��sr�r�rLN)
r�rOr�r�rr�r�r}rRrIr�r!r!r"�test_supportedTigetNumErrors{s
z/AnsiColorizerTests.test_supportedTigetNumErrorsN)r-r.r/r0rIr�r�r�r�r�r�r�r!r!r!r"r�"s	r�c@s0eZdZdZdd�Zdd�Zdd�Zdd	�Zd
S)�ExitWrapperTestsz-
    Tests for L{reporter._ExitWrapper}.
    cCsBttd��|_t�d�|_t��|_t	|j�|_
|�|j
j�dS)NzI am a Failurer�)
r
r�rVrr�rxrrGrHr�wrappedr�rr,r!r!r"rI�s

zExitWrapperTests.setUpcCs>|j�|j|j�|�|jj�|�|jj|j|jfg�dS)zm
        L{reporter._ExitWrapper} causes a wrapped reporter to stop after its
        first failure.
        N)	r�rYrxrVr5rrRrHrZr,r!r!r"�test_stopOnFailure�sz#ExitWrapperTests.test_stopOnFailurecCs>|j�|j|j�|�|jj�|�|jj|j|jfg�dS)zk
        L{reporter._ExitWrapper} causes a wrapped reporter to stop after its
        first error.
        N)	r�rNrxrVr5rrRrHrQr,r!r!r"�test_stopOnError�sz!ExitWrapperTests.test_stopOnErrorcCs>|j�|j|j�|�|jj�|�|jj|j|jfg�dS)zy
        L{reporter._ExitWrapper} does not cause a wrapped reporter to stop
        after an unexpected success.
        N)	r�r�rxrVr�rrRrHr�r,r!r!r"�#test_doesNotStopOnUnexpectedSuccess�s�z4ExitWrapperTests.test_doesNotStopOnUnexpectedSuccessN)r-r.r/r0rIr�r�r�r!r!r!r"r��s


r�)Ir0Z
__future__rrr'r�r8rO�inspectrr
rrrZtwisted.pythonrrZtwisted.python.failurer
Ztwisted.python.reflectrZ
twisted.trialrrrrZtwisted.trial.reporterrrrrrZtwisted.trial.unittestrrrrZtwisted.python.compatrr�iorrr�rZSynchronousTestCaser1rFr\r_rzr{r�r�r�r�r�r�r�rrrrr&r@rBrfrhr]rirlr}r�r�r!r!r!r"�<module>sd|
G-GGK)tKt[ qn

Youez - 2016 - github.com/yon3zu
LinuXploit