mirror of
https://github.com/python/cpython.git
synced 2025-08-04 00:48:58 +00:00
Merged revisions 70837,70864,70878,71004,71032,71043 via svnmerge from
svn+ssh://pythondev@svn.python.org/python/trunk ........ r70837 | gregory.p.smith | 2009-03-31 11:54:10 -0500 (Tue, 31 Mar 2009) | 9 lines The unittest.TestCase.assertEqual() now displays the differences in lists, tuples, dicts and sets on failure. Many new handy type and comparison specific assert* methods have been added that fail with error messages actually useful for debugging. Contributed in by Google and completed with help from mfoord and GvR at PyCon 2009 sprints. Discussion lives in http://bugs.python.org/issue2578. ........ r70864 | gregory.p.smith | 2009-03-31 14:03:28 -0500 (Tue, 31 Mar 2009) | 10 lines Rename the actual method definitions to the official assertFoo names. Adds unittests to make sure the old fail* names continue to work now and adds a comment that they are pending deprecation. Also adds a test to confirm that the plural Equals method variants continue to exist even though we're unlikely to deprecate those. http://bugs.python.org/issue2578 ........ r70878 | gregory.p.smith | 2009-03-31 14:59:14 -0500 (Tue, 31 Mar 2009) | 3 lines Issue an actual PendingDeprecationWarning for the TestCase.fail* methods. Document the deprecation. ........ r71004 | benjamin.peterson | 2009-04-01 18:15:49 -0500 (Wed, 01 Apr 2009) | 1 line remove double underscores ........ r71032 | michael.foord | 2009-04-01 22:20:38 -0500 (Wed, 01 Apr 2009) | 13 lines Better exception messages for unittest assert methods. - unittest.assertNotEqual() now uses the inequality operator (!=) instead of the equality operator. - Default assertTrue and assertFalse messages are now useful. - TestCase has a longMessage attribute. This defaults to False, but if set to True useful error messages are shown in addition to explicit messages passed to assert methods. Issue #5663 ........ r71043 | michael.foord | 2009-04-02 00:51:54 -0500 (Thu, 02 Apr 2009) | 7 lines Store the functions in the _type_equality_funcs as wrapped objects that are deep copyable. This allows for the deep copying of TestCase instances. Issue 5660 ........
This commit is contained in:
Benjamin Peterson
parent
9247e72359
commit
7fe73a17c5
5 changed files with 1378 additions and 136 deletions
|
|
@ -244,7 +244,7 @@ class GCTests(unittest.TestCase):
|
|||
# - the call to assertEqual somehow avoids building its args tuple
|
||||
def test_get_count(self):
|
||||
# Avoid future allocation of method object
|
||||
assertEqual = self.assertEqual
|
||||
assertEqual = self._baseAssertEqual
|
||||
gc.collect()
|
||||
assertEqual(gc.get_count(), (0, 0, 0))
|
||||
a = dict()
|
||||
|
|
|
|||
|
|
@ -207,6 +207,7 @@ class StructTest(unittest.TestCase):
|
|||
class IntTester(unittest.TestCase):
|
||||
|
||||
def __init__(self, formatpair, bytesize):
|
||||
super(IntTester, self).__init__(methodName='test_one')
|
||||
self.assertEqual(len(formatpair), 2)
|
||||
self.formatpair = formatpair
|
||||
for direction in "<>!=":
|
||||
|
|
|
|||
|
|
@ -6,10 +6,12 @@ Still need testing:
|
|||
TestCase.{assert,fail}* methods (some are tested implicitly)
|
||||
"""
|
||||
|
||||
import re
|
||||
from test import support
|
||||
import unittest
|
||||
from unittest import TestCase
|
||||
import types
|
||||
from copy import deepcopy
|
||||
|
||||
### Support code
|
||||
################################################################
|
||||
|
|
@ -53,6 +55,8 @@ class LoggingResult(unittest.TestResult):
|
|||
|
||||
|
||||
class TestEquality(object):
|
||||
"""Used as a mixin for TestCase"""
|
||||
|
||||
# Check for a valid __eq__ implementation
|
||||
def test_eq(self):
|
||||
for obj_1, obj_2 in self.eq_pairs:
|
||||
|
|
@ -66,25 +70,26 @@ class TestEquality(object):
|
|||
self.failIfEqual(obj_2, obj_1)
|
||||
|
||||
class TestHashing(object):
|
||||
"""Used as a mixin for TestCase"""
|
||||
|
||||
# Check for a valid __hash__ implementation
|
||||
def test_hash(self):
|
||||
for obj_1, obj_2 in self.eq_pairs:
|
||||
try:
|
||||
assert hash(obj_1) == hash(obj_2)
|
||||
if not hash(obj_1) == hash(obj_2):
|
||||
self.fail("%r and %r do not hash equal" % (obj_1, obj_2))
|
||||
except KeyboardInterrupt:
|
||||
raise
|
||||
except AssertionError:
|
||||
self.fail("%s and %s do not hash equal" % (obj_1, obj_2))
|
||||
except Exception as e:
|
||||
self.fail("Problem hashing %s and %s: %s" % (obj_1, obj_2, e))
|
||||
self.fail("Problem hashing %r and %r: %s" % (obj_1, obj_2, e))
|
||||
|
||||
for obj_1, obj_2 in self.ne_pairs:
|
||||
try:
|
||||
assert hash(obj_1) != hash(obj_2)
|
||||
if hash(obj_1) == hash(obj_2):
|
||||
self.fail("%s and %s hash equal, but shouldn't" %
|
||||
(obj_1, obj_2))
|
||||
except KeyboardInterrupt:
|
||||
raise
|
||||
except AssertionError:
|
||||
self.fail("%s and %s hash equal, but shouldn't" % (obj_1, obj_2))
|
||||
except Exception as e:
|
||||
self.fail("Problem hashing %s and %s: %s" % (obj_1, obj_2, e))
|
||||
|
||||
|
|
@ -2247,39 +2252,6 @@ class Test_TestCase(TestCase, TestEquality, TestHashing):
|
|||
|
||||
self.failUnless(isinstance(Foo().id(), str))
|
||||
|
||||
# "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 test method's docstring, if available, or None."
|
||||
def test_shortDescription__no_docstring(self):
|
||||
class Foo(unittest.TestCase):
|
||||
def runTest(self):
|
||||
pass
|
||||
|
||||
self.assertEqual(Foo().shortDescription(), None)
|
||||
|
||||
# "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 test method's docstring, if available, or None."
|
||||
def test_shortDescription__singleline_docstring(self):
|
||||
class Foo(unittest.TestCase):
|
||||
def runTest(self):
|
||||
"this tests foo"
|
||||
pass
|
||||
|
||||
self.assertEqual(Foo().shortDescription(), "this tests foo")
|
||||
|
||||
# "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 test method's docstring, if available, or None."
|
||||
def test_shortDescription__multiline_docstring(self):
|
||||
class Foo(unittest.TestCase):
|
||||
def runTest(self):
|
||||
"""this tests foo
|
||||
blah, bar and baz are also tested"""
|
||||
pass
|
||||
|
||||
self.assertEqual(Foo().shortDescription(), "this tests foo")
|
||||
|
||||
# "If result is omitted or None, a temporary result object is created
|
||||
# and used, but is not made available to the caller"
|
||||
def test_run__uses_defaultTestResult(self):
|
||||
|
|
@ -2298,6 +2270,405 @@ class Test_TestCase(TestCase, TestEquality, TestHashing):
|
|||
expected = ['startTest', 'test', 'addSuccess', 'stopTest']
|
||||
self.assertEqual(events, expected)
|
||||
|
||||
def testShortDescriptionWithoutDocstring(self):
|
||||
self.assertEqual(
|
||||
self.shortDescription(),
|
||||
'testShortDescriptionWithoutDocstring (' + __name__ +
|
||||
'.Test_TestCase)')
|
||||
|
||||
def testShortDescriptionWithOneLineDocstring(self):
|
||||
"""Tests shortDescription() for a method with a docstring."""
|
||||
self.assertEqual(
|
||||
self.shortDescription(),
|
||||
('testShortDescriptionWithOneLineDocstring '
|
||||
'(' + __name__ + '.Test_TestCase)\n'
|
||||
'Tests shortDescription() for a method with a docstring.'))
|
||||
|
||||
def testShortDescriptionWithMultiLineDocstring(self):
|
||||
"""Tests shortDescription() for a method with a longer docstring.
|
||||
|
||||
This method ensures that only the first line of a docstring is
|
||||
returned used in the short description, no matter how long the
|
||||
whole thing is.
|
||||
"""
|
||||
self.assertEqual(
|
||||
self.shortDescription(),
|
||||
('testShortDescriptionWithMultiLineDocstring '
|
||||
'(' + __name__ + '.Test_TestCase)\n'
|
||||
'Tests shortDescription() for a method with a longer '
|
||||
'docstring.'))
|
||||
|
||||
def testAddTypeEqualityFunc(self):
|
||||
class SadSnake(object):
|
||||
"""Dummy class for test_addTypeEqualityFunc."""
|
||||
s1, s2 = SadSnake(), SadSnake()
|
||||
self.assertFalse(s1 == s2)
|
||||
def AllSnakesCreatedEqual(a, b, msg=None):
|
||||
return type(a) == type(b) == SadSnake
|
||||
self.addTypeEqualityFunc(SadSnake, AllSnakesCreatedEqual)
|
||||
self.assertEqual(s1, s2)
|
||||
# No this doesn't clean up and remove the SadSnake equality func
|
||||
# from this TestCase instance but since its a local nothing else
|
||||
# will ever notice that.
|
||||
|
||||
def testAssertIn(self):
|
||||
animals = {'monkey': 'banana', 'cow': 'grass', 'seal': 'fish'}
|
||||
|
||||
self.assertIn('a', 'abc')
|
||||
self.assertIn(2, [1, 2, 3])
|
||||
self.assertIn('monkey', animals)
|
||||
|
||||
self.assertNotIn('d', 'abc')
|
||||
self.assertNotIn(0, [1, 2, 3])
|
||||
self.assertNotIn('otter', animals)
|
||||
|
||||
self.assertRaises(self.failureException, self.assertIn, 'x', 'abc')
|
||||
self.assertRaises(self.failureException, self.assertIn, 4, [1, 2, 3])
|
||||
self.assertRaises(self.failureException, self.assertIn, 'elephant',
|
||||
animals)
|
||||
|
||||
self.assertRaises(self.failureException, self.assertNotIn, 'c', 'abc')
|
||||
self.assertRaises(self.failureException, self.assertNotIn, 1, [1, 2, 3])
|
||||
self.assertRaises(self.failureException, self.assertNotIn, 'cow',
|
||||
animals)
|
||||
|
||||
def testAssertDictContainsSubset(self):
|
||||
self.assertDictContainsSubset({}, {})
|
||||
self.assertDictContainsSubset({}, {'a': 1})
|
||||
self.assertDictContainsSubset({'a': 1}, {'a': 1})
|
||||
self.assertDictContainsSubset({'a': 1}, {'a': 1, 'b': 2})
|
||||
self.assertDictContainsSubset({'a': 1, 'b': 2}, {'a': 1, 'b': 2})
|
||||
|
||||
self.assertRaises(unittest.TestCase.failureException,
|
||||
self.assertDictContainsSubset, {'a': 2}, {'a': 1},
|
||||
'.*Mismatched values:.*')
|
||||
|
||||
self.assertRaises(unittest.TestCase.failureException,
|
||||
self.assertDictContainsSubset, {'c': 1}, {'a': 1},
|
||||
'.*Missing:.*')
|
||||
|
||||
self.assertRaises(unittest.TestCase.failureException,
|
||||
self.assertDictContainsSubset, {'a': 1, 'c': 1},
|
||||
{'a': 1}, '.*Missing:.*')
|
||||
|
||||
self.assertRaises(unittest.TestCase.failureException,
|
||||
self.assertDictContainsSubset, {'a': 1, 'c': 1},
|
||||
{'a': 1}, '.*Missing:.*Mismatched values:.*')
|
||||
|
||||
def testAssertEqual(self):
|
||||
equal_pairs = [
|
||||
((), ()),
|
||||
({}, {}),
|
||||
([], []),
|
||||
(set(), set()),
|
||||
(frozenset(), frozenset())]
|
||||
for a, b in equal_pairs:
|
||||
# This mess of try excepts is to test the assertEqual behavior
|
||||
# itself.
|
||||
try:
|
||||
self.assertEqual(a, b)
|
||||
except self.failureException:
|
||||
self.fail('assertEqual(%r, %r) failed' % (a, b))
|
||||
try:
|
||||
self.assertEqual(a, b, msg='foo')
|
||||
except self.failureException:
|
||||
self.fail('assertEqual(%r, %r) with msg= failed' % (a, b))
|
||||
try:
|
||||
self.assertEqual(a, b, 'foo')
|
||||
except self.failureException:
|
||||
self.fail('assertEqual(%r, %r) with third parameter failed' %
|
||||
(a, b))
|
||||
|
||||
unequal_pairs = [
|
||||
((), []),
|
||||
({}, set()),
|
||||
(set([4,1]), frozenset([4,2])),
|
||||
(frozenset([4,5]), set([2,3])),
|
||||
(set([3,4]), set([5,4]))]
|
||||
for a, b in unequal_pairs:
|
||||
self.assertRaises(self.failureException, self.assertEqual, a, b)
|
||||
self.assertRaises(self.failureException, self.assertEqual, a, b,
|
||||
'foo')
|
||||
self.assertRaises(self.failureException, self.assertEqual, a, b,
|
||||
msg='foo')
|
||||
|
||||
def testEquality(self):
|
||||
self.assertListEqual([], [])
|
||||
self.assertTupleEqual((), ())
|
||||
self.assertSequenceEqual([], ())
|
||||
|
||||
a = [0, 'a', []]
|
||||
b = []
|
||||
self.assertRaises(unittest.TestCase.failureException,
|
||||
self.assertListEqual, a, b)
|
||||
self.assertRaises(unittest.TestCase.failureException,
|
||||
self.assertListEqual, tuple(a), tuple(b))
|
||||
self.assertRaises(unittest.TestCase.failureException,
|
||||
self.assertSequenceEqual, a, tuple(b))
|
||||
|
||||
b.extend(a)
|
||||
self.assertListEqual(a, b)
|
||||
self.assertTupleEqual(tuple(a), tuple(b))
|
||||
self.assertSequenceEqual(a, tuple(b))
|
||||
self.assertSequenceEqual(tuple(a), b)
|
||||
|
||||
self.assertRaises(self.failureException, self.assertListEqual,
|
||||
a, tuple(b))
|
||||
self.assertRaises(self.failureException, self.assertTupleEqual,
|
||||
tuple(a), b)
|
||||
self.assertRaises(self.failureException, self.assertListEqual, None, b)
|
||||
self.assertRaises(self.failureException, self.assertTupleEqual, None,
|
||||
tuple(b))
|
||||
self.assertRaises(self.failureException, self.assertSequenceEqual,
|
||||
None, tuple(b))
|
||||
self.assertRaises(self.failureException, self.assertListEqual, 1, 1)
|
||||
self.assertRaises(self.failureException, self.assertTupleEqual, 1, 1)
|
||||
self.assertRaises(self.failureException, self.assertSequenceEqual,
|
||||
1, 1)
|
||||
|
||||
self.assertDictEqual({}, {})
|
||||
|
||||
c = { 'x': 1 }
|
||||
d = {}
|
||||
self.assertRaises(unittest.TestCase.failureException,
|
||||
self.assertDictEqual, c, d)
|
||||
|
||||
d.update(c)
|
||||
self.assertDictEqual(c, d)
|
||||
|
||||
d['x'] = 0
|
||||
self.assertRaises(unittest.TestCase.failureException,
|
||||
self.assertDictEqual, c, d, 'These are unequal')
|
||||
|
||||
self.assertRaises(self.failureException, self.assertDictEqual, None, d)
|
||||
self.assertRaises(self.failureException, self.assertDictEqual, [], d)
|
||||
self.assertRaises(self.failureException, self.assertDictEqual, 1, 1)
|
||||
|
||||
self.assertSameElements([1, 2, 3], [3, 2, 1])
|
||||
self.assertSameElements([1, 2] + [3] * 100, [1] * 100 + [2, 3])
|
||||
self.assertSameElements(['foo', 'bar', 'baz'], ['bar', 'baz', 'foo'])
|
||||
self.assertRaises(self.failureException, self.assertSameElements,
|
||||
[10], [10, 11])
|
||||
self.assertRaises(self.failureException, self.assertSameElements,
|
||||
[10, 11], [10])
|
||||
|
||||
# Test that sequences of unhashable objects can be tested for sameness:
|
||||
self.assertSameElements([[1, 2], [3, 4]], [[3, 4], [1, 2]])
|
||||
self.assertRaises(self.failureException, self.assertSameElements,
|
||||
[[1]], [[2]])
|
||||
|
||||
def testAssertSetEqual(self):
|
||||
set1 = set()
|
||||
set2 = set()
|
||||
self.assertSetEqual(set1, set2)
|
||||
|
||||
self.assertRaises(self.failureException, self.assertSetEqual, None, set2)
|
||||
self.assertRaises(self.failureException, self.assertSetEqual, [], set2)
|
||||
self.assertRaises(self.failureException, self.assertSetEqual, set1, None)
|
||||
self.assertRaises(self.failureException, self.assertSetEqual, set1, [])
|
||||
|
||||
set1 = set(['a'])
|
||||
set2 = set()
|
||||
self.assertRaises(self.failureException, self.assertSetEqual, set1, set2)
|
||||
|
||||
set1 = set(['a'])
|
||||
set2 = set(['a'])
|
||||
self.assertSetEqual(set1, set2)
|
||||
|
||||
set1 = set(['a'])
|
||||
set2 = set(['a', 'b'])
|
||||
self.assertRaises(self.failureException, self.assertSetEqual, set1, set2)
|
||||
|
||||
set1 = set(['a'])
|
||||
set2 = frozenset(['a', 'b'])
|
||||
self.assertRaises(self.failureException, self.assertSetEqual, set1, set2)
|
||||
|
||||
set1 = set(['a', 'b'])
|
||||
set2 = frozenset(['a', 'b'])
|
||||
self.assertSetEqual(set1, set2)
|
||||
|
||||
set1 = set()
|
||||
set2 = "foo"
|
||||
self.assertRaises(self.failureException, self.assertSetEqual, set1, set2)
|
||||
self.assertRaises(self.failureException, self.assertSetEqual, set2, set1)
|
||||
|
||||
# make sure any string formatting is tuple-safe
|
||||
set1 = set([(0, 1), (2, 3)])
|
||||
set2 = set([(4, 5)])
|
||||
self.assertRaises(self.failureException, self.assertSetEqual, set1, set2)
|
||||
|
||||
def testInequality(self):
|
||||
# Try ints
|
||||
self.assertGreater(2, 1)
|
||||
self.assertGreaterEqual(2, 1)
|
||||
self.assertGreaterEqual(1, 1)
|
||||
self.assertLess(1, 2)
|
||||
self.assertLessEqual(1, 2)
|
||||
self.assertLessEqual(1, 1)
|
||||
self.assertRaises(self.failureException, self.assertGreater, 1, 2)
|
||||
self.assertRaises(self.failureException, self.assertGreater, 1, 1)
|
||||
self.assertRaises(self.failureException, self.assertGreaterEqual, 1, 2)
|
||||
self.assertRaises(self.failureException, self.assertLess, 2, 1)
|
||||
self.assertRaises(self.failureException, self.assertLess, 1, 1)
|
||||
self.assertRaises(self.failureException, self.assertLessEqual, 2, 1)
|
||||
|
||||
# Try Floats
|
||||
self.assertGreater(1.1, 1.0)
|
||||
self.assertGreaterEqual(1.1, 1.0)
|
||||
self.assertGreaterEqual(1.0, 1.0)
|
||||
self.assertLess(1.0, 1.1)
|
||||
self.assertLessEqual(1.0, 1.1)
|
||||
self.assertLessEqual(1.0, 1.0)
|
||||
self.assertRaises(self.failureException, self.assertGreater, 1.0, 1.1)
|
||||
self.assertRaises(self.failureException, self.assertGreater, 1.0, 1.0)
|
||||
self.assertRaises(self.failureException, self.assertGreaterEqual, 1.0, 1.1)
|
||||
self.assertRaises(self.failureException, self.assertLess, 1.1, 1.0)
|
||||
self.assertRaises(self.failureException, self.assertLess, 1.0, 1.0)
|
||||
self.assertRaises(self.failureException, self.assertLessEqual, 1.1, 1.0)
|
||||
|
||||
# Try Strings
|
||||
self.assertGreater('bug', 'ant')
|
||||
self.assertGreaterEqual('bug', 'ant')
|
||||
self.assertGreaterEqual('ant', 'ant')
|
||||
self.assertLess('ant', 'bug')
|
||||
self.assertLessEqual('ant', 'bug')
|
||||
self.assertLessEqual('ant', 'ant')
|
||||
self.assertRaises(self.failureException, self.assertGreater, 'ant', 'bug')
|
||||
self.assertRaises(self.failureException, self.assertGreater, 'ant', 'ant')
|
||||
self.assertRaises(self.failureException, self.assertGreaterEqual, 'ant', 'bug')
|
||||
self.assertRaises(self.failureException, self.assertLess, 'bug', 'ant')
|
||||
self.assertRaises(self.failureException, self.assertLess, 'ant', 'ant')
|
||||
self.assertRaises(self.failureException, self.assertLessEqual, 'bug', 'ant')
|
||||
|
||||
# Try bytes
|
||||
self.assertGreater(b'bug', b'ant')
|
||||
self.assertGreaterEqual(b'bug', b'ant')
|
||||
self.assertGreaterEqual(b'ant', b'ant')
|
||||
self.assertLess(b'ant', b'bug')
|
||||
self.assertLessEqual(b'ant', b'bug')
|
||||
self.assertLessEqual(b'ant', b'ant')
|
||||
self.assertRaises(self.failureException, self.assertGreater, b'ant', b'bug')
|
||||
self.assertRaises(self.failureException, self.assertGreater, b'ant', b'ant')
|
||||
self.assertRaises(self.failureException, self.assertGreaterEqual, b'ant',
|
||||
b'bug')
|
||||
self.assertRaises(self.failureException, self.assertLess, b'bug', b'ant')
|
||||
self.assertRaises(self.failureException, self.assertLess, b'ant', b'ant')
|
||||
self.assertRaises(self.failureException, self.assertLessEqual, b'bug', b'ant')
|
||||
|
||||
def testAssertMultiLineEqual(self):
|
||||
sample_text = """\
|
||||
http://www.python.org/doc/2.3/lib/module-unittest.html
|
||||
test case
|
||||
A test case is the smallest unit of testing. [...]
|
||||
"""
|
||||
revised_sample_text = """\
|
||||
http://www.python.org/doc/2.4.1/lib/module-unittest.html
|
||||
test case
|
||||
A test case is the smallest unit of testing. [...] You may provide your
|
||||
own implementation that does not subclass from TestCase, of course.
|
||||
"""
|
||||
sample_text_error = """
|
||||
- http://www.python.org/doc/2.3/lib/module-unittest.html
|
||||
? ^
|
||||
+ http://www.python.org/doc/2.4.1/lib/module-unittest.html
|
||||
? ^^^
|
||||
test case
|
||||
- A test case is the smallest unit of testing. [...]
|
||||
+ A test case is the smallest unit of testing. [...] You may provide your
|
||||
? +++++++++++++++++++++
|
||||
+ own implementation that does not subclass from TestCase, of course.
|
||||
"""
|
||||
|
||||
try:
|
||||
self.assertMultiLineEqual(sample_text, revised_sample_text)
|
||||
except self.failureException as e:
|
||||
# no fair testing ourself with ourself, use assertEqual..
|
||||
self.assertEqual(sample_text_error, str(e))
|
||||
|
||||
def testAssertIsNone(self):
|
||||
self.assertIsNone(None)
|
||||
self.assertRaises(self.failureException, self.assertIsNone, False)
|
||||
self.assertIsNotNone('DjZoPloGears on Rails')
|
||||
self.assertRaises(self.failureException, self.assertIsNotNone, None)
|
||||
|
||||
def testAssertRegexpMatches(self):
|
||||
self.assertRegexpMatches('asdfabasdf', r'ab+')
|
||||
self.assertRaises(self.failureException, self.assertRegexpMatches,
|
||||
'saaas', r'aaaa')
|
||||
|
||||
def testAssertRaisesRegexp(self):
|
||||
class ExceptionMock(Exception):
|
||||
pass
|
||||
|
||||
def Stub():
|
||||
raise ExceptionMock('We expect')
|
||||
|
||||
self.assertRaisesRegexp(ExceptionMock, re.compile('expect$'), Stub)
|
||||
self.assertRaisesRegexp(ExceptionMock, 'expect$', Stub)
|
||||
|
||||
def testAssertNotRaisesRegexp(self):
|
||||
self.assertRaisesRegexp(
|
||||
self.failureException, '^Exception not raised$',
|
||||
self.assertRaisesRegexp, Exception, re.compile('x'),
|
||||
lambda: None)
|
||||
self.assertRaisesRegexp(
|
||||
self.failureException, '^Exception not raised$',
|
||||
self.assertRaisesRegexp, Exception, 'x',
|
||||
lambda: None)
|
||||
|
||||
def testAssertRaisesRegexpMismatch(self):
|
||||
def Stub():
|
||||
raise Exception('Unexpected')
|
||||
|
||||
self.assertRaisesRegexp(
|
||||
self.failureException,
|
||||
r'"\^Expected\$" does not match "Unexpected"',
|
||||
self.assertRaisesRegexp, Exception, '^Expected$',
|
||||
Stub)
|
||||
self.assertRaisesRegexp(
|
||||
self.failureException,
|
||||
r'"\^Expected\$" does not match "Unexpected"',
|
||||
self.assertRaisesRegexp, Exception,
|
||||
re.compile('^Expected$'), Stub)
|
||||
|
||||
def testSynonymAssertMethodNames(self):
|
||||
"""Test undocumented method name synonyms.
|
||||
|
||||
Please do not use these methods names in your own code.
|
||||
|
||||
This test confirms their continued existence and functionality
|
||||
in order to avoid breaking existing code.
|
||||
"""
|
||||
self.assertNotEquals(3, 5)
|
||||
self.assertEquals(3, 3)
|
||||
self.assertAlmostEquals(2.0, 2.0)
|
||||
self.assertNotAlmostEquals(3.0, 5.0)
|
||||
self.assert_(True)
|
||||
|
||||
def testPendingDeprecationMethodNames(self):
|
||||
"""Test fail* methods pending deprecation, they will warn in 3.2.
|
||||
|
||||
Do not use these methods. They will go away in 3.3.
|
||||
"""
|
||||
self.failIfEqual(3, 5)
|
||||
self.failUnlessEqual(3, 3)
|
||||
self.failUnlessAlmostEqual(2.0, 2.0)
|
||||
self.failIfAlmostEqual(3.0, 5.0)
|
||||
self.failUnless(True)
|
||||
self.failUnlessRaises(TypeError, lambda _: 3.14 + 'spam')
|
||||
self.failIf(False)
|
||||
|
||||
def testDeepcopy(self):
|
||||
# Issue: 5660
|
||||
class TestableTest(TestCase):
|
||||
def testNothing(self):
|
||||
pass
|
||||
|
||||
test = TestableTest('testNothing')
|
||||
|
||||
# This shouldn't blow up
|
||||
deepcopy(test)
|
||||
|
||||
|
||||
class Test_TestSkipping(TestCase):
|
||||
|
||||
|
|
@ -2396,20 +2767,20 @@ class Test_Assertions(TestCase):
|
|||
def test_AlmostEqual(self):
|
||||
self.failUnlessAlmostEqual(1.00000001, 1.0)
|
||||
self.failIfAlmostEqual(1.0000001, 1.0)
|
||||
self.assertRaises(AssertionError,
|
||||
self.assertRaises(self.failureException,
|
||||
self.failUnlessAlmostEqual, 1.0000001, 1.0)
|
||||
self.assertRaises(AssertionError,
|
||||
self.assertRaises(self.failureException,
|
||||
self.failIfAlmostEqual, 1.00000001, 1.0)
|
||||
|
||||
self.failUnlessAlmostEqual(1.1, 1.0, places=0)
|
||||
self.assertRaises(AssertionError,
|
||||
self.assertRaises(self.failureException,
|
||||
self.failUnlessAlmostEqual, 1.1, 1.0, places=1)
|
||||
|
||||
self.failUnlessAlmostEqual(0, .1+.1j, places=0)
|
||||
self.failIfAlmostEqual(0, .1+.1j, places=1)
|
||||
self.assertRaises(AssertionError,
|
||||
self.assertRaises(self.failureException,
|
||||
self.failUnlessAlmostEqual, 0, .1+.1j, places=1)
|
||||
self.assertRaises(AssertionError,
|
||||
self.assertRaises(self.failureException,
|
||||
self.failIfAlmostEqual, 0, .1+.1j, places=0)
|
||||
|
||||
def test_assertRaises(self):
|
||||
|
|
@ -2419,7 +2790,7 @@ class Test_Assertions(TestCase):
|
|||
self.assertRaises(KeyError, _raise, KeyError("key"))
|
||||
try:
|
||||
self.assertRaises(KeyError, lambda: None)
|
||||
except AssertionError as e:
|
||||
except self.failureException as e:
|
||||
self.assert_("KeyError not raised" in str(e), str(e))
|
||||
else:
|
||||
self.fail("assertRaises() didn't fail")
|
||||
|
|
@ -2436,7 +2807,7 @@ class Test_Assertions(TestCase):
|
|||
try:
|
||||
with self.assertRaises(KeyError):
|
||||
pass
|
||||
except AssertionError as e:
|
||||
except self.failureException as e:
|
||||
self.assert_("KeyError not raised" in str(e), str(e))
|
||||
else:
|
||||
self.fail("assertRaises() didn't fail")
|
||||
|
|
@ -2449,6 +2820,172 @@ class Test_Assertions(TestCase):
|
|||
self.fail("assertRaises() didn't let exception pass through")
|
||||
|
||||
|
||||
class TestLongMessage(TestCase):
|
||||
"""Test that the individual asserts honour longMessage.
|
||||
This actually tests all the message behaviour for
|
||||
asserts that use longMessage."""
|
||||
|
||||
def setUp(self):
|
||||
class TestableTestFalse(TestCase):
|
||||
longMessage = False
|
||||
failureException = self.failureException
|
||||
|
||||
def testTest(self):
|
||||
pass
|
||||
|
||||
class TestableTestTrue(TestCase):
|
||||
longMessage = True
|
||||
failureException = self.failureException
|
||||
|
||||
def testTest(self):
|
||||
pass
|
||||
|
||||
self.testableTrue = TestableTestTrue('testTest')
|
||||
self.testableFalse = TestableTestFalse('testTest')
|
||||
|
||||
def testDefault(self):
|
||||
self.assertFalse(TestCase.longMessage)
|
||||
|
||||
def test_formatMsg(self):
|
||||
self.assertEquals(self.testableFalse._formatMessage(None, "foo"), "foo")
|
||||
self.assertEquals(self.testableFalse._formatMessage("foo", "bar"), "foo")
|
||||
|
||||
self.assertEquals(self.testableTrue._formatMessage(None, "foo"), "foo")
|
||||
self.assertEquals(self.testableTrue._formatMessage("foo", "bar"), "bar : foo")
|
||||
|
||||
def assertMessages(self, methodName, args, errors):
|
||||
def getMethod(i):
|
||||
useTestableFalse = i < 2
|
||||
if useTestableFalse:
|
||||
test = self.testableFalse
|
||||
else:
|
||||
test = self.testableTrue
|
||||
return getattr(test, methodName)
|
||||
|
||||
for i, expected_regexp in enumerate(errors):
|
||||
testMethod = getMethod(i)
|
||||
kwargs = {}
|
||||
withMsg = i % 2
|
||||
if withMsg:
|
||||
kwargs = {"msg": "oops"}
|
||||
|
||||
with self.assertRaisesRegexp(self.failureException,
|
||||
expected_regexp=expected_regexp):
|
||||
testMethod(*args, **kwargs)
|
||||
|
||||
def testAssertTrue(self):
|
||||
self.assertMessages('assertTrue', (False,),
|
||||
["^False is not True$", "^oops$", "^False is not True$",
|
||||
"^False is not True : oops$"])
|
||||
|
||||
def testAssertFalse(self):
|
||||
self.assertMessages('assertFalse', (True,),
|
||||
["^True is not False$", "^oops$", "^True is not False$",
|
||||
"^True is not False : oops$"])
|
||||
|
||||
def testNotEqual(self):
|
||||
self.assertMessages('assertNotEqual', (1, 1),
|
||||
["^1 == 1$", "^oops$", "^1 == 1$",
|
||||
"^1 == 1 : oops$"])
|
||||
|
||||
def testAlmostEqual(self):
|
||||
self.assertMessages('assertAlmostEqual', (1, 2),
|
||||
["^1 != 2 within 7 places$", "^oops$",
|
||||
"^1 != 2 within 7 places$", "^1 != 2 within 7 places : oops$"])
|
||||
|
||||
def testNotAlmostEqual(self):
|
||||
self.assertMessages('assertNotAlmostEqual', (1, 1),
|
||||
["^1 == 1 within 7 places$", "^oops$",
|
||||
"^1 == 1 within 7 places$", "^1 == 1 within 7 places : oops$"])
|
||||
|
||||
def test_baseAssertEqual(self):
|
||||
self.assertMessages('_baseAssertEqual', (1, 2),
|
||||
["^1 != 2$", "^oops$", "^1 != 2$", "^1 != 2 : oops$"])
|
||||
|
||||
def testAssertSequenceEqual(self):
|
||||
# Error messages are multiline so not testing on full message
|
||||
# assertTupleEqual and assertListEqual delegate to this method
|
||||
self.assertMessages('assertSequenceEqual', ([], [None]),
|
||||
["\+ \[None\]$", "^oops$", r"\+ \[None\]$",
|
||||
r"\+ \[None\] : oops$"])
|
||||
|
||||
def testAssertSetEqual(self):
|
||||
self.assertMessages('assertSetEqual', (set(), set([None])),
|
||||
["None$", "^oops$", "None$",
|
||||
"None : oops$"])
|
||||
|
||||
def testAssertIn(self):
|
||||
self.assertMessages('assertIn', (None, []),
|
||||
['^None not found in \[\]$', "^oops$",
|
||||
'^None not found in \[\]$',
|
||||
'^None not found in \[\] : oops$'])
|
||||
|
||||
def testAssertNotIn(self):
|
||||
self.assertMessages('assertNotIn', (None, [None]),
|
||||
['^None unexpectedly found in \[None\]$', "^oops$",
|
||||
'^None unexpectedly found in \[None\]$',
|
||||
'^None unexpectedly found in \[None\] : oops$'])
|
||||
|
||||
def testAssertDictEqual(self):
|
||||
self.assertMessages('assertDictEqual', ({}, {'key': 'value'}),
|
||||
[r"\+ \{'key': 'value'\}$", "^oops$",
|
||||
"\+ \{'key': 'value'\}$",
|
||||
"\+ \{'key': 'value'\} : oops$"])
|
||||
|
||||
def testAssertDictContainsSubset(self):
|
||||
self.assertMessages('assertDictContainsSubset', ({'key': 'value'}, {}),
|
||||
["^Missing: 'key'$", "^oops$",
|
||||
"^Missing: 'key'$",
|
||||
"^Missing: 'key' : oops$"])
|
||||
|
||||
def testAssertSameElements(self):
|
||||
self.assertMessages('assertSameElements', ([], [None]),
|
||||
[r"\[None\]$", "^oops$",
|
||||
r"\[None\]$",
|
||||
r"\[None\] : oops$"])
|
||||
|
||||
def testAssertMultiLineEqual(self):
|
||||
self.assertMessages('assertMultiLineEqual', ("", "foo"),
|
||||
[r"\+ foo$", "^oops$",
|
||||
r"\+ foo$",
|
||||
r"\+ foo : oops$"])
|
||||
|
||||
def testAssertLess(self):
|
||||
self.assertMessages('assertLess', (2, 1),
|
||||
["^2 not less than 1$", "^oops$",
|
||||
"^2 not less than 1$", "^2 not less than 1 : oops$"])
|
||||
|
||||
def testAssertLessEqual(self):
|
||||
self.assertMessages('assertLessEqual', (2, 1),
|
||||
["^2 not less than or equal to 1$", "^oops$",
|
||||
"^2 not less than or equal to 1$",
|
||||
"^2 not less than or equal to 1 : oops$"])
|
||||
|
||||
def testAssertGreater(self):
|
||||
self.assertMessages('assertGreater', (1, 2),
|
||||
["^1 not greater than 2$", "^oops$",
|
||||
"^1 not greater than 2$",
|
||||
"^1 not greater than 2 : oops$"])
|
||||
|
||||
def testAssertGreaterEqual(self):
|
||||
self.assertMessages('assertGreaterEqual', (1, 2),
|
||||
["^1 not greater than or equal to 2$", "^oops$",
|
||||
"^1 not greater than or equal to 2$",
|
||||
"^1 not greater than or equal to 2 : oops$"])
|
||||
|
||||
def testAssertIsNone(self):
|
||||
self.assertMessages('assertIsNone', ('not None',),
|
||||
["^'not None' is not None$", "^oops$",
|
||||
"^'not None' is not None$",
|
||||
"^'not None' is not None : oops$"])
|
||||
|
||||
def testAssertIsNotNone(self):
|
||||
self.assertMessages('assertIsNotNone', (None,),
|
||||
["^unexpectedly None$", "^oops$",
|
||||
"^unexpectedly None$",
|
||||
"^unexpectedly None : oops$"])
|
||||
|
||||
|
||||
######################################################################
|
||||
## Main
|
||||
######################################################################
|
||||
|
|
@ -2456,7 +2993,7 @@ class Test_Assertions(TestCase):
|
|||
def test_main():
|
||||
support.run_unittest(Test_TestCase, Test_TestLoader,
|
||||
Test_TestSuite, Test_TestResult, Test_FunctionTestCase,
|
||||
Test_TestSkipping, Test_Assertions)
|
||||
Test_TestSkipping, Test_Assertions, TestLongMessage)
|
||||
|
||||
if __name__ == "__main__":
|
||||
test_main()
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue