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