case.py

"""Test case implementation"""

importsys
importfunctools
importdifflib
importpprint
importre
importwarnings
importcollections
importcontextlib
importtraceback
importtime
importtypes

from . importresult
from .utilimport (strclass, safe_repr, _count_diff_all_purpose,
_count_diff_hashable, _common_shorten_repr)

__unittest=True

_subtest_msg_sentinel=object()

DIFF_OMITTED= ('\nDiff is %s characters long. '
'Set self.maxDiff to None to see it.')

classSkipTest(Exception):
"""
 Raise this exception in a test to skip it.

 Usually you can use TestCase.skipTest() or one of the skipping decorators
 instead of raising this directly.
 """

class_ShouldStop(Exception):
"""
 The test should stop.
 """

class_UnexpectedSuccess(Exception):
"""
 The test was supposed to fail, but it didn't!
 """


class_Outcome(object):
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
deftestPartExecutor(self, test_case, subTest=False):
old_success=self.success
self.success=True
try:
yield
exceptKeyboardInterrupt:
raise
exceptSkipTestase:
self.success=False
_addSkip(self.result, test_case, str(e))
except_ShouldStop:
pass
except:
exc_info=sys.exc_info()
ifself.expecting_failure:
self.expectedFailure=exc_info
else:
self.success=False
ifsubTest:
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:
ifsubTestandself.success:
self.result.addSubTest(test_case.test_case, test_case, None)
finally:
self.success=self.successandold_success


def_addSkip(result, test_case, reason):
addSkip=getattr(result, 'addSkip', None)
ifaddSkipisnotNone:
addSkip(test_case, reason)
else:
warnings.warn("TestResult has no addSkip method, skips not reported",
RuntimeWarning, 2)
result.addSuccess(test_case)

def_addError(result, test, exc_info):
ifresultisnotNoneandexc_infoisnotNone:
ifissubclass(exc_info[0], test.failureException):
result.addFailure(test, exc_info)
else:
result.addError(test, exc_info)

def_id(obj):
returnobj


def_enter_context(cm, addcleanup):
# We look up the special methods on the type to match the with
# statement.
cls=type(cm)
try:
enter=cls.__enter__
exit=cls.__exit__
exceptAttributeError:
raiseTypeError(f"'{cls.__module__}.{cls.__qualname__}' object does "
f"not support the context manager protocol") fromNone
result=enter(cm)
addcleanup(exit, cm, None, None, None)
returnresult


_module_cleanups= []
defaddModuleCleanup(function, /, *args, **kwargs):
"""Same as addCleanup, except the cleanup items are called even if
 setUpModule fails (unlike tearDownModule)."""
_module_cleanups.append((function, args, kwargs))

defenterModuleContext(cm):
"""Same as enterContext, but module-wide."""
return_enter_context(cm, addModuleCleanup)


defdoModuleCleanups():
"""Execute all module cleanup functions. Normally called for you after
 tearDownModule."""
exceptions= []
while_module_cleanups:
function, args, kwargs=_module_cleanups.pop()
try:
function(*args, **kwargs)
exceptExceptionasexc:
exceptions.append(exc)
ifexceptions:
# Swallows all but first exception. If a multi-exception handler
# gets written we should use that here instead.
raiseexceptions[0]


defskip(reason):
"""
 Unconditionally skip a test.
 """
defdecorator(test_item):
ifnotisinstance(test_item, type):
@functools.wraps(test_item)
defskip_wrapper(*args, **kwargs):
raiseSkipTest(reason)
test_item=skip_wrapper

test_item.__unittest_skip__=True
test_item.__unittest_skip_why__=reason
returntest_item
ifisinstance(reason, types.FunctionType):
test_item=reason
reason=''
returndecorator(test_item)
returndecorator

defskipIf(condition, reason):
"""
 Skip a test if the condition is true.
 """
ifcondition:
returnskip(reason)
return_id

defskipUnless(condition, reason):
"""
 Skip a test unless the condition is true.
 """
ifnotcondition:
returnskip(reason)
return_id

defexpectedFailure(test_item):
test_item.__unittest_expecting_failure__=True
returntest_item

def_is_subtype(expected, basetype):
ifisinstance(expected, tuple):
returnall(_is_subtype(e, basetype) foreinexpected)
returnisinstance(expected, type) andissubclass(expected, basetype)

class_BaseTestCaseContext:

def__init__(self, test_case):
self.test_case=test_case

def_raiseFailure(self, standardMsg):
msg=self.test_case._formatMessage(self.msg, standardMsg)
raiseself.test_case.failureException(msg)

class_AssertRaisesBaseContext(_BaseTestCaseContext):

def__init__(self, expected, test_case, expected_regex=None):
_BaseTestCaseContext.__init__(self, test_case)
self.expected=expected
self.test_case=test_case
ifexpected_regexisnotNone:
expected_regex=re.compile(expected_regex)
self.expected_regex=expected_regex
self.obj_name=None
self.msg=None

defhandle(self, name, args, kwargs):
"""
 If args is empty, assertRaises/Warns is being used as a
 context manager, so check for a 'msg' kwarg and return self.
 If args is not empty, call a callable passing positional and keyword
 arguments.
 """
try:
ifnot_is_subtype(self.expected, self._base_type):
raiseTypeError('%s() arg 1 must be %s'%
 (name, self._base_type_str))
ifnotargs:
self.msg=kwargs.pop('msg', None)
ifkwargs:
raiseTypeError('%r is an invalid keyword argument for '
'this function'% (next(iter(kwargs)),))
returnself

callable_obj, *args=args
try:
self.obj_name=callable_obj.__name__
exceptAttributeError:
self.obj_name=str(callable_obj)
withself:
callable_obj(*args, **kwargs)
finally:
# bpo-23890: manually break a reference cycle
self=None


class_AssertRaisesContext(_AssertRaisesBaseContext):
"""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):
returnself

def__exit__(self, exc_type, exc_value, tb):
ifexc_typeisNone:
try:
exc_name=self.expected.__name__
exceptAttributeError:
exc_name=str(self.expected)
ifself.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)
ifnotissubclass(exc_type, self.expected):
# let unexpected exceptions pass through
returnFalse
# store exception, without traceback, for later retrieval
self.exception=exc_value.with_traceback(None)
ifself.expected_regexisNone:
returnTrue

expected_regex=self.expected_regex
ifnotexpected_regex.search(str(exc_value)):
self._raiseFailure('"{}" does not match "{}"'.format(
expected_regex.pattern, str(exc_value)))
returnTrue

__class_getitem__=classmethod(types.GenericAlias)


class_AssertWarnsContext(_AssertRaisesBaseContext):
"""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.
forvinlist(sys.modules.values()):
ifgetattr(v, '__warningregistry__', None):
v.__warningregistry__= {}
self.warnings_manager=warnings.catch_warnings(record=True)
self.warnings=self.warnings_manager.__enter__()
warnings.simplefilter("always", self.expected)
returnself

def__exit__(self, exc_type, exc_value, tb):
self.warnings_manager.__exit__(exc_type, exc_value, tb)
ifexc_typeisnotNone:
# let unexpected exceptions pass through
return
try:
exc_name=self.expected.__name__
exceptAttributeError:
exc_name=str(self.expected)
first_matching=None
forminself.warnings:
w=m.message
ifnotisinstance(w, self.expected):
continue
iffirst_matchingisNone:
first_matching=w
if (self.expected_regexisnotNoneand
notself.expected_regex.search(str(w))):
continue
# store warning for later retrieval
self.warning=w
self.filename=m.filename
self.lineno=m.lineno
return
# Now we simply try to choose a helpful failure message
iffirst_matchingisnotNone:
self._raiseFailure('"{}" does not match "{}"'.format(
self.expected_regex.pattern, str(first_matching)))
ifself.obj_name:
self._raiseFailure("{} not triggered by {}".format(exc_name,
self.obj_name))
else:
self._raiseFailure("{} not triggered".format(exc_name))


class_AssertNotWarnsContext(_AssertWarnsContext):

def__exit__(self, exc_type, exc_value, tb):
self.warnings_manager.__exit__(exc_type, exc_value, tb)
ifexc_typeisnotNone:
# let unexpected exceptions pass through
return
try:
exc_name=self.expected.__name__
exceptAttributeError:
exc_name=str(self.expected)
forminself.warnings:
w=m.message
ifisinstance(w, self.expected):
self._raiseFailure(f"{exc_name} triggered")


class_OrderedChainMap(collections.ChainMap):
def__iter__(self):
seen=set()
formappinginself.maps:
forkinmapping:
ifknotinseen:
seen.add(k)
yieldk


classTestCase(object):
"""A class whose instances are single test cases.

 By default, the test code itself should be placed in a method named
 'runTest'.

 If the fixture may be used for many test cases, create as
 many test methods as are needed. When instantiating such a TestCase
 subclass, specify in the constructor arguments the name of the test method
 that the instance is to execute.

 Test authors should subclass TestCase for their own tests. Construction
 and deconstruction of the test's environment ('fixture') can be
 implemented by overriding the 'setUp' and 'tearDown' methods respectively.

 If it is necessary to override the __init__ method, the base class
 __init__ method must always be called. It is important that subclasses
 should not change the signature of their __init__ method, since instances
 of the classes are instantiated automatically by parts of the framework
 in order to be run.

 When subclassing TestCase, you can set these attributes:
 * failureException: determines which exception will be raised when
 the instance's assertion methods fail; test methods raising this
 exception will be deemed to have 'failed' rather than 'errored'.
 * longMessage: determines whether long messages (including repr of
 objects used in assert methods) will be printed on failure in *addition*
 to any explicit message passed.
 * maxDiff: sets the maximum length of a diff in failure messages
 by assert methods using difflib. It is looked up as an instance
 attribute so can be configured by individual tests if required.
 """

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
 method when executed. Raises a ValueError if the instance does
 not have a method with the specified name.
 """
self._testMethodName=methodName
self._outcome=None
self._testMethodDoc='No test'
try:
testMethod=getattr(self, methodName)
exceptAttributeError:
ifmethodName!='runTest':
# we allow instantiation with no explicit method name
# but not an *incorrect* or missing method name
raiseValueError("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')

defaddTypeEqualityFunc(self, typeobj, function):
"""Add a type specific assertEqual style function to compare a type.

 This method is for use by TestCase subclasses that need to register
 their own type equality functions to provide nicer error messages.

 Args:
 typeobj: The data type to call this function on when both values
 are of the same type in assertEqual().
 function: The callable taking two arguments and an optional
 msg= argument that raises self.failureException with a
 useful error message when the two arguments are not equal.
 """
self._type_equality_funcs[typeobj] =function

defaddCleanup(self, function, /, *args, **kwargs):
"""Add a function, with arguments, to be called when the test is
 completed. Functions added are called on a LIFO basis and are
 called after tearDown on test failure or success.

 Cleanup items are called even if setUp fails (unlike tearDown)."""
self._cleanups.append((function, args, kwargs))

defenterContext(self, cm):
"""Enters the supplied context manager.

 If successful, also adds its __exit__ method as a cleanup
 function and returns the result of the __enter__ method.
 """
return_enter_context(cm, self.addCleanup)

@classmethod
defaddClassCleanup(cls, function, /, *args, **kwargs):
"""Same as addCleanup, except the cleanup items are called even if
 setUpClass fails (unlike tearDownClass)."""
cls._class_cleanups.append((function, args, kwargs))

@classmethod
defenterClassContext(cls, cm):
"""Same as enterContext, but class-wide."""
return_enter_context(cm, cls.addClassCleanup)

defsetUp(self):
"Hook method for setting up the test fixture before exercising it."
pass

deftearDown(self):
"Hook method for deconstructing the test fixture after testing it."
pass

@classmethod
defsetUpClass(cls):
"Hook method for setting up class fixture before running tests in the class."

@classmethod
deftearDownClass(cls):
"Hook method for deconstructing the class fixture after running all tests in the class."

defcountTestCases(self):
return1

defdefaultTestResult(self):
returnresult.TestResult()

defshortDescription(self):
"""Returns a one-line description of the test, or None if no
 description has been provided.

 The default implementation of this method returns the first line of
 the specified test method's docstring.
 """
doc=self._testMethodDoc
returndoc.strip().split("\n")[0].strip() ifdocelseNone


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

def__eq__(self, other):
iftype(self) isnottype(other):
returnNotImplemented

returnself._testMethodName==other._testMethodName

def__hash__(self):
returnhash((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
defsubTest(self, msg=_subtest_msg_sentinel, **params):
"""Return a context manager that will return the enclosed block
 of code in a subtest identified by the optional message and
 keyword parameters. A failure in the subtest marks the test
 case as failed but resumes execution at the end of the enclosed
 block, allowing further test code to be executed.
 """
ifself._outcomeisNoneornotself._outcome.result_supports_subtests:
yield
return
parent=self._subtest
ifparentisNone:
params_map=_OrderedChainMap(params)
else:
params_map=parent.params.new_child(params)
self._subtest=_SubTest(self, msg, params_map)
try:
withself._outcome.testPartExecutor(self._subtest, subTest=True):
yield
ifnotself._outcome.success:
result=self._outcome.result
ifresultisnotNoneandresult.failfast:
raise_ShouldStop
elifself._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
exceptAttributeError:
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
exceptAttributeError:
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_UnexpectedSuccessfromNone
except_UnexpectedSuccess:
result.addFailure(self, sys.exc_info())
else:
addUnexpectedSuccess(self)

def_addDuration(self, result, elapsed):
try:
addDuration=result.addDuration
exceptAttributeError:
warnings.warn("TestResult has no addDuration method",
RuntimeWarning)
else:
addDuration(self, elapsed)

def_callSetUp(self):
self.setUp()

def_callTestMethod(self, method):
ifmethod() isnotNone:
warnings.warn(f'It is deprecated to return a value that is not None from a '
f'test case ({method})', DeprecationWarning, stacklevel=3)

def_callTearDown(self):
self.tearDown()

def_callCleanup(self, function, /, *args, **kwargs):
function(*args, **kwargs)

defrun(self, result=None):
ifresultisNone:
result=self.defaultTestResult()
startTestRun=getattr(result, 'startTestRun', None)
stopTestRun=getattr(result, 'stopTestRun', None)
ifstartTestRunisnotNone:
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__', '')
orgetattr(testMethod, '__unittest_skip_why__', ''))
_addSkip(result, self, skip_why)
returnresult

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

withoutcome.testPartExecutor(self):
self._callSetUp()
ifoutcome.success:
outcome.expecting_failure=expecting_failure
withoutcome.testPartExecutor(self):
self._callTestMethod(testMethod)
outcome.expecting_failure=False
withoutcome.testPartExecutor(self):
self._callTearDown()
self.doCleanups()
self._addDuration(result, (time.perf_counter() -start_time))

ifoutcome.success:
ifexpecting_failure:
ifoutcome.expectedFailure:
self._addExpectedFailure(result, outcome.expectedFailure)
else:
self._addUnexpectedSuccess(result)
else:
result.addSuccess(self)
returnresult
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)
ifstopTestRunisnotNone:
stopTestRun()

defdoCleanups(self):
"""Execute all cleanup functions. Normally called for you after
 tearDown."""
outcome=self._outcomeor_Outcome()
whileself._cleanups:
function, args, kwargs=self._cleanups.pop()
withoutcome.testPartExecutor(self):
self._callCleanup(function, *args, **kwargs)

# return this for backwards compatibility
# even though we no longer use it internally
returnoutcome.success

@classmethod
defdoClassCleanups(cls):
"""Execute all class cleanup functions. Normally called for you after
 tearDownClass."""
cls.tearDown_exceptions= []
whilecls._class_cleanups:
function, args, kwargs=cls._class_cleanups.pop()
try:
function(*args, **kwargs)
exceptException:
cls.tearDown_exceptions.append(sys.exc_info())

def__call__(self, *args, **kwds):
returnself.run(*args, **kwds)

defdebug(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__', '')
orgetattr(testMethod, '__unittest_skip_why__', ''))
raiseSkipTest(skip_why)

self._callSetUp()
self._callTestMethod(testMethod)
self._callTearDown()
whileself._cleanups:
function, args, kwargs=self._cleanups.pop()
self._callCleanup(function, *args, **kwargs)

defskipTest(self, reason):
"""Skip this test."""
raiseSkipTest(reason)

deffail(self, msg=None):
"""Fail immediately, with the given message."""
raiseself.failureException(msg)

defassertFalse(self, expr, msg=None):
"""Check that the expression is false."""
ifexpr:
msg=self._formatMessage(msg, "%s is not false"%safe_repr(expr))
raiseself.failureException(msg)

defassertTrue(self, expr, msg=None):
"""Check that the expression is true."""
ifnotexpr:
msg=self._formatMessage(msg, "%s is not true"%safe_repr(expr))
raiseself.failureException(msg)

def_formatMessage(self, msg, standardMsg):
"""Honour the longMessage attribute when generating failure messages.
 If longMessage is False this means:
 * Use only an explicit message if it is provided
 * Otherwise use the standard message for the assert

 If longMessage is True:
 * Use the standard message
 * If an explicit message is provided, plus ' : ' and the explicit message
 """
ifnotself.longMessage:
returnmsgorstandardMsg
ifmsgisNone:
returnstandardMsg
try:
# don't switch to '{}' formatting in Python 2.X
# it changes the way unicode input is handled
return'%s : %s'% (standardMsg, msg)
exceptUnicodeDecodeError:
return'%s : %s'% (safe_repr(standardMsg), safe_repr(msg))

defassertRaises(self, expected_exception, *args, **kwargs):
"""Fail unless an exception of class expected_exception is raised
 by the callable when invoked with specified positional and
 keyword arguments. If a different type of exception is
 raised, it will not be caught, and the test case will be
 deemed to have suffered an error, exactly as for an
 unexpected exception.

 If called with the callable and arguments omitted, will return a
 context object used like this::

 with self.assertRaises(SomeException):
 do_something()

 An optional keyword argument 'msg' can be provided when assertRaises
 is used as a context object.

 The context manager keeps a reference to the exception as
 the 'exception' attribute. This allows you to inspect the
 exception after the assertion::

 with self.assertRaises(SomeException) as cm:
 do_something()
 the_exception = cm.exception
 self.assertEqual(the_exception.error_code, 3)
 """
context=_AssertRaisesContext(expected_exception, self)
try:
returncontext.handle('assertRaises', args, kwargs)
finally:
# bpo-23890: manually break a reference cycle
context=None

defassertWarns(self, expected_warning, *args, **kwargs):
"""Fail unless a warning of class warnClass is triggered
 by the callable when invoked with specified positional and
 keyword arguments. If a different type of warning is
 triggered, it will not be handled: depending on the other
 warning filtering rules in effect, it might be silenced, printed
 out, or raised as an exception.

 If called with the callable and arguments omitted, will return a
 context object used like this::

 with self.assertWarns(SomeWarning):
 do_something()

 An optional keyword argument 'msg' can be provided when assertWarns
 is used as a context object.

 The context manager keeps a reference to the first matching
 warning as the 'warning' attribute; similarly, the 'filename'
 and 'lineno' attributes give you information about the line
 of Python code from which the warning was triggered.
 This allows you to inspect the warning after the assertion::

 with self.assertWarns(SomeWarning) as cm:
 do_something()
 the_warning = cm.warning
 self.assertEqual(the_warning.some_attribute, 147)
 """
context=_AssertWarnsContext(expected_warning, self)
returncontext.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)
returncontext.handle('_assertNotWarns', args, kwargs)

defassertLogs(self, logger=None, level=None):
"""Fail unless a log message of level *level* or higher is emitted
 on *logger_name* or its children. If omitted, *level* defaults to
 INFO and *logger* defaults to the root logger.

 This method must be used as a context manager, and will yield
 a recording object with two attributes: `output` and `records`.
 At the end of the context manager, the `output` attribute will
 be a list of the matching formatted log messages and the
 `records` attribute will be a list of the corresponding LogRecord
 objects.

 Example::

 with self.assertLogs('foo', level='INFO') as cm:
 logging.getLogger('foo').info('first message')
 logging.getLogger('foo.bar').error('second message')
 self.assertEqual(cm.output, ['INFO:foo:first message',
 'ERROR:foo.bar:second message'])
 """
# Lazy import to avoid importing logging if it is not needed.
from ._logimport_AssertLogsContext
return_AssertLogsContext(self, logger, level, no_logs=False)

defassertNoLogs(self, logger=None, level=None):
""" Fail unless no log messages of level *level* or higher are emitted
 on *logger_name* or its children.

 This method must be used as a context manager.
 """
from ._logimport_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.

 Returns: A callable accepting (first, second, msg=None) that will
 raise a failure exception if first != second with a useful human
 readable error message for those types.
 """
#
# 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.
#
iftype(first) istype(second):
asserter=self._type_equality_funcs.get(type(first))
ifasserterisnotNone:
ifisinstance(asserter, str):
asserter=getattr(self, asserter)
returnasserter

returnself._baseAssertEqual

def_baseAssertEqual(self, first, second, msg=None):
"""The default assertEqual implementation, not type specific."""
ifnotfirst==second:
standardMsg='%s != %s'%_common_shorten_repr(first, second)
msg=self._formatMessage(msg, standardMsg)
raiseself.failureException(msg)

defassertEqual(self, first, second, msg=None):
"""Fail if the two objects are unequal as determined by the '=='
 operator.
 """
assertion_func=self._getAssertEqualityFunc(first, second)
assertion_func(first, second, msg=msg)

defassertNotEqual(self, first, second, msg=None):
"""Fail if the two objects are equal as determined by the '!='
 operator.
 """
ifnotfirst!=second:
msg=self._formatMessage(msg, '%s == %s'% (safe_repr(first),
safe_repr(second)))
raiseself.failureException(msg)

defassertAlmostEqual(self, first, second, places=None, msg=None,
delta=None):
"""Fail if the two objects are unequal as determined by their
 difference rounded to the given number of decimal places
 (default 7) and comparing to zero, or by comparing that the
 difference between the two objects is more than the given
 delta.

 Note that decimal places (from zero) are usually not the same
 as significant digits (measured from the most significant digit).

 If the two objects compare equal then they will automatically
 compare almost equal.
 """
iffirst==second:
# shortcut
return
ifdeltaisnotNoneandplacesisnotNone:
raiseTypeError("specify delta or places not both")

diff=abs(first-second)
ifdeltaisnotNone:
ifdiff<=delta:
return

standardMsg='%s != %s within %s delta (%s difference)'% (
safe_repr(first),
safe_repr(second),
safe_repr(delta),
safe_repr(diff))
else:
ifplacesisNone:
places=7

ifround(diff, places) ==0:
return

standardMsg='%s != %s within %r places (%s difference)'% (
safe_repr(first),
safe_repr(second),
places,
safe_repr(diff))
msg=self._formatMessage(msg, standardMsg)
raiseself.failureException(msg)

defassertNotAlmostEqual(self, first, second, places=None, msg=None,
delta=None):
"""Fail if the two objects are equal as determined by their
 difference rounded to the given number of decimal places
 (default 7) and comparing to zero, or by comparing that the
 difference between the two objects is less than the given delta.

 Note that decimal places (from zero) are usually not the same
 as significant digits (measured from the most significant digit).

 Objects that are equal automatically fail.
 """
ifdeltaisnotNoneandplacesisnotNone:
raiseTypeError("specify delta or places not both")
diff=abs(first-second)
ifdeltaisnotNone:
ifnot (first==second) anddiff>delta:
return
standardMsg='%s == %s within %s delta (%s difference)'% (
safe_repr(first),
safe_repr(second),
safe_repr(delta),
safe_repr(diff))
else:
ifplacesisNone:
places=7
ifnot (first==second) andround(diff, places) !=0:
return
standardMsg='%s == %s within %r places'% (safe_repr(first),
safe_repr(second),
places)

msg=self._formatMessage(msg, standardMsg)
raiseself.failureException(msg)

defassertSequenceEqual(self, seq1, seq2, msg=None, seq_type=None):
"""An equality assertion for ordered sequences (like lists and tuples).