Your IP : 216.73.216.213
B
;��]R� � @ s6 d Z ddlmZmZ ddlZddlZddlZddlZddlZ ddl
m Z ddl m
Z
ddlmZmZ ddlmZ ddlmZ dd lmZ dd
lmZmZ dd lmZm Z ydd l m Z W n e k
r� dZ Y nX d
d� Z G dd� de!�Z"G dd� de#�Z$e
ej%�G dd� de j&e#��Z&e
ej%�G dd� deej%d���Z'e
ej%�G dd� de'��Z(e
ej%�G dd� de'��Z)G d d � d e'�Z*e
ej%�G d d � d e&��Z+G d d!� d!e+�Z,G d"d#� d#e+�Z-G d$d%� d%e+�Z.G d&d'� d'e.�Z/G d(d)� d)e#�Z0G d*d+� d+e#�Z1G d,d-� d-e#�Z2e
ej%�G d.d/� d/e#��Z3G d0d1� d1e+�Z4dS )2z3
Defines classes that handle the results of tests.
� )�division�absolute_importN)� OrderedDict)� implementer)�reflect�log)�proxyForInterface)�Failure)�untilConcludes)�_PY3�items)�itrial�util)�TestProtocolClientc C s ddl m} || �S )ad
Return a L{Todo} object built from C{value}.
This is a synonym for L{twisted.trial.unittest.makeTodo}, but imported
locally to avoid circular imports.
@param value: A string or a tuple of C{(errors, reason)}, where C{errors}
is either a single exception class or an iterable of exception classes.
@return: A L{Todo} object.
r )�makeTodo)Ztwisted.trial.unittestr )�valuer � r �I/opt/alt/python37/lib64/python3.7/site-packages/twisted/trial/reporter.py� _makeTodo% s r c @ s e Zd ZdZdS )�BrokenTestCaseWarningzT
Emitted as a warning when an exception occurs in one of setUp or tearDown.
N)�__name__�
__module__� __qualname__�__doc__r r r r r 6 s r c @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) �
SafeStreamz�
Wraps a stream object so that all C{write} calls are wrapped in
L{untilConcludes<twisted.python.util.untilConcludes>}.
c C s
|| _ d S )N)�original)�selfr r r r �__init__C s zSafeStream.__init__c C s t | j|�S )N)�getattrr )r �namer r r � __getattr__G s zSafeStream.__getattr__c O s t | jjf|�|�S )N)r
r �write)r �a�kwr r r r! K s zSafeStream.writeN)r r r r r r r! r r r r r = s r c s� e Zd ZdZdZ� fdd�Zdd� Zdd� Zd d
� Z� fd d �Z � fd
d�Z
dd� Z dd� Z dd� Z
d dd�Zd!dd�Zdd� Zd d � Zd d � Z� ZS )"�
TestResultz�
Accumulates the results of several L{twisted.trial.unittest.TestCase}s.
@ivar successes: count the number of successes achieved by the test run.
@type successes: C{int}
zTest expected to failc s0 t t| ��� g | _g | _g | _d| _g | _d S )Nr )�superr$ r �skips�expectedFailures�unexpectedSuccesses� successesZ_timings)r )� __class__r r r \ s zTestResult.__init__c C s> dt �| j�| jt| j�t| j�t| j�t| j�t| j �f S )Nz<<%s run=%d errors=%d failures=%d todos=%d dones=%d skips=%d>)
r Zqualr* �testsRun�len�errors�failuresr' r& r( )r r r r �__repr__e s
zTestResult.__repr__c C s t � � S )N)�time)r r r r �_getTimem s zTestResult._getTimec C s& t |t�r"t|d |d |d �S |S )zX
Convert a C{sys.exc_info()}-style tuple to a L{Failure}, if necessary.
� r � )�
isinstance�tupler )r �errorr r r � _getFailureq s
zTestResult._getFailurec s t t| ��|� | �� | _dS )zq
This must be called before the given test is commenced.
@type test: L{pyunit.TestCase}
N)r% r$ � startTestr1 � _testStarted)r �test)r* r r r8 z s zTestResult.startTestc s$ t t| ��|� | �� | j | _dS )zp
This must be called after the given test is completed.
@type test: L{pyunit.TestCase}
N)r% r$ �stopTestr1 r9 � _lastTime)r r: )r* r r r; � s zTestResult.stopTestc C s | j �|| �|�f� dS )z�
Report a failed assertion for the given test.
@type test: L{pyunit.TestCase}
@type fail: L{Failure} or L{tuple}
N)r. �appendr7 )r r: �failr r r �
addFailure� s zTestResult.addFailurec C s | j �|| �|�f� dS )z�
Report an error that occurred while running the given test.
@type test: L{pyunit.TestCase}
@type error: L{Failure} or L{tuple}
N)r- r= r7 )r r: r6 r r r �addError� s zTestResult.addErrorc C s | j �||f� dS )a5
Report that the given test was skipped.
In Trial, tests can be 'skipped'. Tests are skipped mostly because
there is some platform or configuration issue that prevents them from
being run correctly.
@type test: L{pyunit.TestCase}
@type reason: L{str}
N)r& r= )r r: �reasonr r r �addSkip� s zTestResult.addSkipNc C s& |dkrt | j�}| j�||f� dS )a�
Report that the given test succeeded against expectations.
In Trial, tests can be marked 'todo'. That is, they are expected to
fail. When a test that is expected to fail instead succeeds, it should
call this method to report the unexpected success.
@type test: L{pyunit.TestCase}
@type todo: L{unittest.Todo}, or L{None}, in which case a default todo
message is provided.
N)r �
_DEFAULT_TODOr( r= )r r: �todor r r �addUnexpectedSuccess� s
z TestResult.addUnexpectedSuccessc C s( |dkrt | j�}| j�|||f� dS )ab
Report that the given test failed, and was expected to do so.
In Trial, tests can be marked 'todo'. That is, they are expected to
fail.
@type test: L{pyunit.TestCase}
@type error: L{Failure}
@type todo: L{unittest.Todo}, or L{None}, in which case a default todo
message is provided.
N)r rC r' r= )r r: r6 rD r r r �addExpectedFailure� s
z TestResult.addExpectedFailurec C s | j d7 _ dS )z_
Report that the given test succeeded.
@type test: L{pyunit.TestCase}
r2 N)r) )r r: r r r �
addSuccess� s zTestResult.addSuccessc C s$ t | j�t | j� ko dkS S )a�
Report whether or not this test suite was successful or not.
The behaviour of this method changed in L{pyunit} in Python 3.4 to
fail if there are any errors, failures, or unexpected successes.
Previous to 3.4, it was only if there were errors or failures. This
method implements the old behaviour for backwards compatibility reasons,
checking just for errors and failures.
@rtype: L{bool}
r )r, r. r- )r r r r �
wasSuccessful� s zTestResult.wasSuccessfulc C s dS )z6
The test suite has finished running.
Nr )r r r r �done� s zTestResult.done)N)N)r r r r rC r r/ r1 r7 r8 r; r? r@ rB rE rF rG rH rI �
__classcell__r r )r* r r$ P s
r$ c @ s e Zd ZdZdS )�TestResultDecoratorz�
Base class for TestResult decorators.
@ivar _originalReporter: The wrapped instance of reporter.
@type _originalReporter: A provider of L{itrial.IReporter}
N)r r r r r r r r rK � s rK �_originalReporterc @ s e Zd ZdZdd� ZdS )� UncleanWarningsReporterWrapperze
A wrapper for a reporter that converts L{util.DirtyReactorAggregateError}s
to warnings.
c C s8 t |t�r&|�tj�r&t�|�� � n| j� ||� dS )z�
If the error is a L{util.DirtyReactorAggregateError}, instead of
reporting it as a normal error, throw a warning.
N)
r4 r �checkr ZDirtyReactorAggregateError�warnings�warnZgetErrorMessagerL r@ )r r: r6 r r r r@ s
z'UncleanWarningsReporterWrapper.addErrorN)r r r r r@ r r r r rM � s rM c @ s e Zd ZdZdd� Zdd� ZdS )� _ExitWrapperza
A wrapper for a reporter that causes the reporter to stop after
unsuccessful tests.
c O s d| _ | jj||�S )NT)�
shouldStoprL r@ )r �args�kwargsr r r r@ s z_ExitWrapper.addErrorc O s d| _ | jj||�S )NT)rR rL r? )r rS rT r r r r? s z_ExitWrapper.addFailureN)r r r r r@ r? r r r r rQ s rQ c @ sT e Zd ZdZdd� Zdd� Zddd�Zd d
� Zd d � Zdd
d�Z dd� Z
dd� Z dS )�_AdaptedReporterz�
TestResult decorator that makes sure that addError only gets tests that
have been adapted with a particular test adapter.
c C s t �| |� || _dS )z�
Construct an L{_AdaptedReporter}.
@param original: An {itrial.IReporter}.
@param testAdapter: A callable that returns an L{itrial.ITestCase}.
N)rK r � testAdapter)r r rV r r r r * s z_AdaptedReporter.__init__c C s | � |�}| j�||�S )z*
See L{itrial.IReporter}.
)rV rL r@ )r r: r6 r r r r@ 5 s
z_AdaptedReporter.addErrorNc C s | j �| �|�||�S )a
See L{itrial.IReporter}.
@type test: A L{pyunit.TestCase}.
@type failure: A L{failure.Failure} or L{exceptions.AssertionError}
@type todo: A L{unittest.Todo} or None
When C{todo} is L{None} a generic C{unittest.Todo} is built.
L{pyunit.TestCase}'s C{run()} calls this with 3 positional arguments
(without C{todo}).
)rL rF rV )r r: �failurerD r r r rF = s
z#_AdaptedReporter.addExpectedFailurec C s | � |�}| j�||�S )z*
See L{itrial.IReporter}.
)rV rL r? )r r: rW r r r r? N s
z_AdaptedReporter.addFailurec C s | � |�}| j�||�S )z*
See L{itrial.IReporter}.
)rV rL rB )r r: �skipr r r rB V s
z_AdaptedReporter.addSkipc C s | � |�}| j�||�S )a3
See L{itrial.IReporter}.
@type test: A L{pyunit.TestCase}.
@type todo: A L{unittest.Todo} or None
When C{todo} is L{None} a generic C{unittest.Todo} is built.
L{pyunit.TestCase}'s C{run()} calls this with 2 positional arguments
(without C{todo}).
)rV rL rE )r r: rD r r r rE ^ s
z%_AdaptedReporter.addUnexpectedSuccessc C s | j �| �|��S )z*
See L{itrial.IReporter}.
)rL r8 rV )r r: r r r r8 n s z_AdaptedReporter.startTestc C s | j �| �|��S )z*
See L{itrial.IReporter}.
)rL r; rV )r r: r r r r; u s z_AdaptedReporter.stopTest)N)N) r r r r r r@ rF r? rB rE r8 r; r r r r rU $ s
rU c s� e Zd ZdZdZdZejdddf� fdd� Zd d
� Z � fd d �Z
� fd
d�Z � fdd�Z dd� Z
dd� Z� fdd�Z� fdd�Zdd� Zdd � Zd d � Zd d � Zd!d"� Zd#d$� Zd%d&� Zd'd(� Zd)d*� Zd+d,� Z� ZS )-�Reportera�
A basic L{TestResult} with support for writing to a stream.
@ivar _startTime: The time when the first test was started. It defaults to
L{None}, which means that no test was actually launched.
@type _startTime: C{float} or L{None}
@ivar _warningCache: A C{set} of tuples of warning message (file, line,
text, category) which have already been written to the output stream
during the currently executing test. This is used to avoid writing
duplicates of the same warning to the output stream.
@type _warningCache: C{set}
@ivar _publisher: The log publisher which will be observed for warning
events.
@type _publisher: L{twisted.python.log.LogPublisher}
zO-------------------------------------------------------------------------------zO===============================================================================�defaultFNc sP t t| ��� t|�| _|| _|| _d | _t� | _ || _
|d k rL|� | j � d S )N)
r% rY r r �_stream�tbformat�realtime�
_startTime�set�
_warningCache�
_publisherZ addObserver�_observeWarnings)r �streamr\ r] � publisher)r* r r r � s
zReporter.__init__c C s\ d|krX|d |d |d � d�d t|d �f}|| jkrX| j�|� | j�d| � dS ) a|
Observe warning events and write them to C{self._stream}.
This method is a log observer which will be registered with
C{self._publisher.addObserver}.
@param event: A C{dict} from the logging system. If it has a
C{'warning'} key, a logged warning will be extracted from it and
possibly written to C{self.stream}.
�warning�filename�lineno�category�.���z%s:%s: %s: %s
N)�split�strr` �addr[ r! )r �event�keyr r r rb � s
zReporter._observeWarningsc s0 t t| ��|� | jdkr$| �� | _t� | _dS )z�
Called when a test begins to run. Records the time when it was first
called and resets the warning cache.
@param test: L{ITestCase}
N)r% rY r8 r^ r1 r_ r` )r r: )r* r r r8 � s
zReporter.startTestc s: t t| ��||� | jr6| jd d }| �| �|�� dS )z�
Called when a test fails. If C{realtime} is set, then it prints the
error to the stream.
@param test: L{ITestCase} that failed.
@param fail: L{failure.Failure} containing the error.
rj r2 N)r% rY r? r] r. �_write�_formatFailureTraceback)r r: r> )r* r r r? � s zReporter.addFailurec sD | � |�}tt| ��||� | jr@| jd d }| �| �|�� dS )z�
Called when a test raises an error. If C{realtime} is set, then it
prints the error to the stream.
@param test: L{ITestCase} that raised the error.
@param error: L{failure.Failure} containing the error.
rj r2 N)r7 r% rY r@ r] r- rp rq )r r: r6 )r* r r r@ � s
zReporter.addErrorc G sL t |�}t|td��st�|r0| j�|| � n | j�|� t| jj� dS )z�
Safely write to the reporter's stream.
@param format: A format string to write.
@param *args: The arguments for the format string.
� N)rl r4 �type�AssertionErrorr[ r! r
�flush)r �formatrS �sr r r rp � s zReporter._writec G s | j |f|�� | � d� dS )z�
Safely write a line to the reporter's stream. Newline is appended to
the format string.
@param format: A format string to write.
@param *args: The arguments for the format string.
�
N)rp )r rv rS r r r �_writeln� s zReporter._writelnc sN t t| ��||||� |rJ| �|�}t�|� d||f }tj|tdd� d S )Nz3caught exception in %s, your TestCase is broken
%sr3 )�
stacklevel) r% rY � upDownErrorrq r �msgrO rP r )r �methodr6 rP � printStatusZtbStrr| )r* r r r{ � s
zReporter.upDownErrorc s. t t| ��|� t�dd| �|�f t� d S )Nz%s
%sz&REACTOR UNCLEAN! traceback(s) follow: )r% rY �
cleanupErrorsrO rP rq r )r �errs)r* r r r s zReporter.cleanupErrorsc
C sv t |�}t|�dk r|S |d d }tj�tj�|d d ��d }|d d }tj�tj�|d d ��d }d}d}||f||ff} tr�xL|D ]D}
tj�tj�|
d ��d } | dkr�|
d dkr�|�|�|
�� q�W | |kr�|dd� }n2| |k�r|d d� }n||fd
k�r"|dd� }|�s,|S |d } | d � d ��rrtj�tj�| d ��d d
k�rr|dd � }|S )a)
Trim frames to remove internal paths.
When a C{SynchronousTestCase} method fails synchronously, the stack
looks like this:
- [0]: C{SynchronousTestCase._run}
- [1]: C{util.runWithWarningsSuppressed}
- [2:-2]: code in the test method which failed
- [-1]: C{_synctest.fail}
When a C{TestCase} method fails synchronously, the stack looks like
this:
- [0]: C{defer.maybeDeferred}
- [1]: C{utils.runWithWarningsSuppressed}
- [2]: C{utils.runWithWarningsSuppressed}
- [3:-2]: code in the test method which failed
- [-1]: C{_synctest.fail}
When a method fails inside a C{Deferred} (i.e., when the test method
returns a C{Deferred}, and that C{Deferred}'s errback fires), the stack
captured inside the resulting C{Failure} looks like this:
- [0]: C{defer.Deferred._runCallbacks}
- [1:-2]: code in the testmethod which failed
- [-1]: C{_synctest.fail}
As a result, we want to trim either [maybeDeferred, runWWS, runWWS] or
[Deferred._runCallbacks] or [SynchronousTestCase._run, runWWS] from the
front, and trim the [unittest.fail] from the end.
There is also another case, when the test method is badly defined and
contains extra arguments.
If it doesn't recognize one of these cases, it just returns the
original frames.
@param frames: The C{list} of frames from the test failure.
@return: The C{list} of frames to display.
r3 r r2 ))Z_run� _synctest)�runWithWarningsSuppressedr ))Z
maybeDeferred�defer)r� �utils�compatZreraiseN� )Z
_runCallbacksr� rj r> r� )
�listr, �os�path�splitext�basenamer �pop�index�
startswith)
r �framesZ newFramesZ firstMethodZ firstFileZ secondMethodZ
secondFileZsyncCaseZ asyncCaseZ twoFrames�frameZ frameFile�lastr r r � _trimFrames s8 (
" zReporter._trimFramesc C sF t |t�r|�� d S | �|j�|j |_}|j| jdd�}||_|S )Nrx T)ZdetailZelideFrameworkCode)r4 rl �rstripr� r� Z getTracebackr\ )r r> r� �resultr r r rq d s
z Reporter._formatFailureTracebackc C sJ t � }x:|D ]2}|d }|dd� }||� }|�|g ��|� q W t|�S )a
Group tests together based on their results.
@param results: An iterable of tuples of two or more elements. The
first element of each tuple is a test case. The remaining
elements describe the outcome of that test case.
@param formatter: A callable which turns a test case result into a
string. The elements after the first of the tuples in
C{results} will be passed as positional arguments to
C{formatter}.
@return: A C{list} of two-tuples. The first element of each tuple
is a unique string describing one result from at least one of
the test cases in C{results}. The second element is a list of
the test cases which had that result.
r r2 N)r �
setdefaultr= r )r �results� formatter�groups�content�caseZoutcomero r r r �
_groupResultsn s
zReporter._groupResultsc C sd x^| � ||�D ]N\}}| �| j� | �|� | �|� | �d� x|D ]}| �|�� � qFW qW dS )a<
Print a group of errors to the stream.
@param flavor: A string indicating the kind of error (e.g. 'TODO').
@param errors: A list of errors, often L{failure.Failure}s, but
sometimes 'todo' errors.
@param formatter: A callable that knows how to format the errors.
rr N)r� ry �_doubleSeparatorrp �id)r Zflavorr- r� rA Zcasesr� r r r �
_printResults� s
zReporter._printResultsc C s d|j | �|�f S )Nz
Reason: %r
%s)rA rq )r r6 rD r r r �_printExpectedFailure� s z Reporter._printExpectedFailurec C s, d|j f }|jr(|dd�|j�f 7 }|S )Nz Reason: %r
zExpected errors: %s
z, )rA r- �join)r rD �retr r r �_printUnexpectedSuccess� s z Reporter._printUnexpectedSuccessc C sj | � d� | �d| jdd� � | �d| j| j� | �d| j| j� | �d| j| j� | �d| j| j � d S )
zM
Print all of the non-success results to the stream in full.
rx z [SKIPPED]c S s d| S )Nz%s
r )�xr r r �<lambda>� � z'Reporter._printErrors.<locals>.<lambda>z[TODO]z[FAIL]z[ERROR]z [SUCCESS!?!]N)
rp r� r& r' r� r. rq r- r( r� )r r r r � _printErrors� s
zReporter._printErrorsc C sl g }x0dD ](}t t| |��}|r
|�d||f � q
W | jrN|�d| jf � |rddd�|� d pfd}|S )zC
Return a formatted count of tests status results.
)r& r' r. r- r( z%s=%dz successes=%dz (z, �)rr )r, r r= r) r� )r Z summaries�stat�num�summaryr r r � _getSummary� s
zReporter._getSummaryc C s, | � � }| �� rd}nd}| �d||� dS )zJ
Print a line summarising the test results to the stream.
�PASSED�FAILEDz%s%s
N)r� rH rp )r r� �statusr r r �
_printSummary� s
zReporter._printSummaryc C sf | j dk r| j �| j� | �� | �| j� | jdk rP| �d| jt�� | j � | � d� | �
� dS )a�
Summarize the result of the test run.
The summary includes a report of all of the errors, todos, skips and
so forth that occurred during the run. It also includes the number of
tests that were run and how long it took to run them (not including
load time).
Expects that C{_printErrors}, C{_writeln}, C{_write}, C{_printSummary}
and C{_separator} are all implemented.
NzRan %d tests in %.3fsrx ) ra ZremoveObserverrb r� ry �
_separatorr^ r+ r0 rp r� )r r r r rI � s
z
Reporter.done) r r r r r� r� �sys�stdoutr rb r8 r? r@ rp ry r{ r r� rq r� r� r� r� r� r� r� rI rJ r r )r* r rY } s.
V
rY c @ s e Zd ZdZdd� Zdd� ZdS )�MinimalReporterz�
A minimalist reporter that prints only a summary of the test result, in
the form of (timeTaken, #tests, #tests, #errors, #failures, #skips).
c C s dS )zb
Don't print a detailed summary of errors. We only care about the
counts.
Nr )r r r r r� � s z MinimalReporter._printErrorsc C s` | j }| jdk r | �� | j }nd}|||t| j�t| j�t| j�f}| �d�t t
|��� dS )z�
Print out a one-line summary of the form:
'%(runtime) %(number_of_tests) %(number_of_tests) %(num_errors)
%(num_failures) %(num_skips)'
Nr � ) r+ r^ r1 r, r- r. r& ry r� �maprl )r ZnumTestsZtiming�tr r r r� � s
z MinimalReporter._printSummaryN)r r r r r� r� r r r r r� � s r� c s\ e Zd ZdZ� fdd�Z� fdd�Z� fdd�Z� fdd �Z� fd
d �Z� fd d
�Z � Z
S )� TextReporterz�
Simple reporter that prints a single character for each test as it runs,
along with the standard Trial summary text.
c s t t| ��|� | �d� d S )Nri )r% r� rG rp )r r: )r* r r rG s zTextReporter.addSuccessc s t t| �j|� | �d� d S )N�E)r% r� r@ rp )r rS )r* r r r@ s zTextReporter.addErrorc s t t| �j|� | �d� d S )N�F)r% r� r? rp )r rS )r* r r r? s zTextReporter.addFailurec s t t| �j|� | �d� d S )N�S)r% r� rB rp )r rS )r* r r rB s zTextReporter.addSkipc s t t| �j|� | �d� d S )N�T)r% r� rF rp )r rS )r* r r rF # s z TextReporter.addExpectedFailurec s t t| �j|� | �d� d S )N�!)r% r� rE rp )r rS )r* r r rE ( s z!TextReporter.addUnexpectedSuccess) r r r r rG r@ r? rB rF rE rJ r r )r* r r� s r� c st e Zd ZdZ� fdd�Z� fdd�Z� fdd�Z� fdd �Z� fd
d �Z� fd d
�Z � fdd�Z
� fdd�Z � Z S )�VerboseTextReporterz�
A verbose reporter that prints the name of each test as it is running.
Each line is printed with the name of the test, followed by the result of
that test.
c s$ | � d|�� � tt| ��|� d S )Nz%s ... )rp r� r% r� r8 )r �tm)r* r r r8 8 s z VerboseTextReporter.startTestc s t t| ��|� | �d� d S )Nz[OK])r% r� rG rp )r r: )r* r r rG = s z VerboseTextReporter.addSuccessc s t t| �j|� | �d� d S )Nz[ERROR])r% r� r@ rp )r rS )r* r r r@ B s z VerboseTextReporter.addErrorc s t t| �j|� | �d� d S )Nz [FAILURE])r% r� r? rp )r rS )r* r r r? G s z VerboseTextReporter.addFailurec s t t| �j|� | �d� d S )Nz [SKIPPED])r% r� rB rp )r rS )r* r r rB L s zVerboseTextReporter.addSkipc s t t| �j|� | �d� d S )Nz[TODO])r% r� rF rp )r rS )r* r r rF Q s z&VerboseTextReporter.addExpectedFailurec s t t| �j|� | �d� d S )Nz [SUCCESS!?!])r% r� rE rp )r rS )r* r r rE V s z(VerboseTextReporter.addUnexpectedSuccessc s t t| ��|� | �d� d S )Nrx )r% r� r; rp )r r: )r* r r r; [ s z VerboseTextReporter.stopTest)
r r r r r8 rG r@ r? rB rF rE r; rJ r r )r* r r� . s r� c s e Zd ZdZ� fdd�Z� ZS )�TimingTextReporterze
Prints out each test as it is running, followed by the time taken for each
test to run.
c s$ t t| ��|� | �d| j � dS )zm
Mark the test as stopped, and write the time it took to run the test
to the stream.
z
(%.03f secs)
N)r% r� r; rp r< )r r} )r* r r r; g s zTimingTextReporter.stopTest)r r r r r; rJ r r )r* r r� a s r� c
@ sN e Zd ZdZedddddddd d
�Zd d � Zejfd
d�Z e
e �Z dd� Z dS )�_AnsiColorizerz�
A colorizer is an object that loosely wraps around a stream, allowing
callers to write text to the stream in a particular color.
Colorizer classes must implement C{supported()} and C{write(text, color)}.
� � � �! �" �# �$ �% )Zblack�red�green�yellow�blue�magenta�cyan�whitec C s
|| _ d S )N)rc )r rc r r r r { s z_AnsiColorizer.__init__c C sz |� � s dS y ddl}W n tk
r, dS X y<y|�d�dkS |jk
rf |�� |�d�dkS X W n
dS dS )z�
A class method that returns True if the current platform supports
coloring terminal output using this method. Returns False otherwise.
Fr NZcolorsr3 )�isatty�curses� ImportErrorZtigetnumr6 Z setupterm)�clsrc r� r r r � supported s z_AnsiColorizer.supportedc C s" | j | }| j�d||f � dS )z�
Write the given text to the stream in the given color.
@param text: Text to be written to the stream.
@param color: A string label for a color. e.g. 'red', 'white'.
z
[%s;1m%s[0mN)�_colorsrc r! )r �text�colorr r r r! � s
z_AnsiColorizer.writeN) r r r r �dictr� r r� r� r� � classmethodr! r r r r r� q s
r� c @ s6 e Zd ZdZdd� Zejfdd�Zee�Zdd� Z dS ) �_Win32Colorizerz'
See _AnsiColorizer docstring.
c C s� ddl m}m}m}m}m}m} ||||f\}} }
} || _||�| _|| B |
B || B | | B |
| B || B | B ||
B | B | |
B | B || B |
B | B d�| _ d S )Nr )� GetStdHandle�STD_OUTPUT_HANDLE�FOREGROUND_RED�FOREGROUND_BLUE�FOREGROUND_GREEN�FOREGROUND_INTENSITY)�normalr� r� r� r� r� r� r� )
� win32consoler� r� r� r� r� r� rc � screenBufferr� ) r rc r� r� r� r� r� r� r� r� r� Zboldr r r r � s
z_Win32Colorizer.__init__c C sr ydd l }|�|j�}W n tk
r, dS X dd l}y |�|j|jB |jB � W n |j k
rh dS X dS d S )Nr FT)
r� r� r� r� �
pywintypes�SetConsoleTextAttributer� r� r� r6 )r� rc r� r� r� r r r r� � s
z_Win32Colorizer.supportedc C s8 | j | }| j�|� | j�|� | j�| j d � d S )Nr� )r� r� r� rc r! )r r� r� r r r r! � s
z_Win32Colorizer.writeN)
r r r r r r� r� r� r� r! r r r r r� � s
r� c @ s6 e Zd ZdZdd� Zejfdd�Zee�Zdd� Z dS ) �_NullColorizerz'
See _AnsiColorizer docstring.
c C s
|| _ d S )N)rc )r rc r r r r � s z_NullColorizer.__init__c C s dS )NTr )r� rc r r r r� � s z_NullColorizer.supportedc C s | j �|� d S )N)rc r! )r r� r� r r r r! � s z_NullColorizer.writeN)
r r r r r r� r� r� r� r! r r r r r� � s
r� c @ s� e Zd ZdZejdddfdd�Zdd� Zd d
� Ze e�Zd d � Z
d
d� Z dd� Z dd� Z
dd� Zdd� Zdd� Zdd� Zdd � Zd d d �ZdS ) �SubunitReporterz�
Reports test output via Subunit.
@ivar _subunit: The subunit protocol client that we are wrapping.
@ivar _successful: An internal variable, used to track whether we have
received only successful results.
@since: 10.0
rZ FNc C s$ t dkrtd��t |�| _d| _dS )aI
Construct a L{SubunitReporter}.
@param stream: A file-like object representing the stream to print
output to. Defaults to stdout.
@param tbformat: The format for tracebacks. Ignored, since subunit
always uses Python's standard format.
@param realtime: Whether or not to print exceptions in the middle
of the test results. Ignored, since subunit always does this.
@param publisher: The log publisher which will be preserved for
reporting events. Ignored, as it's not relevant to subunit.
NzSubunit not availableT)r � Exception�_subunit� _successful)r rc r\ r] rd r r r r � s
zSubunitReporter.__init__c C s dS )z�
Record that the entire test suite run is finished.
We do nothing, since a summary clause is irrelevant to the subunit
protocol.
Nr )r r r r rI s zSubunitReporter.donec C s | j jS )zK
Whether or not the test runner should stop running tests.
)r� rR )r r r r rR s zSubunitReporter.shouldStopc C s
| j �� S )zH
Signal that the test runner should stop running tests.
)r� �stop)r r r r r� s zSubunitReporter.stopc C s | j S )z�
Has the test run been successful so far?
@return: C{True} if we have received no reports of errors or failures,
C{False} otherwise.
)r� )r r r r rH $ s
z SubunitReporter.wasSuccessfulc C s | j �|�S )z2
Record that C{test} has started.
)r� r8 )r r: r r r r8 1 s zSubunitReporter.startTestc C s | j �|�S )z4
Record that C{test} has completed.
)r� r; )r r: r r r r; 8 s zSubunitReporter.stopTestc C s | j �|�S )z5
Record that C{test} was successful.
)r� rG )r r: r r r rG ? s zSubunitReporter.addSuccessc C s4 t | jdd�}|dkr"| �|� n| j�||� dS )a�
Record that C{test} was skipped for C{reason}.
Some versions of subunit don't have support for addSkip. In those
cases, the skip is reported as a success.
@param test: A unittest-compatible C{TestCase}.
@param reason: The reason for it being skipped. The C{str()} of this
object will be included in the subunit output stream.
rB N)r r� rG rB )r r: rA rB r r r rB F s zSubunitReporter.addSkipc C s d| _ | j�|t�|��S )z�
Record that C{test} failed with an unexpected error C{err}.
Also marks the run as being unsuccessful, causing
L{SubunitReporter.wasSuccessful} to return C{False}.
F)r� r� r@ r �excInfoOrFailureToExcInfo)r r: �errr r r r@ X s zSubunitReporter.addErrorc C s d| _ | j�|t�|��S )z�
Record that C{test} failed an assertion with the error C{err}.
Also marks the run as being unsuccessful, causing
L{SubunitReporter.wasSuccessful} to return C{False}.
F)r� r� r? r r� )r r: r� r r r r? d s zSubunitReporter.addFailurec C s: t �|�}t| jdd�}|dkr,| �|� n
|||� dS )z�
Record an expected failure from a test.
Some versions of subunit do not implement this. For those versions, we
record a success.
rF N)r r� r r� rG )r r: rW rD rF r r r rF p s
z"SubunitReporter.addExpectedFailurec C s | � |� dS )z�
Record an unexpected success.
Since subunit has no way of expressing this concept, we record a
success on the subunit stream.
N)rG )r r: rD r r r rE s z$SubunitReporter.addUnexpectedSuccess)N)r r r r r� r� r rI rR �propertyr� rH r8 r; rG rB r@ r? rF rE r r r r r� � s
r� c s� e Zd ZdZdZdZdZdZdZdZ dZ
dZ dZ e
jf� fdd � Zd
d � Z� fd d
�Z� fdd�Z� fdd�Z� fdd�Z� fdd�Z� fdd�Z� fdd�Zdd� Zd d � Z� fd d �Z� fd d!�Z� fd"d#�Z � fd$d%�Z d&d'� Z � Z S )(� TreeReporterz�
Print out the tests in the form a tree.
Tests are indented according to which class and module they belong.
Results are printed in ANSI color.
rr z �O r� r� r� c sL t t| �j|f|�|� g | _x(tttgD ]}|�|�r*||�| _P q*W d S )N) r% r� r � _lastTestr� r� r� r� �
_colorizer)r rc rS rT Z colorizer)r* r r r � s
zTreeReporter.__init__c C s |� � �d�d S )z�
Return the name of the method which 'test' represents. This is
what gets displayed in the leaves of the tree.
e.g. getDescription(TestCase('test_foo')) ==> test_foo
ri rj )r� rk )r r: r r r �getDescription� s zTreeReporter.getDescriptionc s" t t| ��|� | �d| j� d S )Nz[OK])r% r� rG �endLine�SUCCESS)r r: )r* r r rG � s zTreeReporter.addSuccessc s" t t| �j|� | �d| j� d S )Nz[ERROR])r% r� r@ r� �ERROR)r rS )r* r r r@ � s zTreeReporter.addErrorc s" t t| �j|� | �d| j� d S )Nz[FAIL])r% r� r? r� �FAILURE)r rS )r* r r r? � s zTreeReporter.addFailurec s" t t| �j|� | �d| j� d S )Nz [SKIPPED])r% r� rB r� �SKIP)r rS )r* r r rB � s zTreeReporter.addSkipc s" t t| �j|� | �d| j� d S )Nz[TODO])r% r� rF r� �TODO)r rS )r* r r rF � s z TreeReporter.addExpectedFailurec s" t t| �j|� | �d| j� d S )Nz [SUCCESS!?!])r% r� rE r� �TODONE)r rS )r* r r rE � s z!TreeReporter.addUnexpectedSuccessc s( |r || }|| _ tt| ��| j � d S )N)� currentLiner% r� rp )r rv rS )r* r r rp � s zTreeReporter._writec C sJ |� d�dd� }t|�dkr"|S dd� d�|dd� �|d fD �}|S )z�
Return a list of all non-leaf segments to display in the tree.
Normally this is the module and class name.
ri Nrj r c S s g | ]}t |�d kr|�qS )r )r, )�.0�segr r r �
<listcomp>� s z4TreeReporter._getPreludeSegments.<locals>.<listcomp>)rk r, r� )r �testID�segmentsr r r �_getPreludeSegments� s
$z TreeReporter._getPreludeSegmentsc C s| | � |�}d}xb|D ]Z}|t| j�k rN|| j| krf| �d| j| |f � n| �d| j| |f � |d7 }qW || _dS )z�
Write the name of the test to the stream, indenting it appropriately.
If the test is the first test in a new 'branch' of the tree, also
write all of the parents in that branch.
r z%s%s
r2 N)r r, r� rp �indent)r r� r Z indentLevelr� r r r � _testPrelude� s
zTreeReporter._testPreludec s2 | j �d| j� | �d| j� tt| ��|� d S )Nz cleanup errorsz[ERROR])r� r! r� r� r% r� r )r r� )r* r r r � s zTreeReporter.cleanupErrorsc s@ | j �d| | j� |r&| �d| j� tt| ��||||� d S )Nz %sz[ERROR])r� r! r� r� r% r� r{ )r r} r6 rP r~ )r* r r r{ � s zTreeReporter.upDownErrorc sF | � |�� � | �d| jt| j� | �|�f � tt| �� |� dS )zn
Called when C{test} starts. Writes the tests name to the stream using
a tree format.
z %s%s ... N)
r r� rp r r, r� r� r% r� r8 )r r: )r* r r r8 s zTreeReporter.startTestc sN d| j t| j� t|� }tt| ��|� | j�||� tt| ��d� dS )z�
Print 'message' in the given color.
@param message: A string message, usually '[OK]' or something similar.
@param color: A string color, 'red', 'green' and so forth.
r� rx N)�columnsr, r� r% r� rp r� r! )r �messager� Zspaces)r* r r r� s zTreeReporter.endLinec C sD | � � }| �� r d}| j}n
d}| j}| j�||� | �d|� dS )zo
Print a line summarising the test results to the stream, and color the
status result.
r� r� z%s
N)r� rH r� r� r� r! rp )r r� r� r� r r r r� s zTreeReporter._printSummary) r r r r r� r r r� r� r� r� r� r� r� r� r r� rG r@ r? rB rF rE rp r r r r{ r8 r� r� rJ r r )r* r r� � s4
r� )5r �
__future__r r r� r� r0 rO ZunittestZpyunit� collectionsr Zzope.interfacer Ztwisted.pythonr r Ztwisted.python.componentsr Ztwisted.python.failurer Ztwisted.python.utilr
Ztwisted.python.compatr r Z
twisted.trialr
r Zsubunitr r� r �Warningr �objectr Z IReporterr$ rK rM rQ rU rY r� r� r� r� r� r� r� r� r� r r r r �<module> s^
!
Y o %334 !