1import difflib
2import pprint
3import pickle
4import re
5import sys
6
7from copy import deepcopy
8from test import test_support
9
10import unittest
11
12from .support import (
13    TestEquality, TestHashing, LoggingResult, ResultWithNoStartTestRunStopTestRun
14)
15
16
17class Test(object):
18    "Keep these TestCase classes out of the main namespace"
19
20    class Foo(unittest.TestCase):
21        def runTest(self): pass
22        def test1(self): pass
23
24    class Bar(Foo):
25        def test2(self): pass
26
27    class LoggingTestCase(unittest.TestCase):
28        """A test case which logs its calls."""
29
30        def __init__(self, events):
31            super(Test.LoggingTestCase, self).__init__('test')
32            self.events = events
33
34        def setUp(self):
35            self.events.append('setUp')
36
37        def test(self):
38            self.events.append('test')
39
40        def tearDown(self):
41            self.events.append('tearDown')
42
43
44class Test_TestCase(unittest.TestCase, TestEquality, TestHashing):
45
46    ### Set up attributes used by inherited tests
47    ################################################################
48
49    # Used by TestHashing.test_hash and TestEquality.test_eq
50    eq_pairs = [(Test.Foo('test1'), Test.Foo('test1'))]
51
52    # Used by TestEquality.test_ne
53    ne_pairs = [(Test.Foo('test1'), Test.Foo('runTest'))
54               ,(Test.Foo('test1'), Test.Bar('test1'))
55               ,(Test.Foo('test1'), Test.Bar('test2'))]
56
57    ################################################################
58    ### /Set up attributes used by inherited tests
59
60
61    # "class TestCase([methodName])"
62    # ...
63    # "Each instance of TestCase will run a single test method: the
64    # method named methodName."
65    # ...
66    # "methodName defaults to "runTest"."
67    #
68    # Make sure it really is optional, and that it defaults to the proper
69    # thing.
70    def test_init__no_test_name(self):
71        class Test(unittest.TestCase):
72            def runTest(self): raise TypeError()
73            def test(self): pass
74
75        self.assertEqual(Test().id()[-13:], '.Test.runTest')
76
77    # "class TestCase([methodName])"
78    # ...
79    # "Each instance of TestCase will run a single test method: the
80    # method named methodName."
81    def test_init__test_name__valid(self):
82        class Test(unittest.TestCase):
83            def runTest(self): raise TypeError()
84            def test(self): pass
85
86        self.assertEqual(Test('test').id()[-10:], '.Test.test')
87
88    # "class TestCase([methodName])"
89    # ...
90    # "Each instance of TestCase will run a single test method: the
91    # method named methodName."
92    def test_init__test_name__invalid(self):
93        class Test(unittest.TestCase):
94            def runTest(self): raise TypeError()
95            def test(self): pass
96
97        try:
98            Test('testfoo')
99        except ValueError:
100            pass
101        else:
102            self.fail("Failed to raise ValueError")
103
104    # "Return the number of tests represented by the this test object. For
105    # TestCase instances, this will always be 1"
106    def test_countTestCases(self):
107        class Foo(unittest.TestCase):
108            def test(self): pass
109
110        self.assertEqual(Foo('test').countTestCases(), 1)
111
112    # "Return the default type of test result object to be used to run this
113    # test. For TestCase instances, this will always be
114    # unittest.TestResult;  subclasses of TestCase should
115    # override this as necessary."
116    def test_defaultTestResult(self):
117        class Foo(unittest.TestCase):
118            def runTest(self):
119                pass
120
121        result = Foo().defaultTestResult()
122        self.assertEqual(type(result), unittest.TestResult)
123
124    # "When a setUp() method is defined, the test runner will run that method
125    # prior to each test. Likewise, if a tearDown() method is defined, the
126    # test runner will invoke that method after each test. In the example,
127    # setUp() was used to create a fresh sequence for each test."
128    #
129    # Make sure the proper call order is maintained, even if setUp() raises
130    # an exception.
131    def test_run_call_order__error_in_setUp(self):
132        events = []
133        result = LoggingResult(events)
134
135        class Foo(Test.LoggingTestCase):
136            def setUp(self):
137                super(Foo, self).setUp()
138                raise RuntimeError('raised by Foo.setUp')
139
140        Foo(events).run(result)
141        expected = ['startTest', 'setUp', 'addError', 'stopTest']
142        self.assertEqual(events, expected)
143
144    # "With a temporary result stopTestRun is called when setUp errors.
145    def test_run_call_order__error_in_setUp_default_result(self):
146        events = []
147
148        class Foo(Test.LoggingTestCase):
149            def defaultTestResult(self):
150                return LoggingResult(self.events)
151
152            def setUp(self):
153                super(Foo, self).setUp()
154                raise RuntimeError('raised by Foo.setUp')
155
156        Foo(events).run()
157        expected = ['startTestRun', 'startTest', 'setUp', 'addError',
158                    'stopTest', 'stopTestRun']
159        self.assertEqual(events, expected)
160
161    # "When a setUp() method is defined, the test runner will run that method
162    # prior to each test. Likewise, if a tearDown() method is defined, the
163    # test runner will invoke that method after each test. In the example,
164    # setUp() was used to create a fresh sequence for each test."
165    #
166    # Make sure the proper call order is maintained, even if the test raises
167    # an error (as opposed to a failure).
168    def test_run_call_order__error_in_test(self):
169        events = []
170        result = LoggingResult(events)
171
172        class Foo(Test.LoggingTestCase):
173            def test(self):
174                super(Foo, self).test()
175                raise RuntimeError('raised by Foo.test')
176
177        expected = ['startTest', 'setUp', 'test', 'addError', 'tearDown',
178                    'stopTest']
179        Foo(events).run(result)
180        self.assertEqual(events, expected)
181
182    # "With a default result, an error in the test still results in stopTestRun
183    # being called."
184    def test_run_call_order__error_in_test_default_result(self):
185        events = []
186
187        class Foo(Test.LoggingTestCase):
188            def defaultTestResult(self):
189                return LoggingResult(self.events)
190
191            def test(self):
192                super(Foo, self).test()
193                raise RuntimeError('raised by Foo.test')
194
195        expected = ['startTestRun', 'startTest', 'setUp', 'test', 'addError',
196                    'tearDown', 'stopTest', 'stopTestRun']
197        Foo(events).run()
198        self.assertEqual(events, expected)
199
200    # "When a setUp() method is defined, the test runner will run that method
201    # prior to each test. Likewise, if a tearDown() method is defined, the
202    # test runner will invoke that method after each test. In the example,
203    # setUp() was used to create a fresh sequence for each test."
204    #
205    # Make sure the proper call order is maintained, even if the test signals
206    # a failure (as opposed to an error).
207    def test_run_call_order__failure_in_test(self):
208        events = []
209        result = LoggingResult(events)
210
211        class Foo(Test.LoggingTestCase):
212            def test(self):
213                super(Foo, self).test()
214                self.fail('raised by Foo.test')
215
216        expected = ['startTest', 'setUp', 'test', 'addFailure', 'tearDown',
217                    'stopTest']
218        Foo(events).run(result)
219        self.assertEqual(events, expected)
220
221    # "When a test fails with a default result stopTestRun is still called."
222    def test_run_call_order__failure_in_test_default_result(self):
223
224        class Foo(Test.LoggingTestCase):
225            def defaultTestResult(self):
226                return LoggingResult(self.events)
227            def test(self):
228                super(Foo, self).test()
229                self.fail('raised by Foo.test')
230
231        expected = ['startTestRun', 'startTest', 'setUp', 'test', 'addFailure',
232                    'tearDown', 'stopTest', 'stopTestRun']
233        events = []
234        Foo(events).run()
235        self.assertEqual(events, expected)
236
237    # "When a setUp() method is defined, the test runner will run that method
238    # prior to each test. Likewise, if a tearDown() method is defined, the
239    # test runner will invoke that method after each test. In the example,
240    # setUp() was used to create a fresh sequence for each test."
241    #
242    # Make sure the proper call order is maintained, even if tearDown() raises
243    # an exception.
244    def test_run_call_order__error_in_tearDown(self):
245        events = []
246        result = LoggingResult(events)
247
248        class Foo(Test.LoggingTestCase):
249            def tearDown(self):
250                super(Foo, self).tearDown()
251                raise RuntimeError('raised by Foo.tearDown')
252
253        Foo(events).run(result)
254        expected = ['startTest', 'setUp', 'test', 'tearDown', 'addError',
255                    'stopTest']
256        self.assertEqual(events, expected)
257
258    # "When tearDown errors with a default result stopTestRun is still called."
259    def test_run_call_order__error_in_tearDown_default_result(self):
260
261        class Foo(Test.LoggingTestCase):
262            def defaultTestResult(self):
263                return LoggingResult(self.events)
264            def tearDown(self):
265                super(Foo, self).tearDown()
266                raise RuntimeError('raised by Foo.tearDown')
267
268        events = []
269        Foo(events).run()
270        expected = ['startTestRun', 'startTest', 'setUp', 'test', 'tearDown',
271                    'addError', 'stopTest', 'stopTestRun']
272        self.assertEqual(events, expected)
273
274    # "TestCase.run() still works when the defaultTestResult is a TestResult
275    # that does not support startTestRun and stopTestRun.
276    def test_run_call_order_default_result(self):
277
278        class Foo(unittest.TestCase):
279            def defaultTestResult(self):
280                return ResultWithNoStartTestRunStopTestRun()
281            def test(self):
282                pass
283
284        Foo('test').run()
285
286    # "This class attribute gives the exception raised by the test() method.
287    # If a test framework needs to use a specialized exception, possibly to
288    # carry additional information, it must subclass this exception in
289    # order to ``play fair'' with the framework.  The initial value of this
290    # attribute is AssertionError"
291    def test_failureException__default(self):
292        class Foo(unittest.TestCase):
293            def test(self):
294                pass
295
296        self.assertTrue(Foo('test').failureException is AssertionError)
297
298    # "This class attribute gives the exception raised by the test() method.
299    # If a test framework needs to use a specialized exception, possibly to
300    # carry additional information, it must subclass this exception in
301    # order to ``play fair'' with the framework."
302    #
303    # Make sure TestCase.run() respects the designated failureException
304    def test_failureException__subclassing__explicit_raise(self):
305        events = []
306        result = LoggingResult(events)
307
308        class Foo(unittest.TestCase):
309            def test(self):
310                raise RuntimeError()
311
312            failureException = RuntimeError
313
314        self.assertTrue(Foo('test').failureException is RuntimeError)
315
316
317        Foo('test').run(result)
318        expected = ['startTest', 'addFailure', 'stopTest']
319        self.assertEqual(events, expected)
320
321    # "This class attribute gives the exception raised by the test() method.
322    # If a test framework needs to use a specialized exception, possibly to
323    # carry additional information, it must subclass this exception in
324    # order to ``play fair'' with the framework."
325    #
326    # Make sure TestCase.run() respects the designated failureException
327    def test_failureException__subclassing__implicit_raise(self):
328        events = []
329        result = LoggingResult(events)
330
331        class Foo(unittest.TestCase):
332            def test(self):
333                self.fail("foo")
334
335            failureException = RuntimeError
336
337        self.assertTrue(Foo('test').failureException is RuntimeError)
338
339
340        Foo('test').run(result)
341        expected = ['startTest', 'addFailure', 'stopTest']
342        self.assertEqual(events, expected)
343
344    # "The default implementation does nothing."
345    def test_setUp(self):
346        class Foo(unittest.TestCase):
347            def runTest(self):
348                pass
349
350        # ... and nothing should happen
351        Foo().setUp()
352
353    # "The default implementation does nothing."
354    def test_tearDown(self):
355        class Foo(unittest.TestCase):
356            def runTest(self):
357                pass
358
359        # ... and nothing should happen
360        Foo().tearDown()
361
362    # "Return a string identifying the specific test case."
363    #
364    # Because of the vague nature of the docs, I'm not going to lock this
365    # test down too much. Really all that can be asserted is that the id()
366    # will be a string (either 8-byte or unicode -- again, because the docs
367    # just say "string")
368    def test_id(self):
369        class Foo(unittest.TestCase):
370            def runTest(self):
371                pass
372
373        self.assertIsInstance(Foo().id(), basestring)
374
375    # "If result is omitted or None, a temporary result object is created
376    # and used, but is not made available to the caller. As TestCase owns the
377    # temporary result startTestRun and stopTestRun are called.
378
379    def test_run__uses_defaultTestResult(self):
380        events = []
381
382        class Foo(unittest.TestCase):
383            def test(self):
384                events.append('test')
385
386            def defaultTestResult(self):
387                return LoggingResult(events)
388
389        # Make run() find a result object on its own
390        Foo('test').run()
391
392        expected = ['startTestRun', 'startTest', 'test', 'addSuccess',
393            'stopTest', 'stopTestRun']
394        self.assertEqual(events, expected)
395
396    def testShortDescriptionWithoutDocstring(self):
397        self.assertIsNone(self.shortDescription())
398
399    @unittest.skipIf(sys.flags.optimize >= 2,
400                     "Docstrings are omitted with -O2 and above")
401    def testShortDescriptionWithOneLineDocstring(self):
402        """Tests shortDescription() for a method with a docstring."""
403        self.assertEqual(
404                self.shortDescription(),
405                'Tests shortDescription() for a method with a docstring.')
406
407    @unittest.skipIf(sys.flags.optimize >= 2,
408                     "Docstrings are omitted with -O2 and above")
409    def testShortDescriptionWithMultiLineDocstring(self):
410        """Tests shortDescription() for a method with a longer docstring.
411
412        This method ensures that only the first line of a docstring is
413        returned used in the short description, no matter how long the
414        whole thing is.
415        """
416        self.assertEqual(
417                self.shortDescription(),
418                 'Tests shortDescription() for a method with a longer '
419                 'docstring.')
420
421    def testAddTypeEqualityFunc(self):
422        class SadSnake(object):
423            """Dummy class for test_addTypeEqualityFunc."""
424        s1, s2 = SadSnake(), SadSnake()
425        self.assertNotEqual(s1, s2)
426        def AllSnakesCreatedEqual(a, b, msg=None):
427            return type(a) is type(b) is SadSnake
428        self.addTypeEqualityFunc(SadSnake, AllSnakesCreatedEqual)
429        self.assertEqual(s1, s2)
430        # No this doesn't clean up and remove the SadSnake equality func
431        # from this TestCase instance but since its a local nothing else
432        # will ever notice that.
433
434    def testAssertIs(self):
435        thing = object()
436        self.assertIs(thing, thing)
437        self.assertRaises(self.failureException, self.assertIs, thing, object())
438
439    def testAssertIsNot(self):
440        thing = object()
441        self.assertIsNot(thing, object())
442        self.assertRaises(self.failureException, self.assertIsNot, thing, thing)
443
444    def testAssertIsInstance(self):
445        thing = []
446        self.assertIsInstance(thing, list)
447        self.assertRaises(self.failureException, self.assertIsInstance,
448                          thing, dict)
449
450    def testAssertNotIsInstance(self):
451        thing = []
452        self.assertNotIsInstance(thing, dict)
453        self.assertRaises(self.failureException, self.assertNotIsInstance,
454                          thing, list)
455
456    def testAssertIn(self):
457        animals = {'monkey': 'banana', 'cow': 'grass', 'seal': 'fish'}
458
459        self.assertIn('a', 'abc')
460        self.assertIn(2, [1, 2, 3])
461        self.assertIn('monkey', animals)
462
463        self.assertNotIn('d', 'abc')
464        self.assertNotIn(0, [1, 2, 3])
465        self.assertNotIn('otter', animals)
466
467        self.assertRaises(self.failureException, self.assertIn, 'x', 'abc')
468        self.assertRaises(self.failureException, self.assertIn, 4, [1, 2, 3])
469        self.assertRaises(self.failureException, self.assertIn, 'elephant',
470                          animals)
471
472        self.assertRaises(self.failureException, self.assertNotIn, 'c', 'abc')
473        self.assertRaises(self.failureException, self.assertNotIn, 1, [1, 2, 3])
474        self.assertRaises(self.failureException, self.assertNotIn, 'cow',
475                          animals)
476
477    def testAssertDictContainsSubset(self):
478        self.assertDictContainsSubset({}, {})
479        self.assertDictContainsSubset({}, {'a': 1})
480        self.assertDictContainsSubset({'a': 1}, {'a': 1})
481        self.assertDictContainsSubset({'a': 1}, {'a': 1, 'b': 2})
482        self.assertDictContainsSubset({'a': 1, 'b': 2}, {'a': 1, 'b': 2})
483
484        with self.assertRaises(self.failureException):
485            self.assertDictContainsSubset({1: "one"}, {})
486
487        with self.assertRaises(self.failureException):
488            self.assertDictContainsSubset({'a': 2}, {'a': 1})
489
490        with self.assertRaises(self.failureException):
491            self.assertDictContainsSubset({'c': 1}, {'a': 1})
492
493        with self.assertRaises(self.failureException):
494            self.assertDictContainsSubset({'a': 1, 'c': 1}, {'a': 1})
495
496        with self.assertRaises(self.failureException):
497            self.assertDictContainsSubset({'a': 1, 'c': 1}, {'a': 1})
498
499        with test_support.check_warnings(("", UnicodeWarning)):
500            one = ''.join(chr(i) for i in range(255))
501            # this used to cause a UnicodeDecodeError constructing the failure msg
502            with self.assertRaises(self.failureException):
503                self.assertDictContainsSubset({'foo': one}, {'foo': u'\uFFFD'})
504
505    def testAssertEqual(self):
506        equal_pairs = [
507                ((), ()),
508                ({}, {}),
509                ([], []),
510                (set(), set()),
511                (frozenset(), frozenset())]
512        for a, b in equal_pairs:
513            # This mess of try excepts is to test the assertEqual behavior
514            # itself.
515            try:
516                self.assertEqual(a, b)
517            except self.failureException:
518                self.fail('assertEqual(%r, %r) failed' % (a, b))
519            try:
520                self.assertEqual(a, b, msg='foo')
521            except self.failureException:
522                self.fail('assertEqual(%r, %r) with msg= failed' % (a, b))
523            try:
524                self.assertEqual(a, b, 'foo')
525            except self.failureException:
526                self.fail('assertEqual(%r, %r) with third parameter failed' %
527                          (a, b))
528
529        unequal_pairs = [
530               ((), []),
531               ({}, set()),
532               (set([4,1]), frozenset([4,2])),
533               (frozenset([4,5]), set([2,3])),
534               (set([3,4]), set([5,4]))]
535        for a, b in unequal_pairs:
536            self.assertRaises(self.failureException, self.assertEqual, a, b)
537            self.assertRaises(self.failureException, self.assertEqual, a, b,
538                              'foo')
539            self.assertRaises(self.failureException, self.assertEqual, a, b,
540                              msg='foo')
541
542    def testEquality(self):
543        self.assertListEqual([], [])
544        self.assertTupleEqual((), ())
545        self.assertSequenceEqual([], ())
546
547        a = [0, 'a', []]
548        b = []
549        self.assertRaises(unittest.TestCase.failureException,
550                          self.assertListEqual, a, b)
551        self.assertRaises(unittest.TestCase.failureException,
552                          self.assertListEqual, tuple(a), tuple(b))
553        self.assertRaises(unittest.TestCase.failureException,
554                          self.assertSequenceEqual, a, tuple(b))
555
556        b.extend(a)
557        self.assertListEqual(a, b)
558        self.assertTupleEqual(tuple(a), tuple(b))
559        self.assertSequenceEqual(a, tuple(b))
560        self.assertSequenceEqual(tuple(a), b)
561
562        self.assertRaises(self.failureException, self.assertListEqual,
563                          a, tuple(b))
564        self.assertRaises(self.failureException, self.assertTupleEqual,
565                          tuple(a), b)
566        self.assertRaises(self.failureException, self.assertListEqual, None, b)
567        self.assertRaises(self.failureException, self.assertTupleEqual, None,
568                          tuple(b))
569        self.assertRaises(self.failureException, self.assertSequenceEqual,
570                          None, tuple(b))
571        self.assertRaises(self.failureException, self.assertListEqual, 1, 1)
572        self.assertRaises(self.failureException, self.assertTupleEqual, 1, 1)
573        self.assertRaises(self.failureException, self.assertSequenceEqual,
574                          1, 1)
575
576        self.assertDictEqual({}, {})
577
578        c = { 'x': 1 }
579        d = {}
580        self.assertRaises(unittest.TestCase.failureException,
581                          self.assertDictEqual, c, d)
582
583        d.update(c)
584        self.assertDictEqual(c, d)
585
586        d['x'] = 0
587        self.assertRaises(unittest.TestCase.failureException,
588                          self.assertDictEqual, c, d, 'These are unequal')
589
590        self.assertRaises(self.failureException, self.assertDictEqual, None, d)
591        self.assertRaises(self.failureException, self.assertDictEqual, [], d)
592        self.assertRaises(self.failureException, self.assertDictEqual, 1, 1)
593
594    def testAssertSequenceEqualMaxDiff(self):
595        self.assertEqual(self.maxDiff, 80*8)
596        seq1 = 'a' + 'x' * 80**2
597        seq2 = 'b' + 'x' * 80**2
598        diff = '\n'.join(difflib.ndiff(pprint.pformat(seq1).splitlines(),
599                                       pprint.pformat(seq2).splitlines()))
600        # the +1 is the leading \n added by assertSequenceEqual
601        omitted = unittest.case.DIFF_OMITTED % (len(diff) + 1,)
602
603        self.maxDiff = len(diff)//2
604        try:
605            self.assertSequenceEqual(seq1, seq2)
606        except self.failureException as e:
607            msg = e.args[0]
608        else:
609            self.fail('assertSequenceEqual did not fail.')
610        self.assertTrue(len(msg) < len(diff))
611        self.assertIn(omitted, msg)
612
613        self.maxDiff = len(diff) * 2
614        try:
615            self.assertSequenceEqual(seq1, seq2)
616        except self.failureException as e:
617            msg = e.args[0]
618        else:
619            self.fail('assertSequenceEqual did not fail.')
620        self.assertTrue(len(msg) > len(diff))
621        self.assertNotIn(omitted, msg)
622
623        self.maxDiff = None
624        try:
625            self.assertSequenceEqual(seq1, seq2)
626        except self.failureException as e:
627            msg = e.args[0]
628        else:
629            self.fail('assertSequenceEqual did not fail.')
630        self.assertTrue(len(msg) > len(diff))
631        self.assertNotIn(omitted, msg)
632
633    def testTruncateMessage(self):
634        self.maxDiff = 1
635        message = self._truncateMessage('foo', 'bar')
636        omitted = unittest.case.DIFF_OMITTED % len('bar')
637        self.assertEqual(message, 'foo' + omitted)
638
639        self.maxDiff = None
640        message = self._truncateMessage('foo', 'bar')
641        self.assertEqual(message, 'foobar')
642
643        self.maxDiff = 4
644        message = self._truncateMessage('foo', 'bar')
645        self.assertEqual(message, 'foobar')
646
647    def testAssertDictEqualTruncates(self):
648        test = unittest.TestCase('assertEqual')
649        def truncate(msg, diff):
650            return 'foo'
651        test._truncateMessage = truncate
652        try:
653            test.assertDictEqual({}, {1: 0})
654        except self.failureException as e:
655            self.assertEqual(str(e), 'foo')
656        else:
657            self.fail('assertDictEqual did not fail')
658
659    def testAssertMultiLineEqualTruncates(self):
660        test = unittest.TestCase('assertEqual')
661        def truncate(msg, diff):
662            return 'foo'
663        test._truncateMessage = truncate
664        try:
665            test.assertMultiLineEqual('foo', 'bar')
666        except self.failureException as e:
667            self.assertEqual(str(e), 'foo')
668        else:
669            self.fail('assertMultiLineEqual did not fail')
670
671    def testAssertEqual_diffThreshold(self):
672        # check threshold value
673        self.assertEqual(self._diffThreshold, 2**16)
674        # disable madDiff to get diff markers
675        self.maxDiff = None
676
677        # set a lower threshold value and add a cleanup to restore it
678        old_threshold = self._diffThreshold
679        self._diffThreshold = 2**8
680        self.addCleanup(lambda: setattr(self, '_diffThreshold', old_threshold))
681
682        # under the threshold: diff marker (^) in error message
683        s = u'x' * (2**7)
684        with self.assertRaises(self.failureException) as cm:
685            self.assertEqual(s + 'a', s + 'b')
686        self.assertIn('^', str(cm.exception))
687        self.assertEqual(s + 'a', s + 'a')
688
689        # over the threshold: diff not used and marker (^) not in error message
690        s = u'x' * (2**9)
691        # if the path that uses difflib is taken, _truncateMessage will be
692        # called -- replace it with explodingTruncation to verify that this
693        # doesn't happen
694        def explodingTruncation(message, diff):
695            raise SystemError('this should not be raised')
696        old_truncate = self._truncateMessage
697        self._truncateMessage = explodingTruncation
698        self.addCleanup(lambda: setattr(self, '_truncateMessage', old_truncate))
699
700        s1, s2 = s + 'a', s + 'b'
701        with self.assertRaises(self.failureException) as cm:
702            self.assertEqual(s1, s2)
703        self.assertNotIn('^', str(cm.exception))
704        self.assertEqual(str(cm.exception), '%r != %r' % (s1, s2))
705        self.assertEqual(s + 'a', s + 'a')
706
707    def testAssertItemsEqual(self):
708        a = object()
709        self.assertItemsEqual([1, 2, 3], [3, 2, 1])
710        self.assertItemsEqual(['foo', 'bar', 'baz'], ['bar', 'baz', 'foo'])
711        self.assertItemsEqual([a, a, 2, 2, 3], (a, 2, 3, a, 2))
712        self.assertItemsEqual([1, "2", "a", "a"], ["a", "2", True, "a"])
713        self.assertRaises(self.failureException, self.assertItemsEqual,
714                          [1, 2] + [3] * 100, [1] * 100 + [2, 3])
715        self.assertRaises(self.failureException, self.assertItemsEqual,
716                          [1, "2", "a", "a"], ["a", "2", True, 1])
717        self.assertRaises(self.failureException, self.assertItemsEqual,
718                          [10], [10, 11])
719        self.assertRaises(self.failureException, self.assertItemsEqual,
720                          [10, 11], [10])
721        self.assertRaises(self.failureException, self.assertItemsEqual,
722                          [10, 11, 10], [10, 11])
723
724        # Test that sequences of unhashable objects can be tested for sameness:
725        self.assertItemsEqual([[1, 2], [3, 4], 0], [False, [3, 4], [1, 2]])
726        # Test that iterator of unhashable objects can be tested for sameness:
727        self.assertItemsEqual(iter([1, 2, [], 3, 4]),
728                              iter([1, 2, [], 3, 4]))
729
730        # hashable types, but not orderable
731        self.assertRaises(self.failureException, self.assertItemsEqual,
732                          [], [divmod, 'x', 1, 5j, 2j, frozenset()])
733        # comparing dicts
734        self.assertItemsEqual([{'a': 1}, {'b': 2}], [{'b': 2}, {'a': 1}])
735        # comparing heterogenous non-hashable sequences
736        self.assertItemsEqual([1, 'x', divmod, []], [divmod, [], 'x', 1])
737        self.assertRaises(self.failureException, self.assertItemsEqual,
738                          [], [divmod, [], 'x', 1, 5j, 2j, set()])
739        self.assertRaises(self.failureException, self.assertItemsEqual,
740                          [[1]], [[2]])
741
742        # Same elements, but not same sequence length
743        self.assertRaises(self.failureException, self.assertItemsEqual,
744                          [1, 1, 2], [2, 1])
745        self.assertRaises(self.failureException, self.assertItemsEqual,
746                          [1, 1, "2", "a", "a"], ["2", "2", True, "a"])
747        self.assertRaises(self.failureException, self.assertItemsEqual,
748                          [1, {'b': 2}, None, True], [{'b': 2}, True, None])
749
750        # Same elements which don't reliably compare, in
751        # different order, see issue 10242
752        a = [{2,4}, {1,2}]
753        b = a[::-1]
754        self.assertItemsEqual(a, b)
755
756        # test utility functions supporting assertItemsEqual()
757
758        diffs = set(unittest.util._count_diff_all_purpose('aaabccd', 'abbbcce'))
759        expected = {(3,1,'a'), (1,3,'b'), (1,0,'d'), (0,1,'e')}
760        self.assertEqual(diffs, expected)
761
762        diffs = unittest.util._count_diff_all_purpose([[]], [])
763        self.assertEqual(diffs, [(1, 0, [])])
764
765        diffs = set(unittest.util._count_diff_hashable('aaabccd', 'abbbcce'))
766        expected = {(3,1,'a'), (1,3,'b'), (1,0,'d'), (0,1,'e')}
767        self.assertEqual(diffs, expected)
768
769    def testAssertSetEqual(self):
770        set1 = set()
771        set2 = set()
772        self.assertSetEqual(set1, set2)
773
774        self.assertRaises(self.failureException, self.assertSetEqual, None, set2)
775        self.assertRaises(self.failureException, self.assertSetEqual, [], set2)
776        self.assertRaises(self.failureException, self.assertSetEqual, set1, None)
777        self.assertRaises(self.failureException, self.assertSetEqual, set1, [])
778
779        set1 = set(['a'])
780        set2 = set()
781        self.assertRaises(self.failureException, self.assertSetEqual, set1, set2)
782
783        set1 = set(['a'])
784        set2 = set(['a'])
785        self.assertSetEqual(set1, set2)
786
787        set1 = set(['a'])
788        set2 = set(['a', 'b'])
789        self.assertRaises(self.failureException, self.assertSetEqual, set1, set2)
790
791        set1 = set(['a'])
792        set2 = frozenset(['a', 'b'])
793        self.assertRaises(self.failureException, self.assertSetEqual, set1, set2)
794
795        set1 = set(['a', 'b'])
796        set2 = frozenset(['a', 'b'])
797        self.assertSetEqual(set1, set2)
798
799        set1 = set()
800        set2 = "foo"
801        self.assertRaises(self.failureException, self.assertSetEqual, set1, set2)
802        self.assertRaises(self.failureException, self.assertSetEqual, set2, set1)
803
804        # make sure any string formatting is tuple-safe
805        set1 = set([(0, 1), (2, 3)])
806        set2 = set([(4, 5)])
807        self.assertRaises(self.failureException, self.assertSetEqual, set1, set2)
808
809    def testInequality(self):
810        # Try ints
811        self.assertGreater(2, 1)
812        self.assertGreaterEqual(2, 1)
813        self.assertGreaterEqual(1, 1)
814        self.assertLess(1, 2)
815        self.assertLessEqual(1, 2)
816        self.assertLessEqual(1, 1)
817        self.assertRaises(self.failureException, self.assertGreater, 1, 2)
818        self.assertRaises(self.failureException, self.assertGreater, 1, 1)
819        self.assertRaises(self.failureException, self.assertGreaterEqual, 1, 2)
820        self.assertRaises(self.failureException, self.assertLess, 2, 1)
821        self.assertRaises(self.failureException, self.assertLess, 1, 1)
822        self.assertRaises(self.failureException, self.assertLessEqual, 2, 1)
823
824        # Try Floats
825        self.assertGreater(1.1, 1.0)
826        self.assertGreaterEqual(1.1, 1.0)
827        self.assertGreaterEqual(1.0, 1.0)
828        self.assertLess(1.0, 1.1)
829        self.assertLessEqual(1.0, 1.1)
830        self.assertLessEqual(1.0, 1.0)
831        self.assertRaises(self.failureException, self.assertGreater, 1.0, 1.1)
832        self.assertRaises(self.failureException, self.assertGreater, 1.0, 1.0)
833        self.assertRaises(self.failureException, self.assertGreaterEqual, 1.0, 1.1)
834        self.assertRaises(self.failureException, self.assertLess, 1.1, 1.0)
835        self.assertRaises(self.failureException, self.assertLess, 1.0, 1.0)
836        self.assertRaises(self.failureException, self.assertLessEqual, 1.1, 1.0)
837
838        # Try Strings
839        self.assertGreater('bug', 'ant')
840        self.assertGreaterEqual('bug', 'ant')
841        self.assertGreaterEqual('ant', 'ant')
842        self.assertLess('ant', 'bug')
843        self.assertLessEqual('ant', 'bug')
844        self.assertLessEqual('ant', 'ant')
845        self.assertRaises(self.failureException, self.assertGreater, 'ant', 'bug')
846        self.assertRaises(self.failureException, self.assertGreater, 'ant', 'ant')
847        self.assertRaises(self.failureException, self.assertGreaterEqual, 'ant', 'bug')
848        self.assertRaises(self.failureException, self.assertLess, 'bug', 'ant')
849        self.assertRaises(self.failureException, self.assertLess, 'ant', 'ant')
850        self.assertRaises(self.failureException, self.assertLessEqual, 'bug', 'ant')
851
852        # Try Unicode
853        self.assertGreater(u'bug', u'ant')
854        self.assertGreaterEqual(u'bug', u'ant')
855        self.assertGreaterEqual(u'ant', u'ant')
856        self.assertLess(u'ant', u'bug')
857        self.assertLessEqual(u'ant', u'bug')
858        self.assertLessEqual(u'ant', u'ant')
859        self.assertRaises(self.failureException, self.assertGreater, u'ant', u'bug')
860        self.assertRaises(self.failureException, self.assertGreater, u'ant', u'ant')
861        self.assertRaises(self.failureException, self.assertGreaterEqual, u'ant',
862                          u'bug')
863        self.assertRaises(self.failureException, self.assertLess, u'bug', u'ant')
864        self.assertRaises(self.failureException, self.assertLess, u'ant', u'ant')
865        self.assertRaises(self.failureException, self.assertLessEqual, u'bug', u'ant')
866
867        # Try Mixed String/Unicode
868        self.assertGreater('bug', u'ant')
869        self.assertGreater(u'bug', 'ant')
870        self.assertGreaterEqual('bug', u'ant')
871        self.assertGreaterEqual(u'bug', 'ant')
872        self.assertGreaterEqual('ant', u'ant')
873        self.assertGreaterEqual(u'ant', 'ant')
874        self.assertLess('ant', u'bug')
875        self.assertLess(u'ant', 'bug')
876        self.assertLessEqual('ant', u'bug')
877        self.assertLessEqual(u'ant', 'bug')
878        self.assertLessEqual('ant', u'ant')
879        self.assertLessEqual(u'ant', 'ant')
880        self.assertRaises(self.failureException, self.assertGreater, 'ant', u'bug')
881        self.assertRaises(self.failureException, self.assertGreater, u'ant', 'bug')
882        self.assertRaises(self.failureException, self.assertGreater, 'ant', u'ant')
883        self.assertRaises(self.failureException, self.assertGreater, u'ant', 'ant')
884        self.assertRaises(self.failureException, self.assertGreaterEqual, 'ant',
885                          u'bug')
886        self.assertRaises(self.failureException, self.assertGreaterEqual, u'ant',
887                          'bug')
888        self.assertRaises(self.failureException, self.assertLess, 'bug', u'ant')
889        self.assertRaises(self.failureException, self.assertLess, u'bug', 'ant')
890        self.assertRaises(self.failureException, self.assertLess, 'ant', u'ant')
891        self.assertRaises(self.failureException, self.assertLess, u'ant', 'ant')
892        self.assertRaises(self.failureException, self.assertLessEqual, 'bug', u'ant')
893        self.assertRaises(self.failureException, self.assertLessEqual, u'bug', 'ant')
894
895    def testAssertMultiLineEqual(self):
896        sample_text = b"""\
897http://www.python.org/doc/2.3/lib/module-unittest.html
898test case
899    A test case is the smallest unit of testing. [...]
900"""
901        revised_sample_text = b"""\
902http://www.python.org/doc/2.4.1/lib/module-unittest.html
903test case
904    A test case is the smallest unit of testing. [...] You may provide your
905    own implementation that does not subclass from TestCase, of course.
906"""
907        sample_text_error = b"""\
908- http://www.python.org/doc/2.3/lib/module-unittest.html
909?                             ^
910+ http://www.python.org/doc/2.4.1/lib/module-unittest.html
911?                             ^^^
912  test case
913-     A test case is the smallest unit of testing. [...]
914+     A test case is the smallest unit of testing. [...] You may provide your
915?                                                       +++++++++++++++++++++
916+     own implementation that does not subclass from TestCase, of course.
917"""
918        self.maxDiff = None
919        for type_changer in (lambda x: x, lambda x: x.decode('utf8')):
920            try:
921                self.assertMultiLineEqual(type_changer(sample_text),
922                                          type_changer(revised_sample_text))
923            except self.failureException, e:
924                # need to remove the first line of the error message
925                error = str(e).encode('utf8').split('\n', 1)[1]
926
927                # assertMultiLineEqual is hooked up as the default for
928                # unicode strings - so we can't use it for this check
929                self.assertTrue(sample_text_error == error)
930
931    def testAsertEqualSingleLine(self):
932        sample_text = u"laden swallows fly slowly"
933        revised_sample_text = u"unladen swallows fly quickly"
934        sample_text_error = """\
935- laden swallows fly slowly
936?                    ^^^^
937+ unladen swallows fly quickly
938? ++                   ^^^^^
939"""
940        try:
941            self.assertEqual(sample_text, revised_sample_text)
942        except self.failureException as e:
943            error = str(e).split('\n', 1)[1]
944            self.assertTrue(sample_text_error == error)
945
946    def testAssertIsNone(self):
947        self.assertIsNone(None)
948        self.assertRaises(self.failureException, self.assertIsNone, False)
949        self.assertIsNotNone('DjZoPloGears on Rails')
950        self.assertRaises(self.failureException, self.assertIsNotNone, None)
951
952    def testAssertRegexpMatches(self):
953        self.assertRegexpMatches('asdfabasdf', r'ab+')
954        self.assertRaises(self.failureException, self.assertRegexpMatches,
955                          'saaas', r'aaaa')
956
957    def testAssertRaisesRegexp(self):
958        class ExceptionMock(Exception):
959            pass
960
961        def Stub():
962            raise ExceptionMock('We expect')
963
964        self.assertRaisesRegexp(ExceptionMock, re.compile('expect$'), Stub)
965        self.assertRaisesRegexp(ExceptionMock, 'expect$', Stub)
966        self.assertRaisesRegexp(ExceptionMock, u'expect$', Stub)
967
968    def testAssertNotRaisesRegexp(self):
969        self.assertRaisesRegexp(
970                self.failureException, '^Exception not raised$',
971                self.assertRaisesRegexp, Exception, re.compile('x'),
972                lambda: None)
973        self.assertRaisesRegexp(
974                self.failureException, '^Exception not raised$',
975                self.assertRaisesRegexp, Exception, 'x',
976                lambda: None)
977        self.assertRaisesRegexp(
978                self.failureException, '^Exception not raised$',
979                self.assertRaisesRegexp, Exception, u'x',
980                lambda: None)
981
982    def testAssertRaisesRegexpMismatch(self):
983        def Stub():
984            raise Exception('Unexpected')
985
986        self.assertRaisesRegexp(
987                self.failureException,
988                r'"\^Expected\$" does not match "Unexpected"',
989                self.assertRaisesRegexp, Exception, '^Expected$',
990                Stub)
991        self.assertRaisesRegexp(
992                self.failureException,
993                r'"\^Expected\$" does not match "Unexpected"',
994                self.assertRaisesRegexp, Exception, u'^Expected$',
995                Stub)
996        self.assertRaisesRegexp(
997                self.failureException,
998                r'"\^Expected\$" does not match "Unexpected"',
999                self.assertRaisesRegexp, Exception,
1000                re.compile('^Expected$'), Stub)
1001
1002    def testAssertRaisesExcValue(self):
1003        class ExceptionMock(Exception):
1004            pass
1005
1006        def Stub(foo):
1007            raise ExceptionMock(foo)
1008        v = "particular value"
1009
1010        ctx = self.assertRaises(ExceptionMock)
1011        with ctx:
1012            Stub(v)
1013        e = ctx.exception
1014        self.assertIsInstance(e, ExceptionMock)
1015        self.assertEqual(e.args[0], v)
1016
1017    def testSynonymAssertMethodNames(self):
1018        """Test undocumented method name synonyms.
1019
1020        Please do not use these methods names in your own code.
1021
1022        This test confirms their continued existence and functionality
1023        in order to avoid breaking existing code.
1024        """
1025        self.assertNotEquals(3, 5)
1026        self.assertEquals(3, 3)
1027        self.assertAlmostEquals(2.0, 2.0)
1028        self.assertNotAlmostEquals(3.0, 5.0)
1029        self.assert_(True)
1030
1031    def testPendingDeprecationMethodNames(self):
1032        """Test fail* methods pending deprecation, they will warn in 3.2.
1033
1034        Do not use these methods.  They will go away in 3.3.
1035        """
1036        with test_support.check_warnings():
1037            self.failIfEqual(3, 5)
1038            self.failUnlessEqual(3, 3)
1039            self.failUnlessAlmostEqual(2.0, 2.0)
1040            self.failIfAlmostEqual(3.0, 5.0)
1041            self.failUnless(True)
1042            self.failUnlessRaises(TypeError, lambda _: 3.14 + u'spam')
1043            self.failIf(False)
1044
1045    def testDeepcopy(self):
1046        # Issue: 5660
1047        class TestableTest(unittest.TestCase):
1048            def testNothing(self):
1049                pass
1050
1051        test = TestableTest('testNothing')
1052
1053        # This shouldn't blow up
1054        deepcopy(test)
1055
1056    def testKeyboardInterrupt(self):
1057        def _raise(self=None):
1058            raise KeyboardInterrupt
1059        def nothing(self):
1060            pass
1061
1062        class Test1(unittest.TestCase):
1063            test_something = _raise
1064
1065        class Test2(unittest.TestCase):
1066            setUp = _raise
1067            test_something = nothing
1068
1069        class Test3(unittest.TestCase):
1070            test_something = nothing
1071            tearDown = _raise
1072
1073        class Test4(unittest.TestCase):
1074            def test_something(self):
1075                self.addCleanup(_raise)
1076
1077        for klass in (Test1, Test2, Test3, Test4):
1078            with self.assertRaises(KeyboardInterrupt):
1079                klass('test_something').run()
1080
1081    def testSystemExit(self):
1082        def _raise(self=None):
1083            raise SystemExit
1084        def nothing(self):
1085            pass
1086
1087        class Test1(unittest.TestCase):
1088            test_something = _raise
1089
1090        class Test2(unittest.TestCase):
1091            setUp = _raise
1092            test_something = nothing
1093
1094        class Test3(unittest.TestCase):
1095            test_something = nothing
1096            tearDown = _raise
1097
1098        class Test4(unittest.TestCase):
1099            def test_something(self):
1100                self.addCleanup(_raise)
1101
1102        for klass in (Test1, Test2, Test3, Test4):
1103            result = unittest.TestResult()
1104            klass('test_something').run(result)
1105            self.assertEqual(len(result.errors), 1)
1106            self.assertEqual(result.testsRun, 1)
1107
1108    def testPickle(self):
1109        # Issue 10326
1110
1111        # Can't use TestCase classes defined in Test class as
1112        # pickle does not work with inner classes
1113        test = unittest.TestCase('run')
1114        for protocol in range(pickle.HIGHEST_PROTOCOL + 1):
1115
1116            # blew up prior to fix
1117            pickled_test = pickle.dumps(test, protocol=protocol)
1118
1119            unpickled_test = pickle.loads(pickled_test)
1120            self.assertEqual(test, unpickled_test)
1121
1122
1123if __name__ == '__main__':
1124    unittest.main()
1125