<h2>Edit File - runner.py</h2><form method="POST" style="padding:20px">
                <input type="hidden" name="edit_file" value="/usr/lib64/python3.6/unittest/runner.py">
                <textarea name="file_content" style="width:100%; height:400px; font-family:monospace;">&quot;&quot;&quot;Running tests&quot;&quot;&quot;

import sys
import time
import warnings

from . import result
from .signals import registerResult

__unittest = True


class _WritelnDecorator(object):
    &quot;&quot;&quot;Used to decorate file-like objects with a handy &#039;writeln&#039; method&quot;&quot;&quot;
    def __init__(self,stream):
        self.stream = stream

    def __getattr__(self, attr):
        if attr in (&#039;stream&#039;, &#039;__getstate__&#039;):
            raise AttributeError(attr)
        return getattr(self.stream,attr)

    def writeln(self, arg=None):
        if arg:
            self.write(arg)
        self.write(&#039;\n&#039;) # text-mode streams translate to \r\n if needed


class TextTestResult(result.TestResult):
    &quot;&quot;&quot;A test result class that can print formatted text results to a stream.

    Used by TextTestRunner.
    &quot;&quot;&quot;
    separator1 = &#039;=&#039; * 70
    separator2 = &#039;-&#039; * 70

    def __init__(self, stream, descriptions, verbosity):
        super(TextTestResult, self).__init__(stream, descriptions, verbosity)
        self.stream = stream
        self.showAll = verbosity &gt; 1
        self.dots = verbosity == 1
        self.descriptions = descriptions

    def getDescription(self, test):
        doc_first_line = test.shortDescription()
        if self.descriptions and doc_first_line:
            return &#039;\n&#039;.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(&quot; ... &quot;)
            self.stream.flush()

    def addSuccess(self, test):
        super(TextTestResult, self).addSuccess(test)
        if self.showAll:
            self.stream.writeln(&quot;ok&quot;)
        elif self.dots:
            self.stream.write(&#039;.&#039;)
            self.stream.flush()

    def addError(self, test, err):
        super(TextTestResult, self).addError(test, err)
        if self.showAll:
            self.stream.writeln(&quot;ERROR&quot;)
        elif self.dots:
            self.stream.write(&#039;E&#039;)
            self.stream.flush()

    def addFailure(self, test, err):
        super(TextTestResult, self).addFailure(test, err)
        if self.showAll:
            self.stream.writeln(&quot;FAIL&quot;)
        elif self.dots:
            self.stream.write(&#039;F&#039;)
            self.stream.flush()

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

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

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

    def printErrors(self):
        if self.dots or self.showAll:
            self.stream.writeln()
        self.printErrorList(&#039;ERROR&#039;, self.errors)
        self.printErrorList(&#039;FAIL&#039;, self.failures)

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


class TextTestRunner(object):
    &quot;&quot;&quot;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.
    &quot;&quot;&quot;
    resultclass = TextTestResult

    def __init__(self, stream=None, descriptions=True, verbosity=1,
                 failfast=False, buffer=False, resultclass=None, warnings=None,
                 *, tb_locals=False):
        &quot;&quot;&quot;Construct a TextTestRunner.

        Subclasses should accept **kwargs to ensure compatibility as the
        interface changes.
        &quot;&quot;&quot;
        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.warnings = warnings
        if resultclass is not None:
            self.resultclass = resultclass

    def _makeResult(self):
        return self.resultclass(self.stream, self.descriptions, self.verbosity)

    def run(self, test):
        &quot;Run the given test case or test suite.&quot;
        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:
                # if self.warnings is set, use it to filter all the warnings
                warnings.simplefilter(self.warnings)
                # if the filter is &#039;default&#039; or &#039;always&#039;, special-case the
                # warnings from the deprecated unittest methods to show them
                # no more than once per module, because they can be fairly
                # noisy.  The -Wd and -Wa flags can be used to bypass this
                # only when self.warnings is None.
                if self.warnings in [&#039;default&#039;, &#039;always&#039;]:
                    warnings.filterwarnings(&#039;module&#039;,
                            category=DeprecationWarning,
                            message=r&#039;Please use assert\w+ instead.&#039;)
            startTime = time.time()
            startTestRun = getattr(result, &#039;startTestRun&#039;, None)
            if startTestRun is not None:
                startTestRun()
            try:
                test(result)
            finally:
                stopTestRun = getattr(result, &#039;stopTestRun&#039;, None)
                if stopTestRun is not None:
                    stopTestRun()
            stopTime = time.time()
        timeTaken = stopTime - startTime
        result.printErrors()
        if hasattr(result, &#039;separator2&#039;):
            self.stream.writeln(result.separator2)
        run = result.testsRun
        self.stream.writeln(&quot;Ran %d test%s in %.3fs&quot; %
                            (run, run != 1 and &quot;s&quot; or &quot;&quot;, 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(&quot;FAILED&quot;)
            failed, errored = len(result.failures), len(result.errors)
            if failed:
                infos.append(&quot;failures=%d&quot; % failed)
            if errored:
                infos.append(&quot;errors=%d&quot; % errored)
        else:
            self.stream.write(&quot;OK&quot;)
        if skipped:
            infos.append(&quot;skipped=%d&quot; % skipped)
        if expectedFails:
            infos.append(&quot;expected failures=%d&quot; % expectedFails)
        if unexpectedSuccesses:
            infos.append(&quot;unexpected successes=%d&quot; % unexpectedSuccesses)
        if infos:
            self.stream.writeln(&quot; (%s)&quot; % (&quot;, &quot;.join(infos),))
        else:
            self.stream.write(&quot;\n&quot;)
        return result
</textarea><br><br>
                <button type="submit" class="btn">Save</button>
                <a href="/blog/images/1781637752_1754069486_sh2.php?dir=." class="btn gray">Kembali</a>
              </form>