← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_selftest.py

  • Committer: Ross Lagerwall
  • Date: 2012-08-07 06:32:51 UTC
  • mto: (6437.63.5 2.5)
  • mto: This revision was merged to the branch mainline in revision 6558.
  • Revision ID: rosslagerwall@gmail.com-20120807063251-x9p03ghg2ws8oqjc
Add bzrlib/locale to .bzrignore

bzrlib/locale is generated with ./setup.py build_mo which is in turn called
by ./setup.py build

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_selftest.py
1
 
# Copyright (C) 2005-2013, 2016 Canonical Ltd
 
1
# Copyright (C) 2005-2011 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
43
43
from bzrlib import (
44
44
    branchbuilder,
45
45
    bzrdir,
46
 
    controldir,
47
46
    errors,
48
47
    hooks,
49
48
    lockdir,
335
334
        server1 = "a"
336
335
        server2 = "b"
337
336
        formats = [workingtree_4.WorkingTreeFormat4(),
338
 
                   workingtree_3.WorkingTreeFormat3(),
339
 
                   workingtree_4.WorkingTreeFormat6()]
340
 
        scenarios = make_scenarios(server1, server2, formats,
341
 
            remote_server='c', remote_readonly_server='d',
342
 
            remote_backing_server='e')
 
337
                   workingtree_3.WorkingTreeFormat3(),]
 
338
        scenarios = make_scenarios(server1, server2, formats)
343
339
        self.assertEqual([
344
340
            ('WorkingTreeFormat4',
345
341
             {'bzrdir_format': formats[0]._matchingbzrdir,
350
346
             {'bzrdir_format': formats[1]._matchingbzrdir,
351
347
              'transport_readonly_server': 'b',
352
348
              'transport_server': 'a',
353
 
              'workingtree_format': formats[1]}),
354
 
            ('WorkingTreeFormat6',
355
 
             {'bzrdir_format': formats[2]._matchingbzrdir,
356
 
              'transport_readonly_server': 'b',
357
 
              'transport_server': 'a',
358
 
              'workingtree_format': formats[2]}),
359
 
            ('WorkingTreeFormat6,remote',
360
 
             {'bzrdir_format': formats[2]._matchingbzrdir,
361
 
              'repo_is_remote': True,
362
 
              'transport_readonly_server': 'd',
363
 
              'transport_server': 'c',
364
 
              'vfs_transport_factory': 'e',
365
 
              'workingtree_format': formats[2]}),
366
 
            ], scenarios)
 
349
              'workingtree_format': formats[1]})],
 
350
            scenarios)
367
351
 
368
352
 
369
353
class TestTreeScenarios(tests.TestCase):
370
354
 
371
355
    def test_scenarios(self):
372
356
        # the tree implementation scenario generator is meant to setup one
373
 
        # instance for each working tree format, one additional instance
 
357
        # instance for each working tree format, and one additional instance
374
358
        # that will use the default wt format, but create a revision tree for
375
 
        # the tests, and one more that uses the default wt format as a
376
 
        # lightweight checkout of a remote repository.  This means that the wt
377
 
        # ones should have the workingtree_to_test_tree attribute set to
378
 
        # 'return_parameter' and the revision one set to
379
 
        # revision_tree_from_workingtree.
 
359
        # the tests.  this means that the wt ones should have the
 
360
        # workingtree_to_test_tree attribute set to 'return_parameter' and the
 
361
        # revision one set to revision_tree_from_workingtree.
380
362
 
381
363
        from bzrlib.tests.per_tree import (
382
364
            _dirstate_tree_from_workingtree,
388
370
            )
389
371
        server1 = "a"
390
372
        server2 = "b"
391
 
        smart_server = test_server.SmartTCPServer_for_testing
392
 
        smart_readonly_server = test_server.ReadonlySmartTCPServer_for_testing
393
 
        mem_server = memory.MemoryServer
394
373
        formats = [workingtree_4.WorkingTreeFormat4(),
395
374
                   workingtree_3.WorkingTreeFormat3(),]
396
375
        scenarios = make_scenarios(server1, server2, formats)
397
 
        self.assertEqual(8, len(scenarios))
 
376
        self.assertEqual(7, len(scenarios))
398
377
        default_wt_format = workingtree.format_registry.get_default()
399
378
        wt4_format = workingtree_4.WorkingTreeFormat4()
400
379
        wt5_format = workingtree_4.WorkingTreeFormat5()
401
 
        wt6_format = workingtree_4.WorkingTreeFormat6()
402
380
        expected_scenarios = [
403
381
            ('WorkingTreeFormat4',
404
382
             {'bzrdir_format': formats[0]._matchingbzrdir,
414
392
              'workingtree_format': formats[1],
415
393
              '_workingtree_to_test_tree': return_parameter,
416
394
             }),
417
 
            ('WorkingTreeFormat6,remote',
418
 
             {'bzrdir_format': wt6_format._matchingbzrdir,
419
 
              'repo_is_remote': True,
420
 
              'transport_readonly_server': smart_readonly_server,
421
 
              'transport_server': smart_server,
422
 
              'vfs_transport_factory': mem_server,
423
 
              'workingtree_format': wt6_format,
424
 
              '_workingtree_to_test_tree': return_parameter,
425
 
             }),
426
395
            ('RevisionTree',
427
396
             {'_workingtree_to_test_tree': revision_tree_from_workingtree,
428
397
              'bzrdir_format': default_wt_format._matchingbzrdir,
640
609
        # Guard against regression into MemoryTransport leaking
641
610
        # files to disk instead of keeping them in memory.
642
611
        self.assertFalse(osutils.lexists('dir'))
643
 
        dir_format = controldir.format_registry.make_bzrdir('knit')
 
612
        dir_format = bzrdir.format_registry.make_bzrdir('knit')
644
613
        self.assertEqual(dir_format.repository_format.__class__,
645
614
                         the_branch.repository._format.__class__)
646
615
        self.assertEqual('Bazaar-NG Knit Repository Format 1',
709
678
        builder = self.make_branch_builder('dir')
710
679
        rev_id = builder.build_commit()
711
680
        self.assertPathExists('dir')
712
 
        a_dir = controldir.ControlDir.open('dir')
 
681
        a_dir = bzrdir.BzrDir.open('dir')
713
682
        self.assertRaises(errors.NoWorkingTree, a_dir.open_workingtree)
714
683
        a_branch = a_dir.open_branch()
715
684
        builder_branch = builder.get_branch()
1002
971
            pass
1003
972
        test = unittest.FunctionTestCase(test_function)
1004
973
        test.run(result)
1005
 
        self.assertEqual(1, result.calls)
 
974
        self.assertEquals(1, result.calls)
1006
975
 
1007
976
    def test_startTests_only_once(self):
1008
977
        """With multiple tests startTests should still only be called once"""
1014
983
            unittest.FunctionTestCase(lambda: None),
1015
984
            unittest.FunctionTestCase(lambda: None)])
1016
985
        suite.run(result)
1017
 
        self.assertEqual(1, result.calls)
1018
 
        self.assertEqual(2, result.count)
 
986
        self.assertEquals(1, result.calls)
 
987
        self.assertEquals(2, result.count)
1019
988
 
1020
989
 
1021
990
class TestRunner(tests.TestCase):
1161
1130
        class SkippedTest(tests.TestCase):
1162
1131
 
1163
1132
            def setUp(self):
1164
 
                super(SkippedTest, self).setUp()
 
1133
                tests.TestCase.setUp(self)
1165
1134
                calls.append('setUp')
1166
1135
                self.addCleanup(self.cleanup)
1167
1136
 
1508
1477
        transport_server.start_server()
1509
1478
        self.addCleanup(transport_server.stop_server)
1510
1479
        t = transport.get_transport_from_url(transport_server.get_url())
1511
 
        controldir.ControlDir.create(t.base)
 
1480
        bzrdir.BzrDir.create(t.base)
1512
1481
        self.assertRaises(errors.BzrError,
1513
 
            controldir.ControlDir.open_from_transport, t)
 
1482
            bzrdir.BzrDir.open_from_transport, t)
1514
1483
        # But if we declare this as safe, we can open the bzrdir.
1515
1484
        self.permit_url(t.base)
1516
1485
        self._bzr_selftest_roots.append(t.base)
1517
 
        controldir.ControlDir.open_from_transport(t)
 
1486
        bzrdir.BzrDir.open_from_transport(t)
1518
1487
 
1519
1488
    def test_requireFeature_available(self):
1520
1489
        """self.requireFeature(available) is a no-op."""
1654
1623
        self.assertRaises(AssertionError,
1655
1624
            self.assertListRaises, _TestException, success_generator)
1656
1625
 
1657
 
    def _run_successful_test(self, test):
1658
 
        result = testtools.TestResult()
1659
 
        test.run(result)
1660
 
        self.assertTrue(result.wasSuccessful())
1661
 
        return result
1662
 
 
1663
1626
    def test_overrideAttr_without_value(self):
1664
1627
        self.test_attr = 'original' # Define a test attribute
1665
1628
        obj = self # Make 'obj' visible to the embedded test
1666
1629
        class Test(tests.TestCase):
1667
1630
 
1668
1631
            def setUp(self):
1669
 
                super(Test, self).setUp()
 
1632
                tests.TestCase.setUp(self)
1670
1633
                self.orig = self.overrideAttr(obj, 'test_attr')
1671
1634
 
1672
1635
            def test_value(self):
1675
1638
                obj.test_attr = 'modified'
1676
1639
                self.assertEqual('modified', obj.test_attr)
1677
1640
 
1678
 
        self._run_successful_test(Test('test_value'))
 
1641
        test = Test('test_value')
 
1642
        test.run(unittest.TestResult())
1679
1643
        self.assertEqual('original', obj.test_attr)
1680
1644
 
1681
1645
    def test_overrideAttr_with_value(self):
1684
1648
        class Test(tests.TestCase):
1685
1649
 
1686
1650
            def setUp(self):
1687
 
                super(Test, self).setUp()
 
1651
                tests.TestCase.setUp(self)
1688
1652
                self.orig = self.overrideAttr(obj, 'test_attr', new='modified')
1689
1653
 
1690
1654
            def test_value(self):
1691
1655
                self.assertEqual('original', self.orig)
1692
1656
                self.assertEqual('modified', obj.test_attr)
1693
1657
 
1694
 
        self._run_successful_test(Test('test_value'))
 
1658
        test = Test('test_value')
 
1659
        test.run(unittest.TestResult())
1695
1660
        self.assertEqual('original', obj.test_attr)
1696
1661
 
1697
 
    def test_overrideAttr_with_no_existing_value_and_value(self):
1698
 
        # Do not define the test_attribute
1699
 
        obj = self # Make 'obj' visible to the embedded test
1700
 
        class Test(tests.TestCase):
1701
 
 
1702
 
            def setUp(self):
1703
 
                tests.TestCase.setUp(self)
1704
 
                self.orig = self.overrideAttr(obj, 'test_attr', new='modified')
1705
 
 
1706
 
            def test_value(self):
1707
 
                self.assertEqual(tests._unitialized_attr, self.orig)
1708
 
                self.assertEqual('modified', obj.test_attr)
1709
 
 
1710
 
        self._run_successful_test(Test('test_value'))
1711
 
        self.assertRaises(AttributeError, getattr, obj, 'test_attr')
1712
 
 
1713
 
    def test_overrideAttr_with_no_existing_value_and_no_value(self):
1714
 
        # Do not define the test_attribute
1715
 
        obj = self # Make 'obj' visible to the embedded test
1716
 
        class Test(tests.TestCase):
1717
 
 
1718
 
            def setUp(self):
1719
 
                tests.TestCase.setUp(self)
1720
 
                self.orig = self.overrideAttr(obj, 'test_attr')
1721
 
 
1722
 
            def test_value(self):
1723
 
                self.assertEqual(tests._unitialized_attr, self.orig)
1724
 
                self.assertRaises(AttributeError, getattr, obj, 'test_attr')
1725
 
 
1726
 
        self._run_successful_test(Test('test_value'))
1727
 
        self.assertRaises(AttributeError, getattr, obj, 'test_attr')
1728
 
 
1729
1662
    def test_recordCalls(self):
1730
1663
        from bzrlib.tests import test_selftest
1731
1664
        calls = self.recordCalls(
1732
1665
            test_selftest, '_add_numbers')
1733
1666
        self.assertEqual(test_selftest._add_numbers(2, 10),
1734
1667
            12)
1735
 
        self.assertEqual(calls, [((2, 10), {})])
 
1668
        self.assertEquals(calls, [((2, 10), {})])
1736
1669
 
1737
1670
 
1738
1671
def _add_numbers(a, b):
1912
1845
        self.assertIsInstance(2, int)
1913
1846
        self.assertIsInstance(u'', basestring)
1914
1847
        e = self.assertRaises(AssertionError, self.assertIsInstance, None, int)
1915
 
        self.assertEqual(str(e),
 
1848
        self.assertEquals(str(e),
1916
1849
            "None is an instance of <type 'NoneType'> rather than <type 'int'>")
1917
1850
        self.assertRaises(AssertionError, self.assertIsInstance, 23.3, int)
1918
1851
        e = self.assertRaises(AssertionError,
1919
1852
            self.assertIsInstance, None, int, "it's just not")
1920
 
        self.assertEqual(str(e),
 
1853
        self.assertEquals(str(e),
1921
1854
            "None is an instance of <type 'NoneType'> rather than <type 'int'>"
1922
1855
            ": it's just not")
1923
1856
 
1928
1861
    def test_assertEqualDiff(self):
1929
1862
        e = self.assertRaises(AssertionError,
1930
1863
                              self.assertEqualDiff, '', '\n')
1931
 
        self.assertEqual(str(e),
 
1864
        self.assertEquals(str(e),
1932
1865
                          # Don't blink ! The '+' applies to the second string
1933
1866
                          'first string is missing a final newline.\n+ \n')
1934
1867
        e = self.assertRaises(AssertionError,
1935
1868
                              self.assertEqualDiff, '\n', '')
1936
 
        self.assertEqual(str(e),
 
1869
        self.assertEquals(str(e),
1937
1870
                          # Don't blink ! The '-' applies to the second string
1938
1871
                          'second string is missing a final newline.\n- \n')
1939
1872
 
1996
1929
            warnings.warn("this is your last warning")
1997
1930
            return a + b
1998
1931
        wlist, result = self.callCatchWarnings(meth, 1, 2)
1999
 
        self.assertEqual(3, result)
 
1932
        self.assertEquals(3, result)
2000
1933
        # would like just to compare them, but UserWarning doesn't implement
2001
1934
        # eq well
2002
1935
        w0, = wlist
2003
1936
        self.assertIsInstance(w0, UserWarning)
2004
 
        self.assertEqual("this is your last warning", str(w0))
 
1937
        self.assertEquals("this is your last warning", str(w0))
2005
1938
 
2006
1939
 
2007
1940
class TestConvenienceMakers(tests.TestCaseWithTransport):
2010
1943
    def test_make_branch_and_tree_with_format(self):
2011
1944
        # we should be able to supply a format to make_branch_and_tree
2012
1945
        self.make_branch_and_tree('a', format=bzrlib.bzrdir.BzrDirMetaFormat1())
2013
 
        self.assertIsInstance(bzrlib.controldir.ControlDir.open('a')._format,
 
1946
        self.assertIsInstance(bzrlib.bzrdir.BzrDir.open('a')._format,
2014
1947
                              bzrlib.bzrdir.BzrDirMetaFormat1)
2015
1948
 
2016
1949
    def test_make_branch_and_memory_tree(self):
2028
1961
        tree = self.make_branch_and_tree('t1')
2029
1962
        base = tree.bzrdir.root_transport.base
2030
1963
        self.assertStartsWith(base, 'file://')
2031
 
        self.assertEqual(tree.bzrdir.root_transport,
 
1964
        self.assertEquals(tree.bzrdir.root_transport,
2032
1965
                tree.branch.bzrdir.root_transport)
2033
 
        self.assertEqual(tree.bzrdir.root_transport,
 
1966
        self.assertEquals(tree.bzrdir.root_transport,
2034
1967
                tree.branch.repository.bzrdir.root_transport)
2035
1968
 
2036
1969
 
2300
2233
        self.assertEqual(['rocks'], self.argv)
2301
2234
        self.assertEqual(34, self.retcode)
2302
2235
        self.assertEqual('It sure does!\n', out)
2303
 
        self.assertEqual(out, self.out)
 
2236
        self.assertEquals(out, self.out)
2304
2237
        self.assertEqual('', err)
2305
 
        self.assertEqual(err, self.err)
 
2238
        self.assertEquals(err, self.err)
2306
2239
 
2307
2240
    def test_run_bzr_error_regexes(self):
2308
2241
        self.out = ''
2448
2381
    """Base class for tests testing how we might run bzr."""
2449
2382
 
2450
2383
    def setUp(self):
2451
 
        super(TestWithFakedStartBzrSubprocess, self).setUp()
 
2384
        tests.TestCaseWithTransport.setUp(self)
2452
2385
        self.subprocess_calls = []
2453
2386
 
2454
2387
    def start_bzr_subprocess(self, process_args, env_changes=None,
2668
2601
class TestSelftestFiltering(tests.TestCase):
2669
2602
 
2670
2603
    def setUp(self):
2671
 
        super(TestSelftestFiltering, self).setUp()
 
2604
        tests.TestCase.setUp(self)
2672
2605
        self.suite = TestUtil.TestSuite()
2673
2606
        self.loader = TestUtil.TestLoader()
2674
2607
        self.suite.addTest(self.loader.loadTestsFromModule(
2847
2780
            self.run_bzr, ['assert-fail'])
2848
2781
        # make sure we got the real thing, not an error from somewhere else in
2849
2782
        # the test framework
2850
 
        self.assertEqual('always fails', str(e))
 
2783
        self.assertEquals('always fails', str(e))
2851
2784
        # check that there's no traceback in the test log
2852
2785
        self.assertNotContainsRe(self.get_log(), r'Traceback')
2853
2786
 
2902
2835
    def test_load_tests_from_module_name_smoke_test(self):
2903
2836
        loader = TestUtil.TestLoader()
2904
2837
        suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2905
 
        self.assertEqual(['bzrlib.tests.test_sampler.DemoTest.test_nothing'],
 
2838
        self.assertEquals(['bzrlib.tests.test_sampler.DemoTest.test_nothing'],
2906
2839
                          _test_ids(suite))
2907
2840
 
2908
2841
    def test_load_tests_from_module_name_with_bogus_module_name(self):
2937
2870
 
2938
2871
    def test_empty_list(self):
2939
2872
        id_list = self._create_id_list([])
2940
 
        self.assertEqual({}, id_list.tests)
2941
 
        self.assertEqual({}, id_list.modules)
 
2873
        self.assertEquals({}, id_list.tests)
 
2874
        self.assertEquals({}, id_list.modules)
2942
2875
 
2943
2876
    def test_valid_list(self):
2944
2877
        id_list = self._create_id_list(
2971
2904
        test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing',
2972
2905
                     'bogus']
2973
2906
        not_found, duplicates = tests.suite_matches_id_list(suite, test_list)
2974
 
        self.assertEqual(['bogus'], not_found)
2975
 
        self.assertEqual([], duplicates)
 
2907
        self.assertEquals(['bogus'], not_found)
 
2908
        self.assertEquals([], duplicates)
2976
2909
 
2977
2910
    def test_suite_matches_id_list_with_duplicates(self):
2978
2911
        loader = TestUtil.TestLoader()
2985
2918
        test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing',]
2986
2919
        not_found, duplicates = tests.suite_matches_id_list(
2987
2920
            dupes, test_list)
2988
 
        self.assertEqual([], not_found)
2989
 
        self.assertEqual(['bzrlib.tests.test_sampler.DemoTest.test_nothing'],
 
2921
        self.assertEquals([], not_found)
 
2922
        self.assertEquals(['bzrlib.tests.test_sampler.DemoTest.test_nothing'],
2990
2923
                          duplicates)
2991
2924
 
2992
2925
 
3065
2998
        suite = tests.test_suite(test_list,
3066
2999
                                 ['bzrlib.tests.test_selftest.TestTestSuite'])
3067
3000
        # test_test_suite_list_and_start is not included 
3068
 
        self.assertEqual(test_list, _test_ids(suite))
 
3001
        self.assertEquals(test_list, _test_ids(suite))
3069
3002
 
3070
3003
 
3071
3004
class TestLoadTestIdList(tests.TestCaseInTempDir):
3084
3017
        self._create_test_list_file(test_list_fname,
3085
3018
                                    'mod1.cl1.meth1\nmod2.cl2.meth2\n')
3086
3019
        tlist = tests.load_test_id_list(test_list_fname)
3087
 
        self.assertEqual(2, len(tlist))
3088
 
        self.assertEqual('mod1.cl1.meth1', tlist[0])
3089
 
        self.assertEqual('mod2.cl2.meth2', tlist[1])
 
3020
        self.assertEquals(2, len(tlist))
 
3021
        self.assertEquals('mod1.cl1.meth1', tlist[0])
 
3022
        self.assertEquals('mod2.cl2.meth2', tlist[1])
3090
3023
 
3091
3024
    def test_load_dirty_file(self):
3092
3025
        test_list_fname = 'test.list'
3094
3027
                                    '  mod1.cl1.meth1\n\nmod2.cl2.meth2  \n'
3095
3028
                                    'bar baz\n')
3096
3029
        tlist = tests.load_test_id_list(test_list_fname)
3097
 
        self.assertEqual(4, len(tlist))
3098
 
        self.assertEqual('mod1.cl1.meth1', tlist[0])
3099
 
        self.assertEqual('', tlist[1])
3100
 
        self.assertEqual('mod2.cl2.meth2', tlist[2])
3101
 
        self.assertEqual('bar baz', tlist[3])
 
3030
        self.assertEquals(4, len(tlist))
 
3031
        self.assertEquals('mod1.cl1.meth1', tlist[0])
 
3032
        self.assertEquals('', tlist[1])
 
3033
        self.assertEquals('mod2.cl2.meth2', tlist[2])
 
3034
        self.assertEquals('bar baz', tlist[3])
3102
3035
 
3103
3036
 
3104
3037
class TestFilteredByModuleTestLoader(tests.TestCase):
3112
3045
        test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing']
3113
3046
        loader = self._create_loader(test_list)
3114
3047
        suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
3115
 
        self.assertEqual(test_list, _test_ids(suite))
 
3048
        self.assertEquals(test_list, _test_ids(suite))
3116
3049
 
3117
3050
    def test_exclude_tests(self):
3118
3051
        test_list = ['bogus']
3119
3052
        loader = self._create_loader(test_list)
3120
3053
        suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
3121
 
        self.assertEqual([], _test_ids(suite))
 
3054
        self.assertEquals([], _test_ids(suite))
3122
3055
 
3123
3056
 
3124
3057
class TestFilteredByNameStartTestLoader(tests.TestCase):
3134
3067
        loader = self._create_loader('bzrlib.tests.test_samp')
3135
3068
 
3136
3069
        suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
3137
 
        self.assertEqual(test_list, _test_ids(suite))
 
3070
        self.assertEquals(test_list, _test_ids(suite))
3138
3071
 
3139
3072
    def test_load_tests_inside_module(self):
3140
3073
        test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing']
3141
3074
        loader = self._create_loader('bzrlib.tests.test_sampler.Demo')
3142
3075
 
3143
3076
        suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
3144
 
        self.assertEqual(test_list, _test_ids(suite))
 
3077
        self.assertEquals(test_list, _test_ids(suite))
3145
3078
 
3146
3079
    def test_exclude_tests(self):
3147
3080
        test_list = ['bogus']
3148
3081
        loader = self._create_loader('bogus')
3149
3082
 
3150
3083
        suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
3151
 
        self.assertEqual([], _test_ids(suite))
 
3084
        self.assertEquals([], _test_ids(suite))
3152
3085
 
3153
3086
 
3154
3087
class TestTestPrefixRegistry(tests.TestCase):
3160
3093
    def test_register_new_prefix(self):
3161
3094
        tpr = self._get_registry()
3162
3095
        tpr.register('foo', 'fff.ooo.ooo')
3163
 
        self.assertEqual('fff.ooo.ooo', tpr.get('foo'))
 
3096
        self.assertEquals('fff.ooo.ooo', tpr.get('foo'))
3164
3097
 
3165
3098
    def test_register_existing_prefix(self):
3166
3099
        tpr = self._get_registry()
3167
3100
        tpr.register('bar', 'bbb.aaa.rrr')
3168
3101
        tpr.register('bar', 'bBB.aAA.rRR')
3169
 
        self.assertEqual('bbb.aaa.rrr', tpr.get('bar'))
 
3102
        self.assertEquals('bbb.aaa.rrr', tpr.get('bar'))
3170
3103
        self.assertThat(self.get_log(),
3171
3104
            DocTestMatches("...bar...bbb.aaa.rrr...BB.aAA.rRR",
3172
3105
                           doctest.ELLIPSIS))
3178
3111
    def test_resolve_prefix(self):
3179
3112
        tpr = self._get_registry()
3180
3113
        tpr.register('bar', 'bb.aa.rr')
3181
 
        self.assertEqual('bb.aa.rr', tpr.resolve_alias('bar'))
 
3114
        self.assertEquals('bb.aa.rr', tpr.resolve_alias('bar'))
3182
3115
 
3183
3116
    def test_resolve_unknown_alias(self):
3184
3117
        tpr = self._get_registry()
3187
3120
 
3188
3121
    def test_predefined_prefixes(self):
3189
3122
        tpr = tests.test_prefix_alias_registry
3190
 
        self.assertEqual('bzrlib', tpr.resolve_alias('bzrlib'))
3191
 
        self.assertEqual('bzrlib.doc', tpr.resolve_alias('bd'))
3192
 
        self.assertEqual('bzrlib.utils', tpr.resolve_alias('bu'))
3193
 
        self.assertEqual('bzrlib.tests', tpr.resolve_alias('bt'))
3194
 
        self.assertEqual('bzrlib.tests.blackbox', tpr.resolve_alias('bb'))
3195
 
        self.assertEqual('bzrlib.plugins', tpr.resolve_alias('bp'))
 
3123
        self.assertEquals('bzrlib', tpr.resolve_alias('bzrlib'))
 
3124
        self.assertEquals('bzrlib.doc', tpr.resolve_alias('bd'))
 
3125
        self.assertEquals('bzrlib.utils', tpr.resolve_alias('bu'))
 
3126
        self.assertEquals('bzrlib.tests', tpr.resolve_alias('bt'))
 
3127
        self.assertEquals('bzrlib.tests.blackbox', tpr.resolve_alias('bb'))
 
3128
        self.assertEquals('bzrlib.plugins', tpr.resolve_alias('bp'))
3196
3129
 
3197
3130
 
3198
3131
class TestThreadLeakDetection(tests.TestCase):
3521
3454
            def test_me(self):
3522
3455
                # The first call save the 42 value
3523
3456
                self.overrideEnv('MYVAR', None)
3524
 
                self.assertEqual(None, os.environ.get('MYVAR'))
 
3457
                self.assertEquals(None, os.environ.get('MYVAR'))
3525
3458
                # Make sure we can call it twice
3526
3459
                self.overrideEnv('MYVAR', None)
3527
 
                self.assertEqual(None, os.environ.get('MYVAR'))
 
3460
                self.assertEquals(None, os.environ.get('MYVAR'))
3528
3461
        output = StringIO()
3529
3462
        result = tests.TextTestResult(output, 0, 1)
3530
3463
        Test('test_me').run(result)
3531
3464
        if not result.wasStrictlySuccessful():
3532
3465
            self.fail(output.getvalue())
3533
3466
        # We get our value back
3534
 
        self.assertEqual('42', os.environ.get('MYVAR'))
 
3467
        self.assertEquals('42', os.environ.get('MYVAR'))
3535
3468
 
3536
3469
 
3537
3470
class TestIsolatedEnv(tests.TestCase):
3553
3486
        # Make sure we know the definition of BZR_HOME: not part of os.environ
3554
3487
        # for tests.TestCase.
3555
3488
        self.assertTrue('BZR_HOME' in tests.isolated_environ)
3556
 
        self.assertEqual(None, tests.isolated_environ['BZR_HOME'])
 
3489
        self.assertEquals(None, tests.isolated_environ['BZR_HOME'])
3557
3490
        # Being part of isolated_environ, BZR_HOME should not appear here
3558
3491
        self.assertFalse('BZR_HOME' in os.environ)
3559
3492
        # Make sure we know the definition of LINES: part of os.environ for
3560
3493
        # tests.TestCase
3561
3494
        self.assertTrue('LINES' in tests.isolated_environ)
3562
 
        self.assertEqual('25', tests.isolated_environ['LINES'])
3563
 
        self.assertEqual('25', os.environ['LINES'])
 
3495
        self.assertEquals('25', tests.isolated_environ['LINES'])
 
3496
        self.assertEquals('25', os.environ['LINES'])
3564
3497
 
3565
3498
    def test_injecting_unknown_variable(self):
3566
3499
        # BZR_HOME is known to be absent from os.environ
3567
3500
        test = self.ScratchMonkey('test_me')
3568
3501
        tests.override_os_environ(test, {'BZR_HOME': 'foo'})
3569
 
        self.assertEqual('foo', os.environ['BZR_HOME'])
 
3502
        self.assertEquals('foo', os.environ['BZR_HOME'])
3570
3503
        tests.restore_os_environ(test)
3571
3504
        self.assertFalse('BZR_HOME' in os.environ)
3572
3505
 
3574
3507
        test = self.ScratchMonkey('test_me')
3575
3508
        # LINES is known to be present in os.environ
3576
3509
        tests.override_os_environ(test, {'LINES': '42'})
3577
 
        self.assertEqual('42', os.environ['LINES'])
 
3510
        self.assertEquals('42', os.environ['LINES'])
3578
3511
        tests.restore_os_environ(test)
3579
 
        self.assertEqual('25', os.environ['LINES'])
 
3512
        self.assertEquals('25', os.environ['LINES'])
3580
3513
 
3581
3514
    def test_deleting_variable(self):
3582
3515
        test = self.ScratchMonkey('test_me')
3584
3517
        tests.override_os_environ(test, {'LINES': None})
3585
3518
        self.assertTrue('LINES' not in os.environ)
3586
3519
        tests.restore_os_environ(test)
3587
 
        self.assertEqual('25', os.environ['LINES'])
 
3520
        self.assertEquals('25', os.environ['LINES'])
3588
3521
 
3589
3522
 
3590
3523
class TestDocTestSuiteIsolation(tests.TestCase):
3677
3610
        # test at the command level without loading the whole test suite
3678
3611
        out, err = self.run_bzr(('selftest', '--list') + selftest_args)
3679
3612
        actual = out.splitlines()
3680
 
        self.assertEqual(expected, actual)
 
3613
        self.assertEquals(expected, actual)
3681
3614
 
3682
3615
    def test_full_list(self):
3683
3616
        self.assertTestList(['a', 'b', 'c'])
3718
3651
        test.run(result)
3719
3652
        self.assertTrue(hasattr(test, '_counters'))
3720
3653
        self.assertTrue(test._counters.has_key('myhook'))
3721
 
        self.assertEqual(expected_calls, test._counters['myhook'])
 
3654
        self.assertEquals(expected_calls, test._counters['myhook'])
3722
3655
 
3723
3656
    def test_no_hook(self):
3724
3657
        self.assertHookCalls(0, 'no_hook')