Lines Matching refs:self
34 def runTest(self): pass
35 def test1(self): pass
38 def test2(self): pass
43 def __init__(self, events):
44 super(Test.LoggingTestCase, self).__init__('test')
45 self.events = events
47 def setUp(self):
48 self.events.append('setUp')
50 def test(self):
51 self.events.append('test')
53 def tearDown(self):
54 self.events.append('tearDown')
83 def test_init__no_test_name(self):
85 def runTest(self): raise MyException()
86 def test(self): pass
88 self.assertEqual(Test().id()[-13:], '.Test.runTest')
97 with self.assertRaises(AttributeError):
104 def test_init__test_name__valid(self):
106 def runTest(self): raise MyException()
107 def test(self): pass
109 self.assertEqual(Test('test').id()[-10:], '.Test.test')
115 def test_init__test_name__invalid(self):
117 def runTest(self): raise MyException()
118 def test(self): pass
125 self.fail("Failed to raise ValueError")
129 def test_countTestCases(self):
131 def test(self): pass
133 self.assertEqual(Foo('test').countTestCases(), 1)
139 def test_defaultTestResult(self):
141 def runTest(self):
145 self.assertEqual(type(result), unittest.TestResult)
154 def test_run_call_order__error_in_setUp(self):
159 def setUp(self):
160 super(Foo, self).setUp()
165 self.assertEqual(events, expected)
168 def test_run_call_order__error_in_setUp_default_result(self):
172 def defaultTestResult(self):
173 return LoggingResult(self.events)
175 def setUp(self):
176 super(Foo, self).setUp()
182 self.assertEqual(events, expected)
191 def test_run_call_order__error_in_test(self):
196 def test(self):
197 super(Foo, self).test()
203 self.assertEqual(events, expected)
207 def test_run_call_order__error_in_test_default_result(self):
211 def defaultTestResult(self):
212 return LoggingResult(self.events)
214 def test(self):
215 super(Foo, self).test()
221 self.assertEqual(events, expected)
230 def test_run_call_order__failure_in_test(self):
235 def test(self):
236 super(Foo, self).test()
237 self.fail('raised by Foo.test')
242 self.assertEqual(events, expected)
245 def test_run_call_order__failure_in_test_default_result(self):
248 def defaultTestResult(self):
249 return LoggingResult(self.events)
250 def test(self):
251 super(Foo, self).test()
252 self.fail('raised by Foo.test')
258 self.assertEqual(events, expected)
267 def test_run_call_order__error_in_tearDown(self):
272 def tearDown(self):
273 super(Foo, self).tearDown()
279 self.assertEqual(events, expected)
282 def test_run_call_order__error_in_tearDown_default_result(self):
285 def defaultTestResult(self):
286 return LoggingResult(self.events)
287 def tearDown(self):
288 super(Foo, self).tearDown()
295 self.assertEqual(events, expected)
299 def test_run_call_order_default_result(self):
302 def defaultTestResult(self):
304 def test(self):
309 def test_deprecation_of_return_val_from_test(self):
312 def __eq__(self, o):
315 def test1(self):
317 def test2(self):
319 def test3(self):
322 with self.assertWarns(DeprecationWarning) as w:
324 self.assertIn('It is deprecated to return a value that is not None', str(w.warning))
325 self.assertIn('test1', str(w.warning))
326 self.assertEqual(w.filename, __file__)
328 with self.assertWarns(DeprecationWarning) as w:
330 self.assertIn('It is deprecated to return a value that is not None', str(w.warning))
331 self.assertIn('test2', str(w.warning))
332 self.assertEqual(w.filename, __file__)
334 with self.assertWarns(DeprecationWarning) as w:
336 self.assertIn('It is deprecated to return a value that is not None', str(w.warning))
337 self.assertIn('test3', str(w.warning))
338 self.assertEqual(w.filename, __file__)
340 def _check_call_order__subtests(self, result, events, expected_events):
342 def test(self):
343 super(Foo, self).test()
345 with self.subTest(i=i):
347 self.fail('failure')
349 with self.subTest(j=j):
362 self.assertEqual(events, expected_events)
364 def test_run_call_order__subtests(self):
371 self._check_call_order__subtests(result, events, expected)
373 def test_run_call_order__subtests_legacy(self):
380 self._check_call_order__subtests(result, events, expected)
382 def _check_call_order__subtests_success(self, result, events, expected_events):
384 def test(self):
385 super(Foo, self).test()
387 with self.subTest(i=i):
389 with self.subTest(j=j):
393 self.assertEqual(events, expected_events)
395 def test_run_call_order__subtests_success(self):
403 self._check_call_order__subtests_success(result, events, expected)
405 def test_run_call_order__subtests_success_legacy(self):
411 self._check_call_order__subtests_success(result, events, expected)
413 def test_run_call_order__subtests_failfast(self):
419 def test(self):
420 super(Foo, self).test()
421 with self.subTest(i=1):
422 self.fail('failure')
423 with self.subTest(i=2):
424 self.fail('failure')
425 self.fail('failure')
430 self.assertEqual(events, expected)
432 def test_subtests_failfast(self):
437 def test_a(self):
438 with self.subTest():
442 def test_b(self):
443 with self.subTest():
445 with self.subTest():
446 self.fail('failure')
449 def test_c(self):
458 self.assertEqual(events, expected)
460 def test_subtests_debug(self):
465 def test_a(self):
467 with self.subTest():
472 self.assertEqual(events, ['test case', 'subtest 1'])
479 def test_failureException__default(self):
481 def test(self):
484 self.assertIs(Foo('test').failureException, AssertionError)
492 def test_failureException__subclassing__explicit_raise(self):
497 def test(self):
502 self.assertIs(Foo('test').failureException, RuntimeError)
507 self.assertEqual(events, expected)
515 def test_failureException__subclassing__implicit_raise(self):
520 def test(self):
521 self.fail("foo")
525 self.assertIs(Foo('test').failureException, RuntimeError)
530 self.assertEqual(events, expected)
533 def test_setUp(self):
535 def runTest(self):
542 def test_tearDown(self):
544 def runTest(self):
556 def test_id(self):
558 def runTest(self):
561 self.assertIsInstance(Foo().id(), str)
568 def test_run__uses_defaultTestResult(self):
573 def test(self):
576 def defaultTestResult(self):
582 self.assertIs(result, defaultResult)
585 self.assertEqual(events, expected)
589 def test_run__returns_given_result(self):
592 def test(self):
598 self.assertIs(retval, result)
603 def test_call__invoking_an_instance_delegates_to_run(self):
608 def test(self):
611 def run(self, result):
612 self.assertIs(result, resultIn)
617 self.assertIs(retval, resultOut)
620 def testShortDescriptionWithoutDocstring(self):
621 self.assertIsNone(self.shortDescription())
625 def testShortDescriptionWithOneLineDocstring(self):
627 self.assertEqual(
628 self.shortDescription(),
633 def testShortDescriptionWithMultiLineDocstring(self):
640 self.assertEqual(
641 self.shortDescription(),
647 def testShortDescriptionWhitespaceTrimming(self):
652 self.assertEqual(
653 self.shortDescription(),
656 def testAddTypeEqualityFunc(self):
660 self.assertFalse(s1 == s2)
663 self.addTypeEqualityFunc(SadSnake, AllSnakesCreatedEqual)
664 self.assertEqual(s1, s2)
669 def testAssertIs(self):
671 self.assertIs(thing, thing)
672 self.assertRaises(self.failureException, self.assertIs, thing, object())
674 def testAssertIsNot(self):
676 self.assertIsNot(thing, object())
677 self.assertRaises(self.failureException, self.assertIsNot, thing, thing)
679 def testAssertIsInstance(self):
681 self.assertIsInstance(thing, list)
682 self.assertRaises(self.failureException, self.assertIsInstance,
685 def testAssertNotIsInstance(self):
687 self.assertNotIsInstance(thing, dict)
688 self.assertRaises(self.failureException, self.assertNotIsInstance,
691 def testAssertIn(self):
694 self.assertIn('a', 'abc')
695 self.assertIn(2, [1, 2, 3])
696 self.assertIn('monkey', animals)
698 self.assertNotIn('d', 'abc')
699 self.assertNotIn(0, [1, 2, 3])
700 self.assertNotIn('otter', animals)
702 self.assertRaises(self.failureException, self.assertIn, 'x', 'abc')
703 self.assertRaises(self.failureException, self.assertIn, 4, [1, 2, 3])
704 self.assertRaises(self.failureException, self.assertIn, 'elephant',
707 self.assertRaises(self.failureException, self.assertNotIn, 'c', 'abc')
708 self.assertRaises(self.failureException, self.assertNotIn, 1, [1, 2, 3])
709 self.assertRaises(self.failureException, self.assertNotIn, 'cow',
712 def testAssertDictContainsSubset(self):
716 self.assertDictContainsSubset({}, {})
717 self.assertDictContainsSubset({}, {'a': 1})
718 self.assertDictContainsSubset({'a': 1}, {'a': 1})
719 self.assertDictContainsSubset({'a': 1}, {'a': 1, 'b': 2})
720 self.assertDictContainsSubset({'a': 1, 'b': 2}, {'a': 1, 'b': 2})
722 with self.assertRaises(self.failureException):
723 self.assertDictContainsSubset({1: "one"}, {})
725 with self.assertRaises(self.failureException):
726 self.assertDictContainsSubset({'a': 2}, {'a': 1})
728 with self.assertRaises(self.failureException):
729 self.assertDictContainsSubset({'c': 1}, {'a': 1})
731 with self.assertRaises(self.failureException):
732 self.assertDictContainsSubset({'a': 1, 'c': 1}, {'a': 1})
734 with self.assertRaises(self.failureException):
735 self.assertDictContainsSubset({'a': 1, 'c': 1}, {'a': 1})
739 with self.assertRaises(self.failureException):
740 self.assertDictContainsSubset({'foo': one}, {'foo': '\uFFFD'})
742 def testAssertEqual(self):
753 self.assertEqual(a, b)
754 except self.failureException:
755 self.fail('assertEqual(%r, %r) failed' % (a, b))
757 self.assertEqual(a, b, msg='foo')
758 except self.failureException:
759 self.fail('assertEqual(%r, %r) with msg= failed' % (a, b))
761 self.assertEqual(a, b, 'foo')
762 except self.failureException:
763 self.fail('assertEqual(%r, %r) with third parameter failed' %
773 self.assertRaises(self.failureException, self.assertEqual, a, b)
774 self.assertRaises(self.failureException, self.assertEqual, a, b,
776 self.assertRaises(self.failureException, self.assertEqual, a, b,
779 def testEquality(self):
780 self.assertListEqual([], [])
781 self.assertTupleEqual((), ())
782 self.assertSequenceEqual([], ())
786 self.assertRaises(unittest.TestCase.failureException,
787 self.assertListEqual, a, b)
788 self.assertRaises(unittest.TestCase.failureException,
789 self.assertListEqual, tuple(a), tuple(b))
790 self.assertRaises(unittest.TestCase.failureException,
791 self.assertSequenceEqual, a, tuple(b))
794 self.assertListEqual(a, b)
795 self.assertTupleEqual(tuple(a), tuple(b))
796 self.assertSequenceEqual(a, tuple(b))
797 self.assertSequenceEqual(tuple(a), b)
799 self.assertRaises(self.failureException, self.assertListEqual,
801 self.assertRaises(self.failureException, self.assertTupleEqual,
803 self.assertRaises(self.failureException, self.assertListEqual, None, b)
804 self.assertRaises(self.failureException, self.assertTupleEqual, None,
806 self.assertRaises(self.failureException, self.assertSequenceEqual,
808 self.assertRaises(self.failureException, self.assertListEqual, 1, 1)
809 self.assertRaises(self.failureException, self.assertTupleEqual, 1, 1)
810 self.assertRaises(self.failureException, self.assertSequenceEqual,
813 self.assertDictEqual({}, {})
817 self.assertRaises(unittest.TestCase.failureException,
818 self.assertDictEqual, c, d)
821 self.assertDictEqual(c, d)
824 self.assertRaises(unittest.TestCase.failureException,
825 self.assertDictEqual, c, d, 'These are unequal')
827 self.assertRaises(self.failureException, self.assertDictEqual, None, d)
828 self.assertRaises(self.failureException, self.assertDictEqual, [], d)
829 self.assertRaises(self.failureException, self.assertDictEqual, 1, 1)
831 def testAssertSequenceEqualMaxDiff(self):
832 self.assertEqual(self.maxDiff, 80*8)
840 self.maxDiff = len(diff)//2
843 self.assertSequenceEqual(seq1, seq2)
844 except self.failureException as e:
847 self.fail('assertSequenceEqual did not fail.')
848 self.assertLess(len(msg), len(diff))
849 self.assertIn(omitted, msg)
851 self.maxDiff = len(diff) * 2
853 self.assertSequenceEqual(seq1, seq2)
854 except self.failureException as e:
857 self.fail('assertSequenceEqual did not fail.')
858 self.assertGreater(len(msg), len(diff))
859 self.assertNotIn(omitted, msg)
861 self.maxDiff = None
863 self.assertSequenceEqual(seq1, seq2)
864 except self.failureException as e:
867 self.fail('assertSequenceEqual did not fail.')
868 self.assertGreater(len(msg), len(diff))
869 self.assertNotIn(omitted, msg)
871 def testTruncateMessage(self):
872 self.maxDiff = 1
873 message = self._truncateMessage('foo', 'bar')
875 self.assertEqual(message, 'foo' + omitted)
877 self.maxDiff = None
878 message = self._truncateMessage('foo', 'bar')
879 self.assertEqual(message, 'foobar')
881 self.maxDiff = 4
882 message = self._truncateMessage('foo', 'bar')
883 self.assertEqual(message, 'foobar')
885 def testAssertDictEqualTruncates(self):
892 except self.failureException as e:
893 self.assertEqual(str(e), 'foo')
895 self.fail('assertDictEqual did not fail')
897 def testAssertMultiLineEqualTruncates(self):
904 except self.failureException as e:
905 self.assertEqual(str(e), 'foo')
907 self.fail('assertMultiLineEqual did not fail')
909 def testAssertEqual_diffThreshold(self):
911 self.assertEqual(self._diffThreshold, 2**16)
913 self.maxDiff = None
916 old_threshold = self._diffThreshold
917 self._diffThreshold = 2**5
918 self.addCleanup(lambda: setattr(self, '_diffThreshold', old_threshold))
922 with self.assertRaises(self.failureException) as cm:
923 self.assertEqual(s + 'a', s + 'b')
924 self.assertIn('^', str(cm.exception))
925 self.assertEqual(s + 'a', s + 'a')
934 old_truncate = self._truncateMessage
935 self._truncateMessage = explodingTruncation
936 self.addCleanup(lambda: setattr(self, '_truncateMessage', old_truncate))
939 with self.assertRaises(self.failureException) as cm:
940 self.assertEqual(s1, s2)
941 self.assertNotIn('^', str(cm.exception))
942 self.assertEqual(str(cm.exception), '%r != %r' % (s1, s2))
943 self.assertEqual(s + 'a', s + 'a')
945 def testAssertEqual_shorten(self):
947 old_threshold = self._diffThreshold
948 self._diffThreshold = 0
949 self.addCleanup(lambda: setattr(self, '_diffThreshold', old_threshold))
953 with self.assertRaises(self.failureException) as cm:
954 self.assertEqual(s1, s2)
956 self.assertEqual(str(cm.exception), "'%sa' != '%sb'" % (c, c))
957 self.assertEqual(s + 'a', s + 'a')
961 with self.assertRaises(self.failureException) as cm:
962 self.assertEqual(s1, s2)
964 self.assertEqual(str(cm.exception), "'%sa%s' != '%sb%s'" % (c, p, c, p))
968 with self.assertRaises(self.failureException) as cm:
969 self.assertEqual(s1, s2)
972 self.assertEqual(str(cm.exception), "'%sa%s' != '%sb%s'" % (c, d, c, d))
974 def testAssertCountEqual(self):
976 self.assertCountEqual([1, 2, 3], [3, 2, 1])
977 self.assertCountEqual(['foo', 'bar', 'baz'], ['bar', 'baz', 'foo'])
978 self.assertCountEqual([a, a, 2, 2, 3], (a, 2, 3, a, 2))
979 self.assertCountEqual([1, "2", "a", "a"], ["a", "2", True, "a"])
980 self.assertRaises(self.failureException, self.assertCountEqual,
982 self.assertRaises(self.failureException, self.assertCountEqual,
984 self.assertRaises(self.failureException, self.assertCountEqual,
986 self.assertRaises(self.failureException, self.assertCountEqual,
988 self.assertRaises(self.failureException, self.assertCountEqual,
992 self.assertCountEqual([[1, 2], [3, 4], 0], [False, [3, 4], [1, 2]])
994 self.assertCountEqual(iter([1, 2, [], 3, 4]),
998 self.assertRaises(self.failureException, self.assertCountEqual,
1001 self.assertCountEqual([{'a': 1}, {'b': 2}], [{'b': 2}, {'a': 1}])
1003 self.assertCountEqual([1, 'x', divmod, []], [divmod, [], 'x', 1])
1004 self.assertRaises(self.failureException, self.assertCountEqual,
1006 self.assertRaises(self.failureException, self.assertCountEqual,
1010 self.assertRaises(self.failureException, self.assertCountEqual,
1012 self.assertRaises(self.failureException, self.assertCountEqual,
1014 self.assertRaises(self.failureException, self.assertCountEqual,
1021 self.assertCountEqual(a, b)
1027 self.assertEqual(diffs, expected)
1030 self.assertEqual(diffs, [(1, 0, [])])
1034 self.assertEqual(diffs, expected)
1036 def testAssertSetEqual(self):
1039 self.assertSetEqual(set1, set2)
1041 self.assertRaises(self.failureException, self.assertSetEqual, None, set2)
1042 self.assertRaises(self.failureException, self.assertSetEqual, [], set2)
1043 self.assertRaises(self.failureException, self.assertSetEqual, set1, None)
1044 self.assertRaises(self.failureException, self.assertSetEqual, set1, [])
1048 self.assertRaises(self.failureException, self.assertSetEqual, set1, set2)
1052 self.assertSetEqual(set1, set2)
1056 self.assertRaises(self.failureException, self.assertSetEqual, set1, set2)
1060 self.assertRaises(self.failureException, self.assertSetEqual, set1, set2)
1064 self.assertSetEqual(set1, set2)
1068 self.assertRaises(self.failureException, self.assertSetEqual, set1, set2)
1069 self.assertRaises(self.failureException, self.assertSetEqual, set2, set1)
1074 self.assertRaises(self.failureException, self.assertSetEqual, set1, set2)
1076 def testInequality(self):
1078 self.assertGreater(2, 1)
1079 self.assertGreaterEqual(2, 1)
1080 self.assertGreaterEqual(1, 1)
1081 self.assertLess(1, 2)
1082 self.assertLessEqual(1, 2)
1083 self.assertLessEqual(1, 1)
1084 self.assertRaises(self.failureException, self.assertGreater, 1, 2)
1085 self.assertRaises(self.failureException, self.assertGreater, 1, 1)
1086 self.assertRaises(self.failureException, self.assertGreaterEqual, 1, 2)
1087 self.assertRaises(self.failureException, self.assertLess, 2, 1)
1088 self.assertRaises(self.failureException, self.assertLess, 1, 1)
1089 self.assertRaises(self.failureException, self.assertLessEqual, 2, 1)
1092 self.assertGreater(1.1, 1.0)
1093 self.assertGreaterEqual(1.1, 1.0)
1094 self.assertGreaterEqual(1.0, 1.0)
1095 self.assertLess(1.0, 1.1)
1096 self.assertLessEqual(1.0, 1.1)
1097 self.assertLessEqual(1.0, 1.0)
1098 self.assertRaises(self.failureException, self.assertGreater, 1.0, 1.1)
1099 self.assertRaises(self.failureException, self.assertGreater, 1.0, 1.0)
1100 self.assertRaises(self.failureException, self.assertGreaterEqual, 1.0, 1.1)
1101 self.assertRaises(self.failureException, self.assertLess, 1.1, 1.0)
1102 self.assertRaises(self.failureException, self.assertLess, 1.0, 1.0)
1103 self.assertRaises(self.failureException, self.assertLessEqual, 1.1, 1.0)
1106 self.assertGreater('bug', 'ant')
1107 self.assertGreaterEqual('bug', 'ant')
1108 self.assertGreaterEqual('ant', 'ant')
1109 self.assertLess('ant', 'bug')
1110 self.assertLessEqual('ant', 'bug')
1111 self.assertLessEqual('ant', 'ant')
1112 self.assertRaises(self.failureException, self.assertGreater, 'ant', 'bug')
1113 self.assertRaises(self.failureException, self.assertGreater, 'ant', 'ant')
1114 self.assertRaises(self.failureException, self.assertGreaterEqual, 'ant', 'bug')
1115 self.assertRaises(self.failureException, self.assertLess, 'bug', 'ant')
1116 self.assertRaises(self.failureException, self.assertLess, 'ant', 'ant')
1117 self.assertRaises(self.failureException, self.assertLessEqual, 'bug', 'ant')
1120 self.assertGreater(b'bug', b'ant')
1121 self.assertGreaterEqual(b'bug', b'ant')
1122 self.assertGreaterEqual(b'ant', b'ant')
1123 self.assertLess(b'ant', b'bug')
1124 self.assertLessEqual(b'ant', b'bug')
1125 self.assertLessEqual(b'ant', b'ant')
1126 self.assertRaises(self.failureException, self.assertGreater, b'ant', b'bug')
1127 self.assertRaises(self.failureException, self.assertGreater, b'ant', b'ant')
1128 self.assertRaises(self.failureException, self.assertGreaterEqual, b'ant',
1130 self.assertRaises(self.failureException, self.assertLess, b'bug', b'ant')
1131 self.assertRaises(self.failureException, self.assertLess, b'ant', b'ant')
1132 self.assertRaises(self.failureException, self.assertLessEqual, b'bug', b'ant')
1134 def testAssertMultiLineEqual(self):
1157 self.maxDiff = None
1159 self.assertMultiLineEqual(sample_text, revised_sample_text)
1160 except self.failureException as e:
1163 self.assertEqual(sample_text_error, error)
1165 def testAssertEqualSingleLine(self):
1175 self.assertEqual(sample_text, revised_sample_text)
1176 except self.failureException as e:
1179 self.assertEqual(sample_text_error, error)
1181 def testEqualityBytesWarning(self):
1184 return self.assertWarnsRegex(BytesWarning,
1190 with bytes_warning(), self.assertRaises(self.failureException):
1191 self.assertEqual('a', b'a')
1193 self.assertNotEqual('a', b'a')
1197 with bytes_warning(), self.assertRaises(self.failureException):
1198 self.assertListEqual(a, b)
1199 with bytes_warning(), self.assertRaises(self.failureException):
1200 self.assertTupleEqual(tuple(a), tuple(b))
1201 with bytes_warning(), self.assertRaises(self.failureException):
1202 self.assertSequenceEqual(a, tuple(b))
1203 with bytes_warning(), self.assertRaises(self.failureException):
1204 self.assertSequenceEqual(tuple(a), b)
1205 with bytes_warning(), self.assertRaises(self.failureException):
1206 self.assertSequenceEqual('a', b'a')
1207 with bytes_warning(), self.assertRaises(self.failureException):
1208 self.assertSetEqual(set(a), set(b))
1210 with self.assertRaises(self.failureException):
1211 self.assertListEqual(a, tuple(b))
1212 with self.assertRaises(self.failureException):
1213 self.assertTupleEqual(tuple(a), b)
1217 with self.assertRaises(self.failureException):
1218 self.assertListEqual(a, b)
1219 with self.assertRaises(self.failureException):
1220 self.assertTupleEqual(tuple(a), tuple(b))
1221 with self.assertRaises(self.failureException):
1222 self.assertSequenceEqual(a, tuple(b))
1223 with self.assertRaises(self.failureException):
1224 self.assertSequenceEqual(tuple(a), b)
1225 with self.assertRaises(self.failureException):
1226 self.assertSetEqual(set(a), set(b))
1230 with self.assertRaises(self.failureException):
1231 self.assertListEqual(a, b)
1232 with self.assertRaises(self.failureException):
1233 self.assertTupleEqual(tuple(a), tuple(b))
1234 with self.assertRaises(self.failureException):
1235 self.assertSequenceEqual(a, tuple(b))
1236 with self.assertRaises(self.failureException):
1237 self.assertSequenceEqual(tuple(a), b)
1238 with self.assertRaises(self.failureException):
1239 self.assertSetEqual(set(a), set(b))
1241 with bytes_warning(), self.assertRaises(self.failureException):
1242 self.assertDictEqual({'a': 0}, {b'a': 0})
1243 with self.assertRaises(self.failureException):
1244 self.assertDictEqual({}, {b'a': 0})
1245 with self.assertRaises(self.failureException):
1246 self.assertDictEqual({b'a': 0}, {})
1248 with self.assertRaises(self.failureException):
1249 self.assertCountEqual([b'a', b'a'], [b'a', b'a', b'a'])
1251 self.assertCountEqual(['a', b'a'], ['a', b'a'])
1252 with bytes_warning(), self.assertRaises(self.failureException):
1253 self.assertCountEqual(['a', 'a'], [b'a', b'a'])
1254 with bytes_warning(), self.assertRaises(self.failureException):
1255 self.assertCountEqual(['a', 'a', []], [b'a', b'a', []])
1257 def testAssertIsNone(self):
1258 self.assertIsNone(None)
1259 self.assertRaises(self.failureException, self.assertIsNone, False)
1260 self.assertIsNotNone('DjZoPloGears on Rails')
1261 self.assertRaises(self.failureException, self.assertIsNotNone, None)
1263 def testAssertRegex(self):
1264 self.assertRegex('asdfabasdf', r'ab+')
1265 self.assertRaises(self.failureException, self.assertRegex,
1268 def testAssertRaisesCallable(self):
1273 self.assertRaises(ExceptionMock, Stub)
1275 self.assertRaises((ValueError, ExceptionMock), Stub)
1277 self.assertRaises(ValueError, int, '19', base=8)
1279 with self.assertRaises(self.failureException):
1280 self.assertRaises(ExceptionMock, lambda: 0)
1282 with self.assertRaises(TypeError):
1283 self.assertRaises(ExceptionMock, None)
1285 with self.assertRaises(ExceptionMock):
1286 self.assertRaises(ValueError, Stub)
1288 def testAssertRaisesContext(self):
1293 with self.assertRaises(ExceptionMock):
1296 with self.assertRaises((ValueError, ExceptionMock)) as cm:
1299 self.assertIsInstance(cm.exception, ExceptionMock)
1300 self.assertEqual(cm.exception.args[0], 'We expect')
1302 with self.assertRaises(ValueError):
1305 with self.assertRaises(self.failureException):
1306 with self.assertRaises(ExceptionMock):
1309 with self.assertRaisesRegex(self.failureException, 'foobar'):
1310 with self.assertRaises(ExceptionMock, msg='foobar'):
1313 with self.assertRaisesRegex(TypeError, 'foobar'):
1314 with self.assertRaises(ExceptionMock, foobar=42):
1317 with self.assertRaises(ExceptionMock):
1318 self.assertRaises(ValueError, Stub)
1320 def testAssertRaisesNoExceptionType(self):
1321 with self.assertRaises(TypeError):
1322 self.assertRaises()
1323 with self.assertRaises(TypeError):
1324 self.assertRaises(1)
1325 with self.assertRaises(TypeError):
1326 self.assertRaises(object)
1327 with self.assertRaises(TypeError):
1328 self.assertRaises((ValueError, 1))
1329 with self.assertRaises(TypeError):
1330 self.assertRaises((ValueError, object))
1332 def testAssertRaisesRefcount(self):
1342 self.assertRaises(ValueError, func)
1343 self.assertEqual(refcount, sys.getrefcount(func))
1345 def testAssertRaisesRegex(self):
1352 self.assertRaisesRegex(ExceptionMock, re.compile('expect$'), Stub)
1353 self.assertRaisesRegex(ExceptionMock, 'expect$', Stub)
1354 with self.assertRaises(TypeError):
1355 self.assertRaisesRegex(ExceptionMock, 'expect$', None)
1357 def testAssertNotRaisesRegex(self):
1358 self.assertRaisesRegex(
1359 self.failureException, '^Exception not raised by <lambda>$',
1360 self.assertRaisesRegex, Exception, re.compile('x'),
1362 self.assertRaisesRegex(
1363 self.failureException, '^Exception not raised by <lambda>$',
1364 self.assertRaisesRegex, Exception, 'x',
1367 with self.assertRaisesRegex(self.failureException, 'foobar'):
1368 with self.assertRaisesRegex(Exception, 'expect', msg='foobar'):
1371 with self.assertRaisesRegex(TypeError, 'foobar'):
1372 with self.assertRaisesRegex(Exception, 'expect', foobar=42):
1375 def testAssertRaisesRegexInvalidRegex(self):
1379 self.assertRaises(TypeError, self.assertRaisesRegex, MyExc, lambda: True)
1381 def testAssertWarnsRegexInvalidRegex(self):
1385 self.assertRaises(TypeError, self.assertWarnsRegex, MyWarn, lambda: True)
1387 def testAssertWarnsModifySysModules(self):
1391 def __warningregistry__(self):
1396 self.assertWarns(UserWarning, warnings.warn, 'expected')
1401 def testAssertRaisesRegexMismatch(self):
1405 self.assertRaisesRegex(
1406 self.failureException,
1408 self.assertRaisesRegex, Exception, '^Expected$',
1410 self.assertRaisesRegex(
1411 self.failureException,
1413 self.assertRaisesRegex, Exception,
1416 def testAssertRaisesExcValue(self):
1424 ctx = self.assertRaises(ExceptionMock)
1428 self.assertIsInstance(e, ExceptionMock)
1429 self.assertEqual(e.args[0], v)
1431 def testAssertRaisesRegexNoExceptionType(self):
1432 with self.assertRaises(TypeError):
1433 self.assertRaisesRegex()
1434 with self.assertRaises(TypeError):
1435 self.assertRaisesRegex(ValueError)
1436 with self.assertRaises(TypeError):
1437 self.assertRaisesRegex(1, 'expect')
1438 with self.assertRaises(TypeError):
1439 self.assertRaisesRegex(object, 'expect')
1440 with self.assertRaises(TypeError):
1441 self.assertRaisesRegex((ValueError, 1), 'expect')
1442 with self.assertRaises(TypeError):
1443 self.assertRaisesRegex((ValueError, object), 'expect')
1445 def testAssertWarnsCallable(self):
1449 self.assertWarns(RuntimeWarning, _runtime_warn)
1450 self.assertWarns(RuntimeWarning, _runtime_warn)
1452 self.assertWarns((DeprecationWarning, RuntimeWarning), _runtime_warn)
1454 self.assertWarns(RuntimeWarning,
1457 with self.assertRaises(self.failureException):
1458 self.assertWarns(RuntimeWarning, lambda: 0)
1460 with self.assertRaises(TypeError):
1461 self.assertWarns(RuntimeWarning, None)
1466 with self.assertRaises(self.failureException):
1467 self.assertWarns(DeprecationWarning, _runtime_warn)
1471 with self.assertRaises(RuntimeWarning):
1472 self.assertWarns(DeprecationWarning, _runtime_warn)
1474 def testAssertWarnsContext(self):
1480 with self.assertWarns(RuntimeWarning) as cm:
1483 with self.assertWarns((DeprecationWarning, RuntimeWarning)) as cm:
1486 self.assertIsInstance(cm.warning, RuntimeWarning)
1487 self.assertEqual(cm.warning.args[0], "foo")
1488 self.assertIn("test_case.py", cm.filename)
1489 self.assertEqual(cm.lineno, _runtime_warn_lineno + 1)
1491 with self.assertWarns(RuntimeWarning):
1494 with self.assertWarns(RuntimeWarning):
1497 with self.assertRaises(self.failureException):
1498 with self.assertWarns(RuntimeWarning):
1501 with self.assertRaisesRegex(self.failureException, 'foobar'):
1502 with self.assertWarns(RuntimeWarning, msg='foobar'):
1505 with self.assertRaisesRegex(TypeError, 'foobar'):
1506 with self.assertWarns(RuntimeWarning, foobar=42):
1512 with self.assertRaises(self.failureException):
1513 with self.assertWarns(DeprecationWarning):
1518 with self.assertRaises(RuntimeWarning):
1519 with self.assertWarns(DeprecationWarning):
1522 def testAssertWarnsNoExceptionType(self):
1523 with self.assertRaises(TypeError):
1524 self.assertWarns()
1525 with self.assertRaises(TypeError):
1526 self.assertWarns(1)
1527 with self.assertRaises(TypeError):
1528 self.assertWarns(object)
1529 with self.assertRaises(TypeError):
1530 self.assertWarns((UserWarning, 1))
1531 with self.assertRaises(TypeError):
1532 self.assertWarns((UserWarning, object))
1533 with self.assertRaises(TypeError):
1534 self.assertWarns((UserWarning, Exception))
1536 def testAssertWarnsRegexCallable(self):
1539 self.assertWarnsRegex(RuntimeWarning, "o+",
1542 with self.assertRaises(self.failureException):
1543 self.assertWarnsRegex(RuntimeWarning, "o+",
1546 with self.assertRaises(TypeError):
1547 self.assertWarnsRegex(RuntimeWarning, "o+", None)
1552 with self.assertRaises(self.failureException):
1553 self.assertWarnsRegex(DeprecationWarning, "o+",
1556 with self.assertRaises(self.failureException):
1557 self.assertWarnsRegex(RuntimeWarning, "o+",
1565 with self.assertRaises((RuntimeWarning, self.failureException)):
1566 self.assertWarnsRegex(RuntimeWarning, "o+",
1569 def testAssertWarnsRegexContext(self):
1574 with self.assertWarnsRegex(RuntimeWarning, "o+") as cm:
1576 self.assertIsInstance(cm.warning, RuntimeWarning)
1577 self.assertEqual(cm.warning.args[0], "foox")
1578 self.assertIn("test_case.py", cm.filename)
1579 self.assertEqual(cm.lineno, _runtime_warn_lineno + 1)
1581 with self.assertRaises(self.failureException):
1582 with self.assertWarnsRegex(RuntimeWarning, "o+"):
1585 with self.assertRaisesRegex(self.failureException, 'foobar'):
1586 with self.assertWarnsRegex(RuntimeWarning, 'o+', msg='foobar'):
1589 with self.assertRaisesRegex(TypeError, 'foobar'):
1590 with self.assertWarnsRegex(RuntimeWarning, 'o+', foobar=42):
1596 with self.assertRaises(self.failureException):
1597 with self.assertWarnsRegex(DeprecationWarning, "o+"):
1600 with self.assertRaises(self.failureException):
1601 with self.assertWarnsRegex(RuntimeWarning, "o+"):
1609 with self.assertRaises((RuntimeWarning, self.failureException)):
1610 with self.assertWarnsRegex(RuntimeWarning, "o+"):
1613 def testAssertWarnsRegexNoExceptionType(self):
1614 with self.assertRaises(TypeError):
1615 self.assertWarnsRegex()
1616 with self.assertRaises(TypeError):
1617 self.assertWarnsRegex(UserWarning)
1618 with self.assertRaises(TypeError):
1619 self.assertWarnsRegex(1, 'expect')
1620 with self.assertRaises(TypeError):
1621 self.assertWarnsRegex(object, 'expect')
1622 with self.assertRaises(TypeError):
1623 self.assertWarnsRegex((UserWarning, 1), 'expect')
1624 with self.assertRaises(TypeError):
1625 self.assertWarnsRegex((UserWarning, object), 'expect')
1626 with self.assertRaises(TypeError):
1627 self.assertWarnsRegex((UserWarning, Exception), 'expect')
1630 def assertNoStderr(self):
1633 self.assertEqual(buf.getvalue(), "")
1635 def assertLogRecords(self, records, matches):
1636 self.assertEqual(len(records), len(matches))
1638 self.assertIsInstance(rec, logging.LogRecord)
1640 self.assertEqual(getattr(rec, k), v)
1642 def testAssertLogsDefaults(self):
1644 with self.assertNoStderr():
1645 with self.assertLogs() as cm:
1648 self.assertEqual(cm.output, ["INFO:foo:1"])
1649 self.assertLogRecords(cm.records, [{'name': 'foo'}])
1651 def testAssertLogsTwoMatchingMessages(self):
1653 with self.assertNoStderr():
1654 with self.assertLogs() as cm:
1658 self.assertEqual(cm.output, ["INFO:foo:1", "WARNING:quux:3"])
1659 self.assertLogRecords(cm.records,
1662 def checkAssertLogsPerLevel(self, level):
1664 with self.assertNoStderr():
1665 with self.assertLogs(level=level) as cm:
1669 self.assertEqual(cm.output, ["ERROR:foo.bar:2", "CRITICAL:quux:3"])
1670 self.assertLogRecords(cm.records,
1673 def testAssertLogsPerLevel(self):
1674 self.checkAssertLogsPerLevel(logging.ERROR)
1675 self.checkAssertLogsPerLevel('ERROR')
1677 def checkAssertLogsPerLogger(self, logger):
1679 with self.assertNoStderr():
1680 with self.assertLogs(level='DEBUG') as outer_cm:
1681 with self.assertLogs(logger, level='DEBUG') as cm:
1685 self.assertEqual(cm.output, ["INFO:foo:1", "DEBUG:foo.bar:2"])
1686 self.assertLogRecords(cm.records,
1689 self.assertEqual(outer_cm.output, ["WARNING:quux:3"])
1691 def testAssertLogsPerLogger(self):
1692 self.checkAssertLogsPerLogger(logging.getLogger('foo'))
1693 self.checkAssertLogsPerLogger('foo')
1695 def testAssertLogsFailureNoLogs(self):
1697 with self.assertNoStderr():
1698 with self.assertRaises(self.failureException):
1699 with self.assertLogs():
1702 def testAssertLogsFailureLevelTooHigh(self):
1704 with self.assertNoStderr():
1705 with self.assertRaises(self.failureException):
1706 with self.assertLogs(level='WARNING'):
1709 def testAssertLogsFailureLevelTooHigh_FilterInRootLogger(self):
1711 with self.assertNoStderr():
1715 with self.assertRaises(self.failureException):
1716 with self.assertLogs(level='WARNING'):
1721 def testAssertLogsFailureMismatchingLogger(self):
1724 with self.assertLogs('quux', level='ERROR'):
1725 with self.assertRaises(self.failureException):
1726 with self.assertLogs('foo'):
1729 def testAssertLogsUnexpectedException(self):
1731 with self.assertRaises(ZeroDivisionError):
1732 with self.assertLogs():
1735 def testAssertNoLogsDefault(self):
1736 with self.assertRaises(self.failureException) as cm:
1737 with self.assertNoLogs():
1740 self.assertEqual(
1745 def testAssertNoLogsFailureFoundLogs(self):
1746 with self.assertRaises(self.failureException) as cm:
1747 with self.assertNoLogs():
1751 self.assertEqual(
1756 def testAssertNoLogsPerLogger(self):
1757 with self.assertNoStderr():
1758 with self.assertLogs(log_quux):
1759 with self.assertNoLogs(logger=log_foo):
1762 def testAssertNoLogsFailurePerLogger(self):
1765 with self.assertRaises(self.failureException) as cm:
1766 with self.assertLogs(log_quux):
1767 with self.assertNoLogs(logger=log_foo):
1770 self.assertEqual(
1775 def testAssertNoLogsPerLevel(self):
1777 with self.assertNoStderr():
1778 with self.assertNoLogs(level="ERROR"):
1782 def testAssertNoLogsFailurePerLevel(self):
1784 with self.assertRaises(self.failureException) as cm:
1785 with self.assertNoLogs(level="DEBUG"):
1788 self.assertEqual(
1793 def testAssertNoLogsUnexpectedException(self):
1795 with self.assertRaises(ZeroDivisionError):
1796 with self.assertNoLogs():
1799 def testAssertNoLogsYieldsNone(self):
1800 with self.assertNoLogs() as value:
1802 self.assertIsNone(value)
1804 def testDeprecatedMethodNames(self):
1809 (self.failIfEqual, (3, 5)),
1810 (self.assertNotEquals, (3, 5)),
1811 (self.failUnlessEqual, (3, 3)),
1812 (self.assertEquals, (3, 3)),
1813 (self.failUnlessAlmostEqual, (2.0, 2.0)),
1814 (self.assertAlmostEquals, (2.0, 2.0)),
1815 (self.failIfAlmostEqual, (3.0, 5.0)),
1816 (self.assertNotAlmostEquals, (3.0, 5.0)),
1817 (self.failUnless, (True,)),
1818 (self.assert_, (True,)),
1819 (self.failUnlessRaises, (TypeError, lambda _: 3.14 + 'spam')),
1820 (self.failIf, (False,)),
1821 (self.assertDictContainsSubset, (dict(a=1, b=2), dict(a=1, b=2, c=3))),
1822 (self.assertRaisesRegexp, (KeyError, 'foo', lambda: {}['foo'])),
1823 (self.assertRegexpMatches, ('bar', 'bar')),
1826 with self.assertWarns(DeprecationWarning):
1831 def _testDeprecatedFailMethods(self):
1841 with self.assertRaises(AttributeError):
1842 getattr(self, deprecated_name) # remove these in 3.x
1844 def testDeepcopy(self):
1847 def testNothing(self):
1855 def testPickle(self):
1866 self.assertEqual(test, unpickled_test)
1872 def testKeyboardInterrupt(self):
1873 def _raise(self=None):
1875 def nothing(self):
1890 def test_something(self):
1891 self.addCleanup(_raise)
1894 with self.assertRaises(KeyboardInterrupt):
1897 def testSkippingEverywhere(self):
1898 def _skip(self=None):
1900 def nothing(self):
1915 def test_something(self):
1916 self.addCleanup(_skip)
1921 self.assertEqual(len(result.skipped), 1)
1922 self.assertEqual(result.testsRun, 1)
1924 def testSystemExit(self):
1925 def _raise(self=None):
1927 def nothing(self):
1942 def test_something(self):
1943 self.addCleanup(_raise)
1948 self.assertEqual(len(result.errors), 1)
1949 self.assertEqual(result.testsRun, 1)
1952 def testNoCycles(self):
1957 self.assertFalse(wr())
1959 def test_no_exception_leak(self):
1965 def __init__(self):
1967 Exception.__init__(self)
1969 def __del__(self):
1973 def test1(self):
1977 def test2(self):
1984 self.assertEqual(MyException.ninstance, 0)