Lines Matching refs:self
23 'Set self.maxDiff to None to see it.')
45 def __init__(self, result=None):
46 self.expecting_failure = False
47 self.result = result
48 self.result_supports_subtests = hasattr(result, "addSubTest")
49 self.success = True
50 self.expectedFailure = None
53 def testPartExecutor(self, test_case, subTest=False):
54 old_success = self.success
55 self.success = True
61 self.success = False
62 _addSkip(self.result, test_case, str(e))
67 if self.expecting_failure:
68 self.expectedFailure = exc_info
70 self.success = False
72 self.result.addSubTest(test_case.test_case, test_case, exc_info)
74 _addError(self.result, test_case, exc_info)
79 if subTest and self.success:
80 self.result.addSubTest(test_case.test_case, test_case, None)
82 self.success = self.success and old_success
194 def __init__(self, test_case):
195 self.test_case = test_case
197 def _raiseFailure(self, standardMsg):
198 msg = self.test_case._formatMessage(self.msg, standardMsg)
199 raise self.test_case.failureException(msg)
203 def __init__(self, expected, test_case, expected_regex=None):
204 _BaseTestCaseContext.__init__(self, test_case)
205 self.expected = expected
206 self.test_case = test_case
209 self.expected_regex = expected_regex
210 self.obj_name = None
211 self.msg = None
213 def handle(self, name, args, kwargs):
216 context manager, so check for a 'msg' kwarg and return self.
221 if not _is_subtype(self.expected, self._base_type):
223 (name, self._base_type_str))
225 self.msg = kwargs.pop('msg', None)
229 return self
233 self.obj_name = callable_obj.__name__
235 self.obj_name = str(callable_obj)
236 with self:
240 self = None
249 def __enter__(self):
250 return self
252 def __exit__(self, exc_type, exc_value, tb):
255 exc_name = self.expected.__name__
257 exc_name = str(self.expected)
258 if self.obj_name:
259 self._raiseFailure("{} not raised by {}".format(exc_name,
260 self.obj_name))
262 self._raiseFailure("{} not raised".format(exc_name))
265 if not issubclass(exc_type, self.expected):
269 self.exception = exc_value.with_traceback(None)
270 if self.expected_regex is None:
273 expected_regex = self.expected_regex
275 self._raiseFailure('"{}" does not match "{}"'.format(
288 def __enter__(self):
294 self.warnings_manager = warnings.catch_warnings(record=True)
295 self.warnings = self.warnings_manager.__enter__()
296 warnings.simplefilter("always", self.expected)
297 return self
299 def __exit__(self, exc_type, exc_value, tb):
300 self.warnings_manager.__exit__(exc_type, exc_value, tb)
305 exc_name = self.expected.__name__
307 exc_name = str(self.expected)
309 for m in self.warnings:
311 if not isinstance(w, self.expected):
315 if (self.expected_regex is not None and
316 not self.expected_regex.search(str(w))):
319 self.warning = w
320 self.filename = m.filename
321 self.lineno = m.lineno
325 self._raiseFailure('"{}" does not match "{}"'.format(
326 self.expected_regex.pattern, str(first_matching)))
327 if self.obj_name:
328 self._raiseFailure("{} not triggered by {}".format(exc_name,
329 self.obj_name))
331 self._raiseFailure("{} not triggered".format(exc_name))
335 def __iter__(self):
337 for mapping in self.maps:
393 def __init__(self, methodName='runTest'):
398 self._testMethodName = methodName
399 self._outcome = None
400 self._testMethodDoc = 'No test'
402 testMethod = getattr(self, methodName)
408 (self.__class__, methodName))
410 self._testMethodDoc = testMethod.__doc__
411 self._cleanups = []
412 self._subtest = None
417 self._type_equality_funcs = {}
418 self.addTypeEqualityFunc(dict, 'assertDictEqual')
419 self.addTypeEqualityFunc(list, 'assertListEqual')
420 self.addTypeEqualityFunc(tuple, 'assertTupleEqual')
421 self.addTypeEqualityFunc(set, 'assertSetEqual')
422 self.addTypeEqualityFunc(frozenset, 'assertSetEqual')
423 self.addTypeEqualityFunc(str, 'assertMultiLineEqual')
425 def addTypeEqualityFunc(self, typeobj, function):
435 msg= argument that raises self.failureException with a
438 self._type_equality_funcs[typeobj] = function
440 def addCleanup(self, function, /, *args, **kwargs):
446 self._cleanups.append((function, args, kwargs))
448 def enterContext(self, cm):
454 return _enter_context(cm, self.addCleanup)
467 def setUp(self):
471 def tearDown(self):
483 def countTestCases(self):
486 def defaultTestResult(self):
489 def shortDescription(self):
496 doc = self._testMethodDoc
500 def id(self):
501 return "%s.%s" % (strclass(self.__class__), self._testMethodName)
503 def __eq__(self, other):
504 if type(self) is not type(other):
507 return self._testMethodName == other._testMethodName
509 def __hash__(self):
510 return hash((type(self), self._testMethodName))
512 def __str__(self):
513 return "%s (%s.%s)" % (self._testMethodName, strclass(self.__class__), self._testMethodName)
515 def __repr__(self):
517 (strclass(self.__class__), self._testMethodName)
520 def subTest(self, msg=_subtest_msg_sentinel, **params):
527 if self._outcome is None or not self._outcome.result_supports_subtests:
530 parent = self._subtest
535 self._subtest = _SubTest(self, msg, params_map)
537 with self._outcome.testPartExecutor(self._subtest, subTest=True):
539 if not self._outcome.success:
540 result = self._outcome.result
543 elif self._outcome.expectedFailure:
548 self._subtest = parent
550 def _addExpectedFailure(self, result, exc_info):
556 result.addSuccess(self)
558 addExpectedFailure(self, exc_info)
560 def _addUnexpectedSuccess(self, result):
571 result.addFailure(self, sys.exc_info())
573 addUnexpectedSuccess(self)
575 def _callSetUp(self):
576 self.setUp()
578 def _callTestMethod(self, method):
583 def _callTearDown(self):
584 self.tearDown()
586 def _callCleanup(self, function, /, *args, **kwargs):
589 def run(self, result=None):
591 result = self.defaultTestResult()
599 result.startTest(self)
601 testMethod = getattr(self, self._testMethodName)
602 if (getattr(self.__class__, "__unittest_skip__", False) or
605 skip_why = (getattr(self.__class__, '__unittest_skip_why__', '')
607 _addSkip(result, self, skip_why)
611 getattr(self, "__unittest_expecting_failure__", False) or
616 self._outcome = outcome
618 with outcome.testPartExecutor(self):
619 self._callSetUp()
622 with outcome.testPartExecutor(self):
623 self._callTestMethod(testMethod)
625 with outcome.testPartExecutor(self):
626 self._callTearDown()
627 self.doCleanups()
632 self._addExpectedFailure(result, outcome.expectedFailure)
634 self._addUnexpectedSuccess(result)
636 result.addSuccess(self)
645 self._outcome = None
648 result.stopTest(self)
652 def doCleanups(self):
655 outcome = self._outcome or _Outcome()
656 while self._cleanups:
657 function, args, kwargs = self._cleanups.pop()
658 with outcome.testPartExecutor(self):
659 self._callCleanup(function, *args, **kwargs)
677 def __call__(self, *args, **kwds):
678 return self.run(*args, **kwds)
680 def debug(self):
682 testMethod = getattr(self, self._testMethodName)
683 if (getattr(self.__class__, "__unittest_skip__", False) or
686 skip_why = (getattr(self.__class__, '__unittest_skip_why__', '')
690 self._callSetUp()
691 self._callTestMethod(testMethod)
692 self._callTearDown()
693 while self._cleanups:
694 function, args, kwargs = self._cleanups.pop()
695 self._callCleanup(function, *args, **kwargs)
697 def skipTest(self, reason):
701 def fail(self, msg=None):
703 raise self.failureException(msg)
705 def assertFalse(self, expr, msg=None):
708 msg = self._formatMessage(msg, "%s is not false" % safe_repr(expr))
709 raise self.failureException(msg)
711 def assertTrue(self, expr, msg=None):
714 msg = self._formatMessage(msg, "%s is not true" % safe_repr(expr))
715 raise self.failureException(msg)
717 def _formatMessage(self, msg, standardMsg):
727 if not self.longMessage:
738 def assertRaises(self, expected_exception, *args, **kwargs):
749 with self.assertRaises(SomeException):
759 with self.assertRaises(SomeException) as cm:
762 self.assertEqual(the_exception.error_code, 3)
764 context = _AssertRaisesContext(expected_exception, self)
771 def assertWarns(self, expected_warning, *args, **kwargs):
782 with self.assertWarns(SomeWarning):
794 with self.assertWarns(SomeWarning) as cm:
797 self.assertEqual(the_warning.some_attribute, 147)
799 context = _AssertWarnsContext(expected_warning, self)
802 def assertLogs(self, logger=None, level=None):
816 with self.assertLogs('foo', level='INFO') as cm:
819 self.assertEqual(cm.output, ['INFO:foo:first message',
824 return _AssertLogsContext(self, logger, level, no_logs=False)
826 def assertNoLogs(self, logger=None, level=None):
833 return _AssertLogsContext(self, logger, level, no_logs=True)
835 def _getAssertEqualityFunc(self, first, second):
853 asserter = self._type_equality_funcs.get(type(first))
856 asserter = getattr(self, asserter)
859 return self._baseAssertEqual
861 def _baseAssertEqual(self, first, second, msg=None):
865 msg = self._formatMessage(msg, standardMsg)
866 raise self.failureException(msg)
868 def assertEqual(self, first, second, msg=None):
872 assertion_func = self._getAssertEqualityFunc(first, second)
875 def assertNotEqual(self, first, second, msg=None):
880 msg = self._formatMessage(msg, '%s == %s' % (safe_repr(first),
882 raise self.failureException(msg)
884 def assertAlmostEqual(self, first, second, places=None, msg=None,
926 msg = self._formatMessage(msg, standardMsg)
927 raise self.failureException(msg)
929 def assertNotAlmostEqual(self, first, second, places=None, msg=None,
961 msg = self._formatMessage(msg, standardMsg)
962 raise self.failureException(msg)
964 def assertSequenceEqual(self, seq1, seq2, msg=None, seq_type=None):
981 raise self.failureException('First sequence is not a %s: %s'
984 raise self.failureException('Second sequence is not a %s: %s'
1059 standardMsg = self._truncateMessage(standardMsg, diffMsg)
1060 msg = self._formatMessage(msg, standardMsg)
1061 self.fail(msg)
1063 def _truncateMessage(self, message, diff):
1064 max_diff = self.maxDiff
1069 def assertListEqual(self, list1, list2, msg=None):
1079 self.assertSequenceEqual(list1, list2, msg, seq_type=list)
1081 def assertTupleEqual(self, tuple1, tuple2, msg=None):
1090 self.assertSequenceEqual(tuple1, tuple2, msg, seq_type=tuple)
1092 def assertSetEqual(self, set1, set2, msg=None):
1108 self.fail('invalid type when attempting set difference: %s' % e)
1110 self.fail('first argument does not support set difference: %s' % e)
1115 self.fail('invalid type when attempting set difference: %s' % e)
1117 self.fail('second argument does not support set difference: %s' % e)
1133 self.fail(self._formatMessage(msg, standardMsg))
1135 def assertIn(self, member, container, msg=None):
1136 """Just like self.assertTrue(a in b), but with a nicer default message."""
1140 self.fail(self._formatMessage(msg, standardMsg))
1142 def assertNotIn(self, member, container, msg=None):
1143 """Just like self.assertTrue(a not in b), but with a nicer default message."""
1147 self.fail(self._formatMessage(msg, standardMsg))
1149 def assertIs(self, expr1, expr2, msg=None):
1150 """Just like self.assertTrue(a is b), but with a nicer default message."""
1154 self.fail(self._formatMessage(msg, standardMsg))
1156 def assertIsNot(self, expr1, expr2, msg=None):
1157 """Just like self.assertTrue(a is not b), but with a nicer default message."""
1160 self.fail(self._formatMessage(msg, standardMsg))
1162 def assertDictEqual(self, d1, d2, msg=None):
1163 self.assertIsInstance(d1, dict, 'First argument is not a dictionary')
1164 self.assertIsInstance(d2, dict, 'Second argument is not a dictionary')
1171 standardMsg = self._truncateMessage(standardMsg, diff)
1172 self.fail(self._formatMessage(msg, standardMsg))
1174 def assertDictContainsSubset(self, subset, dictionary, msg=None):
1200 self.fail(self._formatMessage(msg, standardMsg))
1203 def assertCountEqual(self, first, second, msg=None):
1207 self.assertEqual(Counter(list(first)),
1231 standardMsg = self._truncateMessage(standardMsg, diffMsg)
1232 msg = self._formatMessage(msg, standardMsg)
1233 self.fail(msg)
1235 def assertMultiLineEqual(self, first, second, msg=None):
1237 self.assertIsInstance(first, str, 'First argument is not a string')
1238 self.assertIsInstance(second, str, 'Second argument is not a string')
1242 if (len(first) > self._diffThreshold or
1243 len(second) > self._diffThreshold):
1244 self._baseAssertEqual(first, second, msg)
1252 standardMsg = self._truncateMessage(standardMsg, diff)
1253 self.fail(self._formatMessage(msg, standardMsg))
1255 def assertLess(self, a, b, msg=None):
1256 """Just like self.assertTrue(a < b), but with a nicer default message."""
1259 self.fail(self._formatMessage(msg, standardMsg))
1261 def assertLessEqual(self, a, b, msg=None):
1262 """Just like self.assertTrue(a <= b), but with a nicer default message."""
1265 self.fail(self._formatMessage(msg, standardMsg))
1267 def assertGreater(self, a, b, msg=None):
1268 """Just like self.assertTrue(a > b), but with a nicer default message."""
1271 self.fail(self._formatMessage(msg, standardMsg))
1273 def assertGreaterEqual(self, a, b, msg=None):
1274 """Just like self.assertTrue(a >= b), but with a nicer default message."""
1277 self.fail(self._formatMessage(msg, standardMsg))
1279 def assertIsNone(self, obj, msg=None):
1280 """Same as self.assertTrue(obj is None), with a nicer default message."""
1283 self.fail(self._formatMessage(msg, standardMsg))
1285 def assertIsNotNone(self, obj, msg=None):
1289 self.fail(self._formatMessage(msg, standardMsg))
1291 def assertIsInstance(self, obj, cls, msg=None):
1292 """Same as self.assertTrue(isinstance(obj, cls)), with a nicer
1296 self.fail(self._formatMessage(msg, standardMsg))
1298 def assertNotIsInstance(self, obj, cls, msg=None):
1302 self.fail(self._formatMessage(msg, standardMsg))
1304 def assertRaisesRegex(self, expected_exception, expected_regex,
1317 context = _AssertRaisesContext(expected_exception, self, expected_regex)
1320 def assertWarnsRegex(self, expected_warning, expected_regex,
1336 context = _AssertWarnsContext(expected_warning, self, expected_regex)
1339 def assertRegex(self, text, expected_regex, msg=None):
1348 msg = self._formatMessage(msg, standardMsg)
1349 raise self.failureException(msg)
1351 def assertNotRegex(self, text, unexpected_regex, msg=None):
1362 msg = self._formatMessage(msg, standardMsg)
1363 raise self.failureException(msg)
1397 def __init__(self, testFunc, setUp=None, tearDown=None, description=None):
1398 super(FunctionTestCase, self).__init__()
1399 self._setUpFunc = setUp
1400 self._tearDownFunc = tearDown
1401 self._testFunc = testFunc
1402 self._description = description
1404 def setUp(self):
1405 if self._setUpFunc is not None:
1406 self._setUpFunc()
1408 def tearDown(self):
1409 if self._tearDownFunc is not None:
1410 self._tearDownFunc()
1412 def runTest(self):
1413 self._testFunc()
1415 def id(self):
1416 return self._testFunc.__name__
1418 def __eq__(self, other):
1419 if not isinstance(other, self.__class__):
1422 return self._setUpFunc == other._setUpFunc and \
1423 self._tearDownFunc == other._tearDownFunc and \
1424 self._testFunc == other._testFunc and \
1425 self._description == other._description
1427 def __hash__(self):
1428 return hash((type(self), self._setUpFunc, self._tearDownFunc,
1429 self._testFunc, self._description))
1431 def __str__(self):
1432 return "%s (%s)" % (strclass(self.__class__),
1433 self._testFunc.__name__)
1435 def __repr__(self):
1436 return "<%s tec=%s>" % (strclass(self.__class__),
1437 self._testFunc)
1439 def shortDescription(self):
1440 if self._description is not None:
1441 return self._description
1442 doc = self._testFunc.__doc__
1448 def __init__(self, test_case, message, params):
1450 self._message = message
1451 self.test_case = test_case
1452 self.params = params
1453 self.failureException = test_case.failureException
1455 def runTest(self):
1458 def _subDescription(self):
1460 if self._message is not _subtest_msg_sentinel:
1461 parts.append("[{}]".format(self._message))
1462 if self.params:
1465 for (k, v) in self.params.items())
1469 def id(self):
1470 return "{} {}".format(self.test_case.id(), self._subDescription())
1472 def shortDescription(self):
1476 return self.test_case.shortDescription()
1478 def __str__(self):
1479 return "{} {}".format(self.test_case, self._subDescription())