test_case.py

importcontextlib
importdifflib
importpprint
importpickle
importre
importsys
importlogging
importwarnings
importweakref
importinspect
importtypes

fromcopyimportdeepcopy
fromtestimportsupport

importunittest

fromtest.test_unittest.supportimport (
TestEquality, TestHashing, LoggingResult, LegacyLoggingResult,
ResultWithNoStartTestRunStopTestRun
)
fromtest.supportimportcaptured_stderr, gc_collect


log_foo=logging.getLogger('foo')
log_foobar=logging.getLogger('foo.bar')
log_quux=logging.getLogger('quux')


classTest(object):
"Keep these TestCase classes out of the main namespace"

classFoo(unittest.TestCase):
defrunTest(self): pass
deftest1(self): pass

classBar(Foo):
deftest2(self): pass

classLoggingTestCase(unittest.TestCase):
"""A test case which logs its calls."""

def__init__(self, events):
super(Test.LoggingTestCase, self).__init__('test')
self.events=events

defsetUp(self):
self.events.append('setUp')

deftest(self):
self.events.append('test')

deftearDown(self):
self.events.append('tearDown')


classTest_TestCase(unittest.TestCase, TestEquality, TestHashing):

### Set up attributes used by inherited tests
################################################################

# Used by TestHashing.test_hash and TestEquality.test_eq
eq_pairs= [(Test.Foo('test1'), Test.Foo('test1'))]

# Used by TestEquality.test_ne
ne_pairs= [(Test.Foo('test1'), Test.Foo('runTest')),
 (Test.Foo('test1'), Test.Bar('test1')),
 (Test.Foo('test1'), Test.Bar('test2'))]

################################################################
### /Set up attributes used by inherited tests


# "class TestCase([methodName])"
# ...
# "Each instance of TestCase will run a single test method: the
# method named methodName."
# ...
# "methodName defaults to "runTest"."
#
# Make sure it really is optional, and that it defaults to the proper
# thing.
deftest_init__no_test_name(self):
classTest(unittest.TestCase):
defrunTest(self): raiseMyException()
deftest(self): pass

self.assertEqual(Test().id()[-13:], '.Test.runTest')

# test that TestCase can be instantiated with no args
# primarily for use at the interactive interpreter
test=unittest.TestCase()
test.assertEqual(3, 3)
withtest.assertRaises(test.failureException):
test.assertEqual(3, 2)

withself.assertRaises(AttributeError):
test.run()

# "class TestCase([methodName])"
# ...
# "Each instance of TestCase will run a single test method: the
# method named methodName."
deftest_init__test_name__valid(self):
classTest(unittest.TestCase):
defrunTest(self): raiseMyException()
deftest(self): pass

self.assertEqual(Test('test').id()[-10:], '.Test.test')

# "class TestCase([methodName])"
# ...
# "Each instance of TestCase will run a single test method: the
# method named methodName."
deftest_init__test_name__invalid(self):
classTest(unittest.TestCase):
defrunTest(self): raiseMyException()
deftest(self): pass

try:
Test('testfoo')
exceptValueError:
pass
else:
self.fail("Failed to raise ValueError")

# "Return the number of tests represented by the this test object. For
# TestCase instances, this will always be 1"
deftest_countTestCases(self):
classFoo(unittest.TestCase):
deftest(self): pass

self.assertEqual(Foo('test').countTestCases(), 1)

# "Return the default type of test result object to be used to run this
# test. For TestCase instances, this will always be
# unittest.TestResult; subclasses of TestCase should
# override this as necessary."
deftest_defaultTestResult(self):
classFoo(unittest.TestCase):
defrunTest(self):
pass

result=Foo().defaultTestResult()
self.assertEqual(type(result), unittest.TestResult)

# "When a setUp() method is defined, the test runner will run that method
# prior to each test. Likewise, if a tearDown() method is defined, the
# test runner will invoke that method after each test. In the example,
# setUp() was used to create a fresh sequence for each test."
#
# Make sure the proper call order is maintained, even if setUp() raises
# an exception.
deftest_run_call_order__error_in_setUp(self):
events= []
result=LoggingResult(events)

classFoo(Test.LoggingTestCase):
defsetUp(self):
super(Foo, self).setUp()
raiseRuntimeError('raised by Foo.setUp')

Foo(events).run(result)
expected= ['startTest', 'setUp', 'addError', 'stopTest']
self.assertEqual(events, expected)

# "With a temporary result stopTestRun is called when setUp errors.
deftest_run_call_order__error_in_setUp_default_result(self):
events= []

classFoo(Test.LoggingTestCase):
defdefaultTestResult(self):
returnLoggingResult(self.events)

defsetUp(self):
super(Foo, self).setUp()
raiseRuntimeError('raised by Foo.setUp')

Foo(events).run()
expected= ['startTestRun', 'startTest', 'setUp', 'addError',
'stopTest', 'stopTestRun']
self.assertEqual(events, expected)

# "When a setUp() method is defined, the test runner will run that method
# prior to each test. Likewise, if a tearDown() method is defined, the
# test runner will invoke that method after each test. In the example,
# setUp() was used to create a fresh sequence for each test."
#
# Make sure the proper call order is maintained, even if the test raises
# an error (as opposed to a failure).
deftest_run_call_order__error_in_test(self):
events= []
result=LoggingResult(events)

classFoo(Test.LoggingTestCase):
deftest(self):
super(Foo, self).test()
raiseRuntimeError('raised by Foo.test')

expected= ['startTest', 'setUp', 'test',
'addError', 'tearDown', 'stopTest']
Foo(events).run(result)
self.assertEqual(events, expected)

# "With a default result, an error in the test still results in stopTestRun
# being called."
deftest_run_call_order__error_in_test_default_result(self):
events= []

classFoo(Test.LoggingTestCase):
defdefaultTestResult(self):
returnLoggingResult(self.events)

deftest(self):
super(Foo, self).test()
raiseRuntimeError('raised by Foo.test')

expected= ['startTestRun', 'startTest', 'setUp', 'test',
'addError', 'tearDown', 'stopTest', 'stopTestRun']
Foo(events).run()
self.assertEqual(events, expected)

# "When a setUp() method is defined, the test runner will run that method
# prior to each test. Likewise, if a tearDown() method is defined, the
# test runner will invoke that method after each test. In the example,
# setUp() was used to create a fresh sequence for each test."
#
# Make sure the proper call order is maintained, even if the test signals
# a failure (as opposed to an error).
deftest_run_call_order__failure_in_test(self):
events= []
result=LoggingResult(events)

classFoo(Test.LoggingTestCase):
deftest(self):
super(Foo, self).test()
self.fail('raised by Foo.test')

expected= ['startTest', 'setUp', 'test',
'addFailure', 'tearDown', 'stopTest']
Foo(events).run(result)
self.assertEqual(events, expected)

# "When a test fails with a default result stopTestRun is still called."
deftest_run_call_order__failure_in_test_default_result(self):

classFoo(Test.LoggingTestCase):
defdefaultTestResult(self):
returnLoggingResult(self.events)
deftest(self):
super(Foo, self).test()
self.fail('raised by Foo.test')

expected= ['startTestRun', 'startTest', 'setUp', 'test',
'addFailure', 'tearDown', 'stopTest', 'stopTestRun']
events= []
Foo(events).run()
self.assertEqual(events, expected)

# "When a setUp() method is defined, the test runner will run that method
# prior to each test. Likewise, if a tearDown() method is defined, the
# test runner will invoke that method after each test. In the example,
# setUp() was used to create a fresh sequence for each test."
#
# Make sure the proper call order is maintained, even if tearDown() raises
# an exception.
deftest_run_call_order__error_in_tearDown(self):
events= []
result=LoggingResult(events)

classFoo(Test.LoggingTestCase):
deftearDown(self):
super(Foo, self).tearDown()
raiseRuntimeError('raised by Foo.tearDown')

Foo(events).run(result)
expected= ['startTest', 'setUp', 'test', 'tearDown', 'addError',
'stopTest']
self.assertEqual(events, expected)

# "When tearDown errors with a default result stopTestRun is still called."
deftest_run_call_order__error_in_tearDown_default_result(self):

classFoo(Test.LoggingTestCase):
defdefaultTestResult(self):
returnLoggingResult(self.events)
deftearDown(self):
super(Foo, self).tearDown()
raiseRuntimeError('raised by Foo.tearDown')

events= []
Foo(events).run()
expected= ['startTestRun', 'startTest', 'setUp', 'test', 'tearDown',
'addError', 'stopTest', 'stopTestRun']
self.assertEqual(events, expected)

# "TestCase.run() still works when the defaultTestResult is a TestResult
# that does not support startTestRun and stopTestRun.
deftest_run_call_order_default_result(self):

classFoo(unittest.TestCase):
defdefaultTestResult(self):
returnResultWithNoStartTestRunStopTestRun()
deftest(self):
pass

withself.assertWarns(RuntimeWarning):
Foo('test').run()

deftest_deprecation_of_return_val_from_test(self):
# Issue 41322 - deprecate return of value that is not None from a test
classNothing:
def__eq__(self, o):
returnoisNone
classFoo(unittest.TestCase):
deftest1(self):
return1
deftest2(self):
yield1
deftest3(self):
returnNothing()

withself.assertWarns(DeprecationWarning) asw:
Foo('test1').run()
self.assertIn('It is deprecated to return a value that is not None', str(w.warning))
self.assertIn('test1', str(w.warning))
self.assertEqual(w.filename, __file__)

withself.assertWarns(DeprecationWarning) asw:
Foo('test2').run()
self.assertIn('It is deprecated to return a value that is not None', str(w.warning))
self.assertIn('test2', str(w.warning))
self.assertEqual(w.filename, __file__)

withself.assertWarns(DeprecationWarning) asw:
Foo('test3').run()
self.assertIn('It is deprecated to return a value that is not None', str(w.warning))
self.assertIn('test3', str(w.warning))
self.assertEqual(w.filename, __file__)

def_check_call_order__subtests(self, result, events, expected_events):
classFoo(Test.LoggingTestCase):
deftest(self):
super(Foo, self).test()
foriin [1, 2, 3]:
withself.subTest(i=i):
ifi==1:
self.fail('failure')
forjin [2, 3]:
withself.subTest(j=j):
ifi*j==6:
raiseRuntimeError('raised by Foo.test')
1/0

# Order is the following:
# i=1 => subtest failure
# i=2, j=2 => subtest success
# i=2, j=3 => subtest error
# i=3, j=2 => subtest error
# i=3, j=3 => subtest success
# toplevel => error
Foo(events).run(result)
self.assertEqual(events, expected_events)

deftest_run_call_order__subtests(self):
events= []
result=LoggingResult(events)
expected= ['startTest', 'setUp', 'test',
'addSubTestFailure', 'addSubTestSuccess',
'addSubTestFailure', 'addSubTestFailure',
'addSubTestSuccess', 'addError', 'tearDown', 'stopTest']
self._check_call_order__subtests(result, events, expected)

deftest_run_call_order__subtests_legacy(self):
# With a legacy result object (without an addSubTest method),
# text execution stops after the first subtest failure.
events= []
result=LegacyLoggingResult(events)
expected= ['startTest', 'setUp', 'test',
'addFailure', 'tearDown', 'stopTest']
self._check_call_order__subtests(result, events, expected)

def_check_call_order__subtests_success(self, result, events, expected_events):
classFoo(Test.LoggingTestCase):
deftest(self):
super(Foo, self).test()
foriin [1, 2]:
withself.subTest(i=i):
forjin [2, 3]:
withself.subTest(j=j):
pass

Foo(events).run(result)
self.assertEqual(events, expected_events)

deftest_run_call_order__subtests_success(self):
events= []
result=LoggingResult(events)
# The 6 subtest successes are individually recorded, in addition
# to the whole test success.
expected= (['startTest', 'setUp', 'test']
+6* ['addSubTestSuccess']
+ ['tearDown', 'addSuccess', 'stopTest'])
self._check_call_order__subtests_success(result, events, expected)

deftest_run_call_order__subtests_success_legacy(self):
# With a legacy result, only the whole test success is recorded.
events= []
result=LegacyLoggingResult(events)
expected= ['startTest', 'setUp', 'test', 'tearDown',
'addSuccess', 'stopTest']
self._check_call_order__subtests_success(result, events, expected)

deftest_run_call_order__subtests_failfast(self):
events= []
result=LoggingResult(events)
result.failfast=True

classFoo(Test.LoggingTestCase):
deftest(self):
super(Foo, self).test()
withself.subTest(i=1):
self.fail('failure')
withself.subTest(i=2):
self.fail('failure')
self.fail('failure')

expected= ['startTest', 'setUp', 'test',
'addSubTestFailure', 'tearDown', 'stopTest']
Foo(events).run(result)
self.assertEqual(events, expected)

deftest_subtests_failfast(self):
# Ensure proper test flow with subtests and failfast (issue #22894)
events= []

classFoo(unittest.TestCase):
deftest_a(self):
withself.subTest():
events.append('a1')
events.append('a2')

deftest_b(self):
withself.subTest():
events.append('b1')
withself.subTest():
self.fail('failure')
events.append('b2')

deftest_c(self):
events.append('c')

result=unittest.TestResult()
result.failfast=True
suite=unittest.TestLoader().loadTestsFromTestCase(Foo)
suite.run(result)

expected= ['a1', 'a2', 'b1']
self.assertEqual(events, expected)

deftest_subtests_debug(self):
# Test debug() with a test that uses subTest() (bpo-34900)
events= []

classFoo(unittest.TestCase):
deftest_a(self):
events.append('test case')
withself.subTest():
events.append('subtest 1')

Foo('test_a').debug()

self.assertEqual(events, ['test case', 'subtest 1'])

# "This class attribute gives the exception raised by the test() method.
# If a test framework needs to use a specialized exception, possibly to
# carry additional information, it must subclass this exception in
# order to ``play fair'' with the framework. The initial value of this
# attribute is AssertionError"
deftest_failureException__default(self):
classFoo(unittest.TestCase):
deftest(self):
pass

self.assertIs(Foo('test').failureException, AssertionError)

# "This class attribute gives the exception raised by the test() method.
# If a test framework needs to use a specialized exception, possibly to
# carry additional information, it must subclass this exception in
# order to ``play fair'' with the framework."
#
# Make sure TestCase.run() respects the designated failureException
deftest_failureException__subclassing__explicit_raise(self):
events= []
result=LoggingResult(events)

classFoo(unittest.TestCase):
deftest(self):
raiseRuntimeError()

failureException=RuntimeError

self.assertIs(Foo('test').failureException, RuntimeError)


Foo('test').run(result)
expected= ['startTest', 'addFailure', 'stopTest']
self.assertEqual(events, expected)

# "This class attribute gives the exception raised by the test() method.
# If a test framework needs to use a specialized exception, possibly to
# carry additional information, it must subclass this exception in
# order to ``play fair'' with the framework."
#
# Make sure TestCase.run() respects the designated failureException
deftest_failureException__subclassing__implicit_raise(self):
events= []
result=LoggingResult(events)

classFoo(unittest.TestCase):
deftest(self):
self.fail("foo")

failureException=RuntimeError

self.assertIs(Foo('test').failureException, RuntimeError)


Foo('test').run(result)
expected= ['startTest', 'addFailure', 'stopTest']
self.assertEqual(events, expected)

# "The default implementation does nothing."
deftest_setUp(self):
classFoo(unittest.TestCase):
defrunTest(self):
pass

# ... and nothing should happen
Foo().setUp()

# "The default implementation does nothing."
deftest_tearDown(self):
classFoo(unittest.TestCase):
defrunTest(self):
pass

# ... and nothing should happen
Foo().tearDown()

# "Return a string identifying the specific test case."
#
# Because of the vague nature of the docs, I'm not going to lock this
# test down too much. Really all that can be asserted is that the id()
# will be a string (either 8-byte or unicode -- again, because the docs
# just say "string")
deftest_id(self):
classFoo(unittest.TestCase):
defrunTest(self):
pass

self.assertIsInstance(Foo().id(), str)


# "If result is omitted or None, a temporary result object is created,
# used, and is made available to the caller. As TestCase owns the
# temporary result startTestRun and stopTestRun are called.

deftest_run__uses_defaultTestResult(self):
events= []
defaultResult=LoggingResult(events)

classFoo(unittest.TestCase):
deftest(self):
events.append('test')

defdefaultTestResult(self):
returndefaultResult

# Make run() find a result object on its own
result=Foo('test').run()

self.assertIs(result, defaultResult)
expected= ['startTestRun', 'startTest', 'test', 'addSuccess',
'stopTest', 'stopTestRun']
self.assertEqual(events, expected)


# "The result object is returned to run's caller"
deftest_run__returns_given_result(self):

classFoo(unittest.TestCase):
deftest(self):
pass

result=unittest.TestResult()

retval=Foo('test').run(result)
self.assertIs(retval, result)


# "The same effect [as method run] may be had by simply calling the
# TestCase instance."
deftest_call__invoking_an_instance_delegates_to_run(self):
resultIn=unittest.TestResult()
resultOut=unittest.TestResult()

classFoo(unittest.TestCase):
deftest(self):
pass

defrun(self, result):
self.assertIs(result, resultIn)
returnresultOut

retval=Foo('test')(resultIn)

self.assertIs(retval, resultOut)


deftestShortDescriptionWithoutDocstring(self):
self.assertIsNone(self.shortDescription())

@unittest.skipIf(sys.flags.optimize>=2,
"Docstrings are omitted with -O2 and above")
deftestShortDescriptionWithOneLineDocstring(self):
"""Tests shortDescription() for a method with a docstring."""
self.assertEqual(
self.shortDescription(),
'Tests shortDescription() for a method with a docstring.')

@unittest.skipIf(sys.flags.optimize>=2,
"Docstrings are omitted with -O2 and above")
deftestShortDescriptionWithMultiLineDocstring(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(),
'Tests shortDescription() for a method with a longer '
'docstring.')

@unittest.skipIf(sys.flags.optimize>=2,
"Docstrings are omitted with -O2 and above")
deftestShortDescriptionWhitespaceTrimming(self):
"""
 Tests shortDescription() whitespace is trimmed, so that the first
 line of nonwhite-space text becomes the docstring.
 """
self.assertEqual(
self.shortDescription(),
'Tests shortDescription() whitespace is trimmed, so that the first')

deftestAddTypeEqualityFunc(self):
classSadSnake(object):
"""Dummy class for test_addTypeEqualityFunc."""
s1, s2=SadSnake(), SadSnake()
self.assertFalse(s1==s2)
defAllSnakesCreatedEqual(a, b, msg=None):
returntype(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 it's local nothing else
# will ever notice that.

deftestAssertIs(self):
thing=object()
self.assertIs(thing, thing)
self.assertRaises(self.failureException, self.assertIs, thing, object())

deftestAssertIsNot(self):
thing=object()
self.assertIsNot(thing, object())
self.assertRaises(self.failureException, self.assertIsNot, thing, thing)

deftestAssertIsInstance(self):
thing= []
self.assertIsInstance(thing, list)
self.assertRaises(self.failureException, self.assertIsInstance,
thing, dict)

deftestAssertNotIsInstance(self):
thing= []
self.assertNotIsInstance(thing, dict)
self.assertRaises(self.failureException, self.assertNotIsInstance,
thing, list)

deftestAssertIn(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)

deftestAssertEqual(self):
equal_pairs= [
 ((), ()),
 ({}, {}),
 ([], []),
 (set(), set()),
 (frozenset(), frozenset())]
fora, binequal_pairs:
# This mess of try excepts is to test the assertEqual behavior
# itself.
try:
self.assertEqual(a, b)
exceptself.failureException:
self.fail('assertEqual(%r, %r) failed'% (a, b))
try:
self.assertEqual(a, b, msg='foo')
exceptself.failureException:
self.fail('assertEqual(%r, %r) with msg= failed'% (a, b))
try:
self.assertEqual(a, b, 'foo')
exceptself.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]))]
fora, binunequal_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')

deftestEquality(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)

deftestAssertSequenceEqualMaxDiff(self):
self.assertEqual(self.maxDiff, 80*8)
seq1='a'+'x'*80**2
seq2='b'+'x'*80**2
diff='\n'.join(difflib.ndiff(pprint.pformat(seq1).splitlines(),
pprint.pformat(seq2).splitlines()))
# the +1 is the leading \n added by assertSequenceEqual
omitted=unittest.case.DIFF_OMITTED% (len(diff) +1,)

self.maxDiff=len(diff)//2
try:

self.assertSequenceEqual(seq1, seq2)
exceptself.failureExceptionase:
msg=e.args[0]
else:
self.fail('assertSequenceEqual did not fail.')
self.assertLess(len(msg), len(diff))
self.assertIn(omitted, msg)

self.maxDiff=len(diff) *2
try:
self.assertSequenceEqual(seq1, seq2)
exceptself.failureExceptionase:
msg=e.args[0]
else:
self.fail('assertSequenceEqual did not fail.')
self.assertGreater(len(msg), len(diff))
self.assertNotIn(omitted, msg)

self.maxDiff=None
try:
self.assertSequenceEqual(seq1, seq2)
exceptself.failureExceptionase:
msg=e.args[0]
else:
self.fail('assertSequenceEqual did not fail.')
self.assertGreater(len(msg), len(diff))
self.assertNotIn(omitted, msg)

deftestTruncateMessage(self):
self.maxDiff=1
message=self._truncateMessage('foo', 'bar')
omitted=unittest.case.DIFF_OMITTED%len('bar')
self.assertEqual(message, 'foo'+omitted)

self.maxDiff=None
message=self._truncateMessage('foo', 'bar')
self.assertEqual(message, 'foobar')

self.maxDiff=4
message=self._truncateMessage('foo', 'bar')
self.assertEqual(message, 'foobar')

deftestAssertDictEqualTruncates(self):
test=unittest.TestCase('assertEqual')
deftruncate(msg, diff):
return'foo'
test._truncateMessage=truncate
try:
test.assertDictEqual({}, {1: 0})
exceptself.failureExceptionase:
self.assertEqual(str(e), 'foo')
else:
self.fail('assertDictEqual did not fail')

deftestAssertMultiLineEqualTruncates(self):
test=unittest.TestCase('assertEqual')
deftruncate(msg, diff):
return'foo'
test._truncateMessage=truncate
try:
test.assertMultiLineEqual('foo', 'bar')
exceptself.failureExceptionase:
self.assertEqual(str(e), 'foo')
else:
self.fail('assertMultiLineEqual did not fail')

deftestAssertEqual_diffThreshold(self):
# check threshold value
self.assertEqual(self._diffThreshold, 2**16)
# disable madDiff to get diff markers
self.maxDiff=None

# set a lower threshold value and add a cleanup to restore it
old_threshold=self._diffThreshold
self._diffThreshold=2**5
self.addCleanup(lambda: setattr(self, '_diffThreshold', old_threshold))

# under the threshold: diff marker (^) in error message
s='x'* (2**4)
withself.assertRaises(self.failureException) ascm:
self.assertEqual(s+'a', s+'b')
self.assertIn('^', str(cm.exception))
self.assertEqual(s+'a', s+'a')

# over the threshold: diff not used and marker (^) not in error message
s='x'* (2**6)
# if the path that uses difflib is taken, _truncateMessage will be
# called -- replace it with explodingTruncation to verify that this
# doesn't happen
defexplodingTruncation(message, diff):
raiseSystemError('this should not be raised')
old_truncate=self._truncateMessage
self._truncateMessage=explodingTruncation
self.addCleanup(lambda: setattr(self, '_truncateMessage', old_truncate))

s1, s2=s+'a', s+'b'
withself.assertRaises(self.failureException) ascm:
self.assertEqual(s1, s2)
self.assertNotIn('^', str(cm.exception))
self.assertEqual(str(cm.exception), '%r != %r'% (s1, s2))
self.assertEqual(s+'a', s+'a')

deftestAssertEqual_shorten(self):
# set a lower threshold value and add a cleanup to restore it
old_threshold=self._diffThreshold
self._diffThreshold=0
self.addCleanup(lambda: setattr(self, '_diffThreshold', old_threshold))

s='x'*100
s1, s2=s+'a', s+'b'
withself.assertRaises(self.failureException) ascm:
self.assertEqual(s1, s2)
c='xxxx[35 chars]'+'x'*61
self.assertEqual(str(cm.exception), "'%sa' != '%sb'"% (c, c))
self.assertEqual(s+'a', s+'a')

p='y'*50
s1, s2=s+'a'+p, s+'b'+p
withself.assertRaises(self.failureException) ascm:
self.assertEqual(s1, s2)
c='xxxx[85 chars]xxxxxxxxxxx'
self.assertEqual(str(cm.exception), "'%sa%s' != '%sb%s'"% (c, p, c, p))

p='y'*100
s1, s2=s+'a'+p, s+'b'+p
withself.assertRaises(self.failureException) ascm:
self.assertEqual(s1, s2)
c='xxxx[91 chars]xxxxx'
d='y'*40+'[56 chars]yyyy'
self.assertEqual(str(cm.exception), "'%sa%s' != '%sb%s'"% (c, d, c, d))

deftestAssertCountEqual(self):
a=object()
self.assertCountEqual([1, 2, 3], [3, 2, 1])
self.assertCountEqual(['foo', 'bar', 'baz'], ['bar', 'baz', 'foo'])
self.assertCountEqual([a, a, 2, 2, 3], (a, 2, 3, a, 2))
self.assertCountEqual([1, "2", "a", "a"], ["a", "2", True, "a"])
self.assertRaises(self.failureException, self.assertCountEqual,
 [1, 2] + [3] *100, [1] *100+ [2, 3])
self.assertRaises(self.failureException, self.assertCountEqual,
 [1, "2", "a", "a"], ["a", "2", True, 1])
self.assertRaises(self.failureException, self.assertCountEqual,
 [10], [10, 11])
self.assertRaises(self.failureException, self.assertCountEqual,
 [10, 11], [10])
self.assertRaises(self.failureException, self.assertCountEqual,
 [10, 11, 10], [10, 11])

# Test that sequences of unhashable objects can be tested for sameness:
self.assertCountEqual([[1, 2], [3, 4], 0], [False, [3, 4], [1, 2]])
# Test that iterator of unhashable objects can be tested for sameness:
self.assertCountEqual(iter([1, 2, [], 3, 4]),
iter([1, 2, [], 3, 4]))

# hashable types, but not orderable
self.assertRaises(self.failureException, self.assertCountEqual,
 [], [divmod, 'x', 1, 5j, 2j, frozenset()])
# comparing dicts
self.assertCountEqual([{'a': 1}, {'b': 2}], [{'b': 2}, {'a': 1}])
# comparing heterogeneous non-hashable sequences
self.assertCountEqual([1, 'x', divmod, []], [divmod, [], 'x', 1])
self.assertRaises(self.failureException, self.assertCountEqual,
 [], [divmod, [], 'x', 1, 5j, 2j, set()])
self.assertRaises(self.failureException, self.assertCountEqual,
 [[1]], [[2]])

# Same elements, but not same sequence length
self.assertRaises(self.failureException, self.assertCountEqual,
 [1, 1, 2], [2, 1])
self.assertRaises(self.failureException, self.assertCountEqual,
 [1, 1, "2", "a", "a"], ["2", "2", True, "a"])
self.assertRaises(self.failureException, self.assertCountEqual,
 [1, {'b': 2}, None, True], [{'b': 2}, True, None])

# Same elements which don't reliably compare, in
# different order, see issue 10242
a= [{2,4}, {1,2}]
b=a[::-1]
self.assertCountEqual(a, b)

# test utility functions supporting assertCountEqual()

diffs=set(unittest.util._count_diff_all_purpose('aaabccd', 'abbbcce'))
expected= {(3,1,'a'), (1,3,'b'), (1,0,'d'), (0,1,'e')}
self.assertEqual(diffs, expected)

diffs=unittest.util._count_diff_all_purpose([[]], [])