running tests import sys import time import warnings from import result from case import subtest from signals import registerresult unittest true class writelndecoratorobject a test result class that can print formatted text results to a stream used by texttestrunner construct a texttestresult subclasses should accept kwargs to ensure compatibility as the interface changes supertexttestresult self initstream descriptions verbosity self stream stream self showall verbosity 1 self dots verbosity 1 self descriptions descriptions self newline true self durations durations def getdescriptionself test docfirstline test shortdescription if self descriptions and docfirstline return n joinstrtest docfirstline else return strtest def starttestself test supertexttestresult self starttesttest if self showall self stream writeself getdescriptiontest self stream write self stream flush self newline false def writestatusself test status issubtest isinstancetest subtest if issubtest or self newline if not self newline self stream writeln if issubtest self stream write self stream writeself getdescriptiontest self stream write self stream writelnstatus self stream flush self newline true def addsubtestself test subtest err if err is not none if self showall if issubclasserr0 subtest failureexception self writestatussubtest fail else self writestatussubtest error elif self dots if issubclasserr0 subtest failureexception self stream write f else self stream write e self stream flush supertexttestresult self addsubtesttest subtest err def addsuccessself test supertexttestresult self addsuccesstest if self showall self writestatustest ok elif self dots self stream write self stream flush def adderrorself test err supertexttestresult self adderrortest err if self showall self writestatustest error elif self dots self stream write e self stream flush def addfailureself test err supertexttestresult self addfailuretest err if self showall self writestatustest fail elif self dots self stream write f self stream flush def addskipself test reason supertexttestresult self addskiptest reason if self showall self writestatustest skipped 0 r formatreason elif self dots self stream writes self stream flush def addexpectedfailureself test err supertexttestresult self addexpectedfailuretest err if self showall self stream writelnexpected failure self stream flush elif self dots self stream writex self stream flush def addunexpectedsuccessself test supertexttestresult self addunexpectedsuccesstest if self showall self stream writelnunexpected success self stream flush elif self dots self stream writeu self stream flush def printerrorsself if self dots or self showall self stream writeln self stream flush self printerrorlist error self errors self printerrorlist fail self failures unexpectedsuccesses getattrself unexpectedsuccesses if unexpectedsuccesses self stream writelnself separator1 for test in unexpectedsuccesses self stream writelnfunexpected success self getdescriptiontest self stream flush def printerrorlistself flavour errors for test err in errors self stream writelnself separator1 self stream writelns s flavour self getdescriptiontest self stream writelnself separator2 self stream writelns err self stream flush class texttestrunnerobject resultclass texttestresult def initself streamnone descriptionstrue verbosity1 failfastfalse bufferfalse resultclassnone warningsnone tblocalsfalse durationsnone if stream is none stream sys stderr self stream writelndecoratorstream self descriptions descriptions self verbosity verbosity self failfast failfast self buffer buffer self tblocals tblocals self durations durations self warnings warnings if resultclass is not none self resultclass resultclass def makeresultself try return self resultclassself stream self descriptions self verbosity durationsself durations except typeerror didn t accept the durations argument return self resultclassself stream self descriptions self verbosity def printdurationsself result if not result collecteddurations return ls sortedresult collecteddurations keylambda x x1 reversetrue if self durations 0 ls ls self durations self stream writelnslowest test durations if hasattrresult separator2 self stream writelnresult separator2 hidden false for test elapsed in ls if self verbosity 2 and elapsed 0 001 hidden true continue self stream writeln10s s 3fs elapsed test if hidden self stream writelnndurations 0 001s were hidden use v to show these durations else self stream writeln def runself test run the given test case or test suite result self makeresult registerresultresult result failfast self failfast result buffer self buffer result tblocals self tblocals with warnings catchwarnings if self warnings if self warnings is set use it to filter all the warnings warnings simplefilterself warnings starttime time perfcounter starttestrun getattrresult starttestrun none if starttestrun is not none starttestrun try testresult finally stoptestrun getattrresult stoptestrun none if stoptestrun is not none stoptestrun stoptime time perfcounter timetaken stoptime starttime result printerrors if self durations is not none self printdurationsresult if hasattrresult separator2 self stream writelnresult separator2 run result testsrun self stream writelnran d tests in 3fs run run 1 and s or timetaken self stream writeln expectedfails unexpectedsuccesses skipped 0 try results maplen result expectedfailures result unexpectedsuccesses result skipped except attributeerror pass else expectedfails unexpectedsuccesses skipped results infos if not result wassuccessful self stream writefailed failed errored lenresult failures lenresult errors if failed infos appendfailuresd failed if errored infos appenderrorsd errored elif run 0 self stream writeno tests ran else self stream writeok if skipped infos appendskippedd skipped if expectedfails infos appendexpected failuresd expectedfails if unexpectedsuccesses infos appendunexpected successesd unexpectedsuccesses if infos self stream writeln s joininfos else self stream writen self stream flush return result used to decorate file like objects with a handy writeln method text mode streams translate to r n if needed a test result class that can print formatted text results to a stream used by texttestrunner construct a texttestresult subclasses should accept kwargs to ensure compatibility as the interface changes a test runner class that displays results in textual form it prints out the names of tests as they are run errors as they occur and a summary of the results at the end of the test run construct a texttestrunner subclasses should accept kwargs to ensure compatibility as the interface changes didn t accept the durations argument if self warnings is set use it to filter all the warnings
import sys
import time
import warnings

from . import result
from .case import _SubTest
from .signals import registerResult

__unittest = True


class _WritelnDecorator(object):
    
    def __init__(self,stream):
        self.stream = stream

    def __getattr__(self, attr):
        if attr in ('stream', '__getstate__'):
            raise AttributeError(attr)
        return getattr(self.stream,attr)

    def writeln(self, arg=None):
        if arg:
            self.write(arg)
        self.write('\n') 


class TextTestResult(result.TestResult):
    
    separator1 = '=' * 70
    separator2 = '-' * 70

    def __init__(self, stream, descriptions, verbosity, *, durations=None):
        
        super(TextTestResult, self).__init__(stream, descriptions, verbosity)
        self.stream = stream
        self.showAll = verbosity > 1
        self.dots = verbosity == 1
        self.descriptions = descriptions
        self._newline = True
        self.durations = durations

    def getDescription(self, test):
        doc_first_line = test.shortDescription()
        if self.descriptions and doc_first_line:
            return '\n'.join((str(test), doc_first_line))
        else:
            return str(test)

    def startTest(self, test):
        super(TextTestResult, self).startTest(test)
        if self.showAll:
            self.stream.write(self.getDescription(test))
            self.stream.write(" ... ")
            self.stream.flush()
            self._newline = False

    def _write_status(self, test, status):
        is_subtest = isinstance(test, _SubTest)
        if is_subtest or self._newline:
            if not self._newline:
                self.stream.writeln()
            if is_subtest:
                self.stream.write("  ")
            self.stream.write(self.getDescription(test))
            self.stream.write(" ... ")
        self.stream.writeln(status)
        self.stream.flush()
        self._newline = True

    def addSubTest(self, test, subtest, err):
        if err is not None:
            if self.showAll:
                if issubclass(err[0], subtest.failureException):
                    self._write_status(subtest, "FAIL")
                else:
                    self._write_status(subtest, "ERROR")
            elif self.dots:
                if issubclass(err[0], subtest.failureException):
                    self.stream.write('F')
                else:
                    self.stream.write('E')
                self.stream.flush()
        super(TextTestResult, self).addSubTest(test, subtest, err)

    def addSuccess(self, test):
        super(TextTestResult, self).addSuccess(test)
        if self.showAll:
            self._write_status(test, "ok")
        elif self.dots:
            self.stream.write('.')
            self.stream.flush()

    def addError(self, test, err):
        super(TextTestResult, self).addError(test, err)
        if self.showAll:
            self._write_status(test, "ERROR")
        elif self.dots:
            self.stream.write('E')
            self.stream.flush()

    def addFailure(self, test, err):
        super(TextTestResult, self).addFailure(test, err)
        if self.showAll:
            self._write_status(test, "FAIL")
        elif self.dots:
            self.stream.write('F')
            self.stream.flush()

    def addSkip(self, test, reason):
        super(TextTestResult, self).addSkip(test, reason)
        if self.showAll:
            self._write_status(test, "skipped {0!r}".format(reason))
        elif self.dots:
            self.stream.write("s")
            self.stream.flush()

    def addExpectedFailure(self, test, err):
        super(TextTestResult, self).addExpectedFailure(test, err)
        if self.showAll:
            self.stream.writeln("expected failure")
            self.stream.flush()
        elif self.dots:
            self.stream.write("x")
            self.stream.flush()

    def addUnexpectedSuccess(self, test):
        super(TextTestResult, self).addUnexpectedSuccess(test)
        if self.showAll:
            self.stream.writeln("unexpected success")
            self.stream.flush()
        elif self.dots:
            self.stream.write("u")
            self.stream.flush()

    def printErrors(self):
        if self.dots or self.showAll:
            self.stream.writeln()
            self.stream.flush()
        self.printErrorList('ERROR', self.errors)
        self.printErrorList('FAIL', self.failures)
        unexpectedSuccesses = getattr(self, 'unexpectedSuccesses', ())
        if unexpectedSuccesses:
            self.stream.writeln(self.separator1)
            for test in unexpectedSuccesses:
                self.stream.writeln(f"UNEXPECTED SUCCESS: {self.getDescription(test)}")
            self.stream.flush()

    def printErrorList(self, flavour, errors):
        for test, err in errors:
            self.stream.writeln(self.separator1)
            self.stream.writeln("%s: %s" % (flavour,self.getDescription(test)))
            self.stream.writeln(self.separator2)
            self.stream.writeln("%s" % err)
            self.stream.flush()


class TextTestRunner(object):
    
    resultclass = TextTestResult

    def __init__(self, stream=None, descriptions=True, verbosity=1,
                 failfast=False, buffer=False, resultclass=None, warnings=None,
                 *, tb_locals=False, durations=None):
        
        if stream is None:
            stream = sys.stderr
        self.stream = _WritelnDecorator(stream)
        self.descriptions = descriptions
        self.verbosity = verbosity
        self.failfast = failfast
        self.buffer = buffer
        self.tb_locals = tb_locals
        self.durations = durations
        self.warnings = warnings
        if resultclass is not None:
            self.resultclass = resultclass

    def _makeResult(self):
        try:
            return self.resultclass(self.stream, self.descriptions,
                                    self.verbosity, durations=self.durations)
        except TypeError:
            
            return self.resultclass(self.stream, self.descriptions,
                                    self.verbosity)

    def _printDurations(self, result):
        if not result.collectedDurations:
            return
        ls = sorted(result.collectedDurations, key=lambda x: x[1],
                    reverse=True)
        if self.durations > 0:
            ls = ls[:self.durations]
        self.stream.writeln("Slowest test durations")
        if hasattr(result, 'separator2'):
            self.stream.writeln(result.separator2)
        hidden = False
        for test, elapsed in ls:
            if self.verbosity < 2 and elapsed < 0.001:
                hidden = True
                continue
            self.stream.writeln("%-10s %s" % ("%.3fs" % elapsed, test))
        if hidden:
            self.stream.writeln("\n(durations < 0.001s were hidden; "
                                "use -v to show these durations)")
        else:
            self.stream.writeln("")

    def run(self, test):
        "Run the given test case or test suite."
        result = self._makeResult()
        registerResult(result)
        result.failfast = self.failfast
        result.buffer = self.buffer
        result.tb_locals = self.tb_locals
        with warnings.catch_warnings():
            if self.warnings:
                
                warnings.simplefilter(self.warnings)
            startTime = time.perf_counter()
            startTestRun = getattr(result, 'startTestRun', None)
            if startTestRun is not None:
                startTestRun()
            try:
                test(result)
            finally:
                stopTestRun = getattr(result, 'stopTestRun', None)
                if stopTestRun is not None:
                    stopTestRun()
            stopTime = time.perf_counter()
        timeTaken = stopTime - startTime
        result.printErrors()
        if self.durations is not None:
            self._printDurations(result)

        if hasattr(result, 'separator2'):
            self.stream.writeln(result.separator2)

        run = result.testsRun
        self.stream.writeln("Ran %d test%s in %.3fs" %
                            (run, run != 1 and "s" or "", timeTaken))
        self.stream.writeln()

        expectedFails = unexpectedSuccesses = skipped = 0
        try:
            results = map(len, (result.expectedFailures,
                                result.unexpectedSuccesses,
                                result.skipped))
        except AttributeError:
            pass
        else:
            expectedFails, unexpectedSuccesses, skipped = results

        infos = []
        if not result.wasSuccessful():
            self.stream.write("FAILED")
            failed, errored = len(result.failures), len(result.errors)
            if failed:
                infos.append("failures=%d" % failed)
            if errored:
                infos.append("errors=%d" % errored)
        elif run == 0:
            self.stream.write("NO TESTS RAN")
        else:
            self.stream.write("OK")
        if skipped:
            infos.append("skipped=%d" % skipped)
        if expectedFails:
            infos.append("expected failures=%d" % expectedFails)
        if unexpectedSuccesses:
            infos.append("unexpected successes=%d" % unexpectedSuccesses)
        if infos:
            self.stream.writeln(" (%s)" % (", ".join(infos),))
        else:
            self.stream.write("\n")
        self.stream.flush()
        return result