File Manager

X7ROOT File Manager

Current Path: /opt/cloudlinux/venv/lib/python3.11/site-packages/tap

opt / cloudlinux / venv / lib / python3.11 / site-packages / tap /

?? ..
?? __init__.py(85 B)
?? __main__.py(48 B)
?? __pycache__
?? adapter.py(1.47 KB)
?? directive.py(1.75 KB)
?? formatter.py(762 B)
?? line.py(4.56 KB)
?? loader.py(2.87 KB)
?? main.py(2.07 KB)
?? parser.py(6.63 KB)
?? rules.py(3.3 KB)
?? runner.py(4.95 KB)
?? tests
?? tracker.py(7.4 KB)

Editing: runner.py

import os
import sys
from unittest import TextTestResult, TextTestRunner
from unittest.runner import _WritelnDecorator

from tap import formatter
from tap.tracker import Tracker

class TAPTestResult(TextTestResult):
    FORMAT = None

def __init__(self, stream, descriptions, verbosity):
        super().__init__(stream, descriptions, verbosity)

def addSubTest(self, test, subtest, err):
        super().addSubTest(test, subtest, err)
        if err is not None:
            diagnostics = formatter.format_exception(err)
            self.tracker.add_not_ok(
                self._cls_name(test),
                self._description(subtest),
                diagnostics=diagnostics,
            )
        else:
            self.tracker.add_ok(self._cls_name(test), self._description(subtest))

def stopTestRun(self):  # pragma: no cover
        """Once the test run is complete, generate each of the TAP files."""
        super().stopTestRun()
        self.tracker.generate_tap_reports()

def addError(self, test, err):
        super().addError(test, err)
        diagnostics = formatter.format_exception(err)
        self.tracker.add_not_ok(
            self._cls_name(test), self._description(test), diagnostics=diagnostics
        )

def addFailure(self, test, err):
        super().addFailure(test, err)
        diagnostics = formatter.format_exception(err)
        self.tracker.add_not_ok(
            self._cls_name(test), self._description(test), diagnostics=diagnostics
        )

def addSuccess(self, test):
        super().addSuccess(test)
        self.tracker.add_ok(self._cls_name(test), self._description(test))

def addSkip(self, test, reason):
        super().addSkip(test, reason)
        self.tracker.add_skip(self._cls_name(test), self._description(test), reason)

def addExpectedFailure(self, test, err):
        super().addExpectedFailure(test, err)
        diagnostics = formatter.format_exception(err)
        self.tracker.add_not_ok(
            self._cls_name(test),
            self._description(test),
            "TODO {}".format("(expected failure)"),
            diagnostics=diagnostics,
        )

def addUnexpectedSuccess(self, test):
        super().addUnexpectedSuccess(test)
        self.tracker.add_ok(
            self._cls_name(test),
            self._description(test),
            "TODO {}".format("(unexpected success)"),
        )

def _cls_name(self, test):
        return test.__class__.__name__

def _description(self, test):
        if self.FORMAT:
            try:
                return self.FORMAT.format(
                    method_name=str(test),
                    short_description=test.shortDescription() or "",
                )
            except KeyError:
                sys.exit(
                    f"Bad format string: {self.FORMAT}\n"
                    "Replacement options are: {short_description} and "
                    "{method_name}"
                )

return test.shortDescription() or str(test)

# TODO: 2016-7-30 mblayman - Since the 2.6 signature is no longer relevant,
# check the possibility of removing the module level scope.

# Module level state stinks, but this is the only way to keep compatibility
# with Python 2.6. The best place for the tracker is as an instance variable
# on the runner, but __init__ is so different that it is not easy to create
# a runner that satisfies every supported Python version.
_tracker = Tracker()

class TAPTestRunner(TextTestRunner):
    """A test runner that will behave exactly like TextTestRunner and will
    additionally generate TAP files for each test case"""

resultclass = TAPTestResult

def set_stream(self, streaming):
        """Set the streaming boolean option to stream TAP directly to stdout.

The test runner default output will be suppressed in favor of TAP.
        """
        self.stream = _WritelnDecorator(open(os.devnull, "w"))  # noqa: SIM115
        _tracker.streaming = streaming
        _tracker.stream = sys.stdout

def _makeResult(self):  # pragma: no cover
        result = self.resultclass(self.stream, self.descriptions, self.verbosity)
        result.tracker = _tracker
        return result

@classmethod
    def set_outdir(cls, outdir):
        """Set the output directory so that TAP files are written to the
        specified outdir location.
        """
        # Blame the lack of unittest extensibility for this hacky method.
        _tracker.outdir = outdir

@classmethod
    def set_combined(cls, combined):
        """Set the tracker to use a single output file."""
        _tracker.combined = combined

@classmethod
    def set_header(cls, header):
        """Set the header display flag."""
        _tracker.header = header

@classmethod
    def set_format(cls, fmt):
        """Set the format of each test line.

The format string can use:
        * {method_name}: The test method name
        * {short_description}: The test's docstring short description
        """
        TAPTestResult.FORMAT = fmt

X7ROOT File Manager

Editing: runner.py

Upload File

Create Folder