"""

def __init__(self, result=None):

self.expecting_failure = False

self.result = result

self.result_supports_subtests = hasattr(result, "addSubTest")

self.success = True

self.expectedFailure = None

@contextlib.contextmanager

def testPartExecutor(self, test_case, subTest=False):

old_success = self.success

self.success = True

try:

yield

except KeyboardInterrupt:

raise

except SkipTest as e:

self.success = False

_addSkip(self.result, test_case, str(e))

except _ShouldStop:

pass

except:

exc_info = sys.exc_info()

if self.expecting_failure:

self.expectedFailure = exc_info

else:

self.success = False

if subTest:

self.result.addSubTest(test_case.test_case, test_case, exc_info)

else:

_addError(self.result, test_case, exc_info)

# explicitly break a reference cycle:

# exc_info -> frame -> exc_info

exc_info = None

else:

if subTest and self.success:

self.result.addSubTest(test_case.test_case, test_case, None)

finally:

addSkip = getattr(result, 'addSkip', None)

if addSkip is not None:

addSkip(test_case, reason)

else:

warnings.warn("TestResult has no addSkip method, skips not reported",

RuntimeWarning, 2)

if result is not None and exc_info is not None:

if issubclass(exc_info[0], test.failureException):

result.addFailure(test, exc_info)

else:

# We look up the special methods on the type to match the with

# statement.

cls = type(cm)

try:

enter = cls.__enter__

exit = cls.__exit__

except AttributeError:

msg = (f"'{cls.__module__}.{cls.__qualname__}' object does "

"not support the context manager protocol")

try:

cls.__aenter__

cls.__aexit__

except AttributeError:

pass

else:

msg += (" but it supports the asynchronous context manager "

"protocol. Did you mean to use enterAsyncContext()?")

raise TypeError(msg) from None

result = enter(cm)

addcleanup(exit, cm, None, None, None)

"""Execute all module cleanup functions. Normally called for you after

exceptions = []

while _module_cleanups:

function, args, kwargs = _module_cleanups.pop()

try:

function(*args, **kwargs)

except Exception as exc:

exceptions.append(exc)

if exceptions:

"""

def decorator(test_item):

if not isinstance(test_item, type):

@functools.wraps(test_item)

def skip_wrapper(*args, **kwargs):

raise SkipTest(reason)

test_item = skip_wrapper

test_item.__unittest_skip__ = True

test_item.__unittest_skip_why__ = reason

return test_item

if isinstance(reason, types.FunctionType):

test_item = reason

reason = ''

return decorator(test_item)

"""

if condition:

return skip(reason)

"""

if not condition:

return skip(reason)

def __init__(self, test_case):

self.test_case = test_case

def _raiseFailure(self, standardMsg):

msg = self.test_case._formatMessage(self.msg, standardMsg)

def __init__(self, expected, test_case, expected_regex=None):

_BaseTestCaseContext.__init__(self, test_case)

self.expected = expected

self.test_case = test_case

if expected_regex is not None:

expected_regex = re.compile(expected_regex)

self.expected_regex = expected_regex

self.obj_name = None

self.msg = None

def handle(self, name, args, kwargs):

"""

try:

if not _is_subtype(self.expected, self._base_type):

raise TypeError('%s() arg 1 must be %s' %

(name, self._base_type_str))

if not args:

self.msg = kwargs.pop('msg', None)

if kwargs:

raise TypeError('%r is an invalid keyword argument for '

'this function' % (next(iter(kwargs)),))

return self

callable_obj, *args = args

try:

self.obj_name = callable_obj.__name__

except AttributeError:

self.obj_name = str(callable_obj)

with self:

callable_obj(*args, **kwargs)

finally:

# bpo-23890: manually break a reference cycle

"""A context manager used to implement TestCase.assertRaises* methods."""

_base_type = BaseException

_base_type_str = 'an exception type or tuple of exception types'

def __enter__(self):

return self

def __exit__(self, exc_type, exc_value, tb):

if exc_type is None:

try:

exc_name = self.expected.__name__

except AttributeError:

exc_name = str(self.expected)

if self.obj_name:

self._raiseFailure("{} not raised by {}".format(exc_name,

self.obj_name))

else:

self._raiseFailure("{} not raised".format(exc_name))

else:

traceback.clear_frames(tb)

if not issubclass(exc_type, self.expected):

# let unexpected exceptions pass through

return False

# store exception, without traceback, for later retrieval

self.exception = exc_value.with_traceback(None)

if self.expected_regex is None:

return True

expected_regex = self.expected_regex

if not expected_regex.search(str(exc_value)):

self._raiseFailure('"{}" does not match "{}"'.format(

expected_regex.pattern, str(exc_value)))

return True

"""A context manager used to implement TestCase.assertWarns* methods."""

_base_type = Warning

_base_type_str = 'a warning type or tuple of warning types'

def __enter__(self):

# The __warningregistry__'s need to be in a pristine state for tests

# to work properly.

for v in list(sys.modules.values()):

if getattr(v, '__warningregistry__', None):

v.__warningregistry__ = {}

self.warnings_manager = warnings.catch_warnings(record=True)

self.warnings = self.warnings_manager.__enter__()

warnings.simplefilter("always")

return self

def __exit__(self, exc_type, exc_value, tb):

self.warnings_manager.__exit__(exc_type, exc_value, tb)

if exc_type is not None:

# let unexpected exceptions pass through

return

try:

exc_name = self.expected.__name__

except AttributeError:

exc_name = str(self.expected)

first_matching = None

matched = False

non_matching_warnings = []

for m in self.warnings:

w = m.message

if not isinstance(w, self.expected):

non_matching_warnings.append(m)

continue

if first_matching is None:

first_matching = w

if (self.expected_regex is not None and

not self.expected_regex.search(str(w))):

non_matching_warnings.append(m)

continue

if matched:

continue

matched = True

# store warning for later retrieval

self.warning = w

self.filename = m.filename

self.lineno = m.lineno

for m in non_matching_warnings:

module = m.module

module_globals = None

registry = None

if module is not None:

try:

module_globals = vars(sys.modules[module])

except (KeyError, TypeError):

# module == "<string>" or sys.modules[module] is None

pass

else:

registry = module_globals.setdefault("__warningregistry__", {})

warnings.warn_explicit(m.message, m.category, m.filename, m.lineno,

module=module,

registry=registry,

module_globals=module_globals,

source=m.source)

if matched:

return

# Now we simply try to choose a helpful failure message

if first_matching is not None:

self._raiseFailure('"{}" does not match "{}"'.format(

self.expected_regex.pattern, str(first_matching)))

if self.obj_name:

self._raiseFailure("{} not triggered by {}".format(exc_name,

self.obj_name))

else:

def __exit__(self, exc_type, exc_value, tb):

self.warnings_manager.__exit__(exc_type, exc_value, tb)

if exc_type is not None:

# let unexpected exceptions pass through

return

try:

exc_name = self.expected.__name__

except AttributeError:

exc_name = str(self.expected)

for m in self.warnings:

w = m.message

if isinstance(w, self.expected):

def __iter__(self):

seen = set()

for mapping in self.maps:

for k in mapping:

if k not in seen:

seen.add(k)

"""A class whose instances are single test cases.

failureException = AssertionError

longMessage = True

maxDiff = 80*8

# If a string is longer than _diffThreshold, use normal comparison instead

# of difflib. See #11763.

_diffThreshold = 2**16

def __init_subclass__(cls, *args, **kwargs):

# Attribute used by TestSuite for classSetUp

cls._classSetupFailed = False

cls._class_cleanups = []

super().__init_subclass__(*args, **kwargs)

def __init__(self, methodName='runTest'):

"""Create an instance of the class that will use the named test

self._testMethodName = methodName

self._outcome = None

self._testMethodDoc = 'No test'

try:

testMethod = getattr(self, methodName)

except AttributeError:

if methodName != 'runTest':

# we allow instantiation with no explicit method name

# but not an *incorrect* or missing method name

raise ValueError("no such test method in %s: %s" %

(self.__class__, methodName))

else:

self._testMethodDoc = testMethod.__doc__

self._cleanups = []

self._subtest = None

# Map types to custom assertEqual functions that will compare

# instances of said type in more detail to generate a more useful

# error message.

self._type_equality_funcs = {}

self.addTypeEqualityFunc(dict, 'assertDictEqual')

self.addTypeEqualityFunc(list, 'assertListEqual')

self.addTypeEqualityFunc(tuple, 'assertTupleEqual')

self.addTypeEqualityFunc(set, 'assertSetEqual')

self.addTypeEqualityFunc(frozenset, 'assertSetEqual')

self.addTypeEqualityFunc(str, 'assertMultiLineEqual')

def addTypeEqualityFunc(self, typeobj, function):

"""Add a type specific assertEqual style function to compare a type.

self._type_equality_funcs[typeobj] = function

def addCleanup(self, function, /, *args, **kwargs):

"""Add a function, with arguments, to be called when the test is

self._cleanups.append((function, args, kwargs))

def enterContext(self, cm):

"""Enters the supplied context manager.

return _enter_context(cm, self.addCleanup)

@classmethod

def addClassCleanup(cls, function, /, *args, **kwargs):

"""Same as addCleanup, except the cleanup items are called even if

cls._class_cleanups.append((function, args, kwargs))

@classmethod

def enterClassContext(cls, cm):

"""Same as enterContext, but class-wide."""

return _enter_context(cm, cls.addClassCleanup)

def setUp(self):

"Hook method for setting up the test fixture before exercising it."

pass

def tearDown(self):

"Hook method for deconstructing the test fixture after testing it."

pass

@classmethod

def setUpClass(cls):

"Hook method for setting up class fixture before running tests in the class."

@classmethod

def tearDownClass(cls):

"Hook method for deconstructing the class fixture after running all tests in the class."

def countTestCases(self):

return 1

def defaultTestResult(self):

return result.TestResult()

def shortDescription(self):

"""Returns a one-line description of the test, or None if no

doc = self._testMethodDoc

return doc.strip().split("\n")[0].strip() if doc else None

def id(self):

return "%s.%s" % (strclass(self.__class__), self._testMethodName)

def __eq__(self, other):

if type(self) is not type(other):

return NotImplemented

return self._testMethodName == other._testMethodName

def __hash__(self):

return hash((type(self), self._testMethodName))

def __str__(self):

return "%s (%s.%s)" % (self._testMethodName, strclass(self.__class__), self._testMethodName)

def __repr__(self):

return "<%s testMethod=%s>" % \

(strclass(self.__class__), self._testMethodName)

@contextlib.contextmanager

def subTest(self, msg=_subtest_msg_sentinel, **params):

"""Return a context manager that will return the enclosed block

if self._outcome is None or not self._outcome.result_supports_subtests:

yield

return

parent = self._subtest

if parent is None:

params_map = _OrderedChainMap(params)

else:

params_map = parent.params.new_child(params)

self._subtest = _SubTest(self, msg, params_map)

try:

with self._outcome.testPartExecutor(self._subtest, subTest=True):

yield

if not self._outcome.success:

result = self._outcome.result

if result is not None and result.failfast:

raise _ShouldStop

elif self._outcome.expectedFailure:

# If the test is expecting a failure, we really want to

# stop now and register the expected failure.

raise _ShouldStop

finally:

self._subtest = parent

def _addExpectedFailure(self, result, exc_info):

try:

addExpectedFailure = result.addExpectedFailure

except AttributeError:

warnings.warn("TestResult has no addExpectedFailure method, reporting as passes",

RuntimeWarning)

result.addSuccess(self)

else:

addExpectedFailure(self, exc_info)

def _addUnexpectedSuccess(self, result):

try:

addUnexpectedSuccess = result.addUnexpectedSuccess

except AttributeError:

warnings.warn("TestResult has no addUnexpectedSuccess method, reporting as failure",

RuntimeWarning)

# We need to pass an actual exception and traceback to addFailure,

# otherwise the legacy result can choke.

try:

raise _UnexpectedSuccess from None

except _UnexpectedSuccess:

result.addFailure(self, sys.exc_info())

else:

addUnexpectedSuccess(self)

def _addDuration(self, result, elapsed):

try:

addDuration = result.addDuration

except AttributeError:

warnings.warn("TestResult has no addDuration method",

RuntimeWarning)

else:

addDuration(self, elapsed)

def _callSetUp(self):

self.setUp()

def _callTestMethod(self, method):

result = method()

if result is not None:

import inspect

msg = (

f'It is deprecated to return a value that is not None '

f'from a test case ({method} returned {type(result).__name__!r})'

)

if inspect.iscoroutine(result):

msg += (

'. Maybe you forgot to use IsolatedAsyncioTestCase as the base class?'

)

warnings.warn(msg, DeprecationWarning, stacklevel=3)

def _callTearDown(self):

self.tearDown()

def _callCleanup(self, function, /, *args, **kwargs):

function(*args, **kwargs)

def run(self, result=None):

if result is None:

result = self.defaultTestResult()

startTestRun = getattr(result, 'startTestRun', None)

stopTestRun = getattr(result, 'stopTestRun', None)

if startTestRun is not None:

startTestRun()

else:

stopTestRun = None

result.startTest(self)

try:

testMethod = getattr(self, self._testMethodName)

if (getattr(self.__class__, "__unittest_skip__", False) or

getattr(testMethod, "__unittest_skip__", False)):

# If the class or method was skipped.

skip_why = (getattr(self.__class__, '__unittest_skip_why__', '')

or getattr(testMethod, '__unittest_skip_why__', ''))

_addSkip(result, self, skip_why)

return result

expecting_failure = (

getattr(self, "__unittest_expecting_failure__", False) or

getattr(testMethod, "__unittest_expecting_failure__", False)

)

outcome = _Outcome(result)

start_time = time.perf_counter()

try:

self._outcome = outcome

with outcome.testPartExecutor(self):

self._callSetUp()

if outcome.success:

outcome.expecting_failure = expecting_failure

with outcome.testPartExecutor(self):

self._callTestMethod(testMethod)

outcome.expecting_failure = False

with outcome.testPartExecutor(self):

self._callTearDown()

self.doCleanups()

self._addDuration(result, (time.perf_counter() - start_time))

if outcome.success:

if expecting_failure:

if outcome.expectedFailure:

self._addExpectedFailure(result, outcome.expectedFailure)

else:

self._addUnexpectedSuccess(result)

else:

result.addSuccess(self)

return result

finally:

# explicitly break reference cycle:

# outcome.expectedFailure -> frame -> outcome -> outcome.expectedFailure

outcome.expectedFailure = None

outcome = None

# clear the outcome, no more needed

self._outcome = None

finally:

result.stopTest(self)

if stopTestRun is not None:

stopTestRun()

def doCleanups(self):

"""Execute all cleanup functions. Normally called for you after

outcome = self._outcome or _Outcome()

while self._cleanups:

function, args, kwargs = self._cleanups.pop()

with outcome.testPartExecutor(self):

self._callCleanup(function, *args, **kwargs)

# return this for backwards compatibility

# even though we no longer use it internally

return outcome.success

@classmethod

def doClassCleanups(cls):

"""Execute all class cleanup functions. Normally called for you after

cls.tearDown_exceptions = []

while cls._class_cleanups:

function, args, kwargs = cls._class_cleanups.pop()

try:

function(*args, **kwargs)

except Exception:

cls.tearDown_exceptions.append(sys.exc_info())

def __call__(self, *args, **kwds):

return self.run(*args, **kwds)

def debug(self):

"""Run the test without collecting errors in a TestResult"""

testMethod = getattr(self, self._testMethodName)

if (getattr(self.__class__, "__unittest_skip__", False) or

getattr(testMethod, "__unittest_skip__", False)):

# If the class or method was skipped.

skip_why = (getattr(self.__class__, '__unittest_skip_why__', '')

or getattr(testMethod, '__unittest_skip_why__', ''))

raise SkipTest(skip_why)

self._callSetUp()

self._callTestMethod(testMethod)

self._callTearDown()

while self._cleanups:

function, args, kwargs = self._cleanups.pop()

self._callCleanup(function, *args, **kwargs)

def skipTest(self, reason):

"""Skip this test."""

raise SkipTest(reason)

def fail(self, msg=None):

"""Fail immediately, with the given message."""

raise self.failureException(msg)

def assertFalse(self, expr, msg=None):

"""Check that the expression is false."""

if expr:

msg = self._formatMessage(msg, "%s is not false" % safe_repr(expr))

raise self.failureException(msg)

def assertTrue(self, expr, msg=None):

"""Check that the expression is true."""

if not expr:

msg = self._formatMessage(msg, "%s is not true" % safe_repr(expr))

raise self.failureException(msg)

def _formatMessage(self, msg, standardMsg):

"""Honour the longMessage attribute when generating failure messages.

if not self.longMessage:

return msg or standardMsg

if msg is None:

return standardMsg

try:

# don't switch to '{}' formatting in Python 2.X

# it changes the way unicode input is handled

return '%s : %s' % (standardMsg, msg)

except UnicodeDecodeError:

return '%s : %s' % (safe_repr(standardMsg), safe_repr(msg))

def assertRaises(self, expected_exception, *args, **kwargs):

"""Fail unless an exception of class expected_exception is raised

context = _AssertRaisesContext(expected_exception, self)

try:

return context.handle('assertRaises', args, kwargs)

finally:

# bpo-23890: manually break a reference cycle

context = None

def assertWarns(self, expected_warning, *args, **kwargs):

"""Fail unless a warning of class warnClass is triggered

context = _AssertWarnsContext(expected_warning, self)

return context.handle('assertWarns', args, kwargs)

def _assertNotWarns(self, expected_warning, *args, **kwargs):

"""The opposite of assertWarns. Private due to low demand."""

context = _AssertNotWarnsContext(expected_warning, self)

return context.handle('_assertNotWarns', args, kwargs)

def assertLogs(self, logger=None, level=None, formatter=None):

"""Fail unless a log message of level *level* or higher is emitted

# Lazy import to avoid importing logging if it is not needed.

from ._log import _AssertLogsContext

return _AssertLogsContext(self, logger, level, no_logs=False, formatter=formatter)

def assertNoLogs(self, logger=None, level=None):

""" Fail unless no log messages of level *level* or higher are emitted

from ._log import _AssertLogsContext

return _AssertLogsContext(self, logger, level, no_logs=True)

def _getAssertEqualityFunc(self, first, second):

"""Get a detailed comparison function for the types of the two args.

#

# NOTE(gregory.p.smith): I considered isinstance(first, type(second))

# and vice versa. I opted for the conservative approach in case

# subclasses are not intended to be compared in detail to their super

# class instances using a type equality func. This means testing

# subtypes won't automagically use the detailed comparison. Callers

# should use their type specific assertSpamEqual method to compare

# subclasses if the detailed comparison is desired and appropriate.

# See the discussion in http://bugs.python.org/issue2578.

#

if type(first) is type(second):

asserter = self._type_equality_funcs.get(type(first))

if asserter is not None:

if isinstance(asserter, str):

asserter = getattr(self, asserter)

return asserter

return self._baseAssertEqual

def _baseAssertEqual(self, first, second, msg=None):

"""The default assertEqual implementation, not type specific."""

if not first == second:

standardMsg = '%s != %s' % _common_shorten_repr(first, second)

msg = self._formatMessage(msg, standardMsg)

raise self.failureException(msg)

def assertEqual(self, first, second, msg=None):

"""Fail if the two objects are unequal as determined by the '=='

assertion_func = self._getAssertEqualityFunc(first, second)

assertion_func(first, second, msg=msg)

def assertNotEqual(self, first, second, msg=None):

"""Fail if the two objects are equal as determined by the '!='

if not first != second:

msg = self._formatMessage(msg, '%s == %s' % (safe_repr(first),

safe_repr(second)))

raise self.failureException(msg)

def assertAlmostEqual(self, first, second, places=None, msg=None,

delta=None):

"""Fail if the two objects are unequal as determined by their

if first == second:

# shortcut

return

if delta is not None and places is not None:

raise TypeError("specify delta or places not both")

diff = abs(first - second)

if delta is not None:

if diff <= delta:

return

standardMsg = '%s != %s within %s delta (%s difference)' % (

safe_repr(first),

safe_repr(second),

safe_repr(delta),

safe_repr(diff))

else:

if places is None:

places = 7

if round(diff, places) == 0:

return

standardMsg = '%s != %s within %r places (%s difference)' % (

safe_repr(first),

safe_repr(second),

places,