/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_selftest.py

Merge with stacked-fixes

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_selftest.py
65
65
                          iter_suite_tests,
66
66
                          preserve_input,
67
67
                          randomize_suite,
68
 
                          sort_suite_by_re,
 
68
                          split_suite_by_condition,
69
69
                          split_suite_by_re,
70
70
                          test_lsprof,
71
71
                          test_suite,
77
77
from bzrlib.version import _get_bzr_source_tree
78
78
 
79
79
 
 
80
def _test_ids(test_suite):
 
81
    """Get the ids for the tests in a test suite."""
 
82
    return [t.id() for t in iter_suite_tests(test_suite)]
 
83
 
 
84
 
80
85
class SelftestTests(TestCase):
81
86
 
82
87
    def test_import_tests(self):
121
126
    """
122
127
 
123
128
    def test_get_transport_permutations(self):
124
 
        # this checks that we the module get_test_permutations call
125
 
        # is made by the adapter get_transport_test_permitations method.
 
129
        # this checks that get_test_permutations defined by the module is
 
130
        # called by the adapter get_transport_test_permutations method.
126
131
        class MockModule(object):
127
132
            def get_test_permutations(self):
128
133
                return sample_permutation
134
139
                         adapter.get_transport_test_permutations(MockModule()))
135
140
 
136
141
    def test_adapter_checks_all_modules(self):
137
 
        # this checks that the adapter returns as many permurtations as
138
 
        # there are in all the registered# transport modules for there
139
 
        # - we assume if this matches its probably doing the right thing
140
 
        # especially in combination with the tests for setting the right
141
 
        # classes below.
 
142
        # this checks that the adapter returns as many permutations as there
 
143
        # are in all the registered transport modules - we assume if this
 
144
        # matches its probably doing the right thing especially in combination
 
145
        # with the tests for setting the right classes below.
142
146
        from bzrlib.tests.test_transport_implementations \
143
147
            import TransportTestProviderAdapter
144
148
        from bzrlib.transport import _get_transport_modules
357
361
        formats = [(str, "C1", "C2"), (int, "D1", "D2")]
358
362
        adapter = InterRepositoryTestProviderAdapter(server1, server2, formats)
359
363
        self.assertEqual([
360
 
            ('str',
 
364
            ('str,str,str',
361
365
             {'interrepo_class': str,
362
366
              'repository_format': 'C1',
363
367
              'repository_format_to': 'C2',
364
368
              'transport_readonly_server': 'b',
365
369
              'transport_server': 'a'}),
366
 
            ('int',
 
370
            ('int,str,str',
367
371
             {'interrepo_class': int,
368
372
              'repository_format': 'D1',
369
373
              'repository_format_to': 'D2',
478
482
        adapter = TreeTestProviderAdapter(server1, server2, formats)
479
483
        suite = adapter.adapt(input_test)
480
484
        tests = list(iter(suite))
481
 
        self.assertEqual(4, len(tests))
 
485
        # XXX We should not have tests fail as we add more scenarios
 
486
        # abentley 20080412
 
487
        self.assertEqual(5, len(tests))
482
488
        # this must match the default format setp up in
483
489
        # TreeTestProviderAdapter.adapt
484
490
        default_format = WorkingTreeFormat3
486
492
        self.assertEqual(tests[0].bzrdir_format, formats[0][1])
487
493
        self.assertEqual(tests[0].transport_server, server1)
488
494
        self.assertEqual(tests[0].transport_readonly_server, server2)
489
 
        self.assertEqual(tests[0].workingtree_to_test_tree, return_parameter)
 
495
        self.assertEqual(tests[0]._workingtree_to_test_tree, return_parameter)
490
496
        self.assertEqual(tests[1].workingtree_format, formats[1][0])
491
497
        self.assertEqual(tests[1].bzrdir_format, formats[1][1])
492
498
        self.assertEqual(tests[1].transport_server, server1)
493
499
        self.assertEqual(tests[1].transport_readonly_server, server2)
494
 
        self.assertEqual(tests[1].workingtree_to_test_tree, return_parameter)
 
500
        self.assertEqual(tests[1]._workingtree_to_test_tree, return_parameter)
495
501
        self.assertIsInstance(tests[2].workingtree_format, default_format)
496
502
        #self.assertEqual(tests[2].bzrdir_format,
497
503
        #                 default_format._matchingbzrdir)
498
504
        self.assertEqual(tests[2].transport_server, server1)
499
505
        self.assertEqual(tests[2].transport_readonly_server, server2)
500
 
        self.assertEqual(tests[2].workingtree_to_test_tree,
 
506
        self.assertEqual(tests[2]._workingtree_to_test_tree,
501
507
            revision_tree_from_workingtree)
502
508
 
503
509
 
538
544
        self.assertEqual(tests[0].workingtree_format, formats[0][1])
539
545
        self.assertEqual(tests[0].workingtree_format_to, formats[0][2])
540
546
        self.assertEqual(tests[0].mutable_trees_to_test_trees, formats[0][3])
541
 
        self.assertEqual(tests[0].workingtree_to_test_tree, return_parameter)
 
547
        self.assertEqual(tests[0]._workingtree_to_test_tree, return_parameter)
542
548
        self.assertEqual(tests[0].transport_server, server1)
543
549
        self.assertEqual(tests[0].transport_readonly_server, server2)
544
550
        self.assertEqual(tests[1].intertree_class, formats[1][0])
545
551
        self.assertEqual(tests[1].workingtree_format, formats[1][1])
546
552
        self.assertEqual(tests[1].workingtree_format_to, formats[1][2])
547
553
        self.assertEqual(tests[1].mutable_trees_to_test_trees, formats[1][3])
548
 
        self.assertEqual(tests[1].workingtree_to_test_tree, return_parameter)
 
554
        self.assertEqual(tests[1]._workingtree_to_test_tree, return_parameter)
549
555
        self.assertEqual(tests[1].transport_server, server1)
550
556
        self.assertEqual(tests[1].transport_readonly_server, server2)
551
557
 
897
903
        test.run(result)
898
904
        self.assertEqual(
899
905
            [
900
 
            ('update', '[2 in 0s, 3 known failures] passing_test', None, None),
 
906
            ('update', '[2 in 0s] passing_test', None, None),
901
907
            ],
902
908
            pb.calls[2:])
903
909
 
973
979
        test.run(result)
974
980
        self.assertEqual(
975
981
            [
976
 
            ('update', '[2 in 0s, 2 missing features] passing_test', None, None),
 
982
            ('update', '[2 in 0s, 2 missing] passing_test', None, None),
977
983
            ],
978
984
            pb.calls[1:])
979
985
    
1024
1030
        self.assertEqual(None, result._extractBenchmarkTime(test))
1025
1031
 
1026
1032
 
 
1033
class TestUnicodeFilenameFeature(TestCase):
 
1034
 
 
1035
    def test_probe_passes(self):
 
1036
        """UnicodeFilenameFeature._probe passes."""
 
1037
        # We can't test much more than that because the behaviour depends
 
1038
        # on the platform.
 
1039
        tests.UnicodeFilenameFeature._probe()
 
1040
 
 
1041
 
1027
1042
class TestRunner(TestCase):
1028
1043
 
1029
1044
    def dummy_test(self):
1101
1116
        self.assertTrue(result.wasSuccessful())
1102
1117
 
1103
1118
    def test_skipped_from_setup(self):
 
1119
        calls = []
1104
1120
        class SkippedSetupTest(TestCase):
1105
1121
 
1106
1122
            def setUp(self):
1107
 
                self.counter = 1
 
1123
                calls.append('setUp')
1108
1124
                self.addCleanup(self.cleanup)
1109
1125
                raise TestSkipped('skipped setup')
1110
1126
 
1112
1128
                self.fail('test reached')
1113
1129
 
1114
1130
            def cleanup(self):
1115
 
                self.counter -= 1
 
1131
                calls.append('cleanup')
1116
1132
 
1117
1133
        runner = TextTestRunner(stream=self._log_file)
1118
1134
        test = SkippedSetupTest('test_skip')
1119
1135
        result = self.run_test_runner(runner, test)
1120
1136
        self.assertTrue(result.wasSuccessful())
1121
1137
        # Check if cleanup was called the right number of times.
1122
 
        self.assertEqual(0, test.counter)
 
1138
        self.assertEqual(['setUp', 'cleanup'], calls)
1123
1139
 
1124
1140
    def test_skipped_from_test(self):
 
1141
        calls = []
1125
1142
        class SkippedTest(TestCase):
1126
1143
 
1127
1144
            def setUp(self):
1128
 
                self.counter = 1
 
1145
                calls.append('setUp')
1129
1146
                self.addCleanup(self.cleanup)
1130
1147
 
1131
1148
            def test_skip(self):
1132
1149
                raise TestSkipped('skipped test')
1133
1150
 
1134
1151
            def cleanup(self):
1135
 
                self.counter -= 1
 
1152
                calls.append('cleanup')
1136
1153
 
1137
1154
        runner = TextTestRunner(stream=self._log_file)
1138
1155
        test = SkippedTest('test_skip')
1139
1156
        result = self.run_test_runner(runner, test)
1140
1157
        self.assertTrue(result.wasSuccessful())
1141
1158
        # Check if cleanup was called the right number of times.
1142
 
        self.assertEqual(0, test.counter)
 
1159
        self.assertEqual(['setUp', 'cleanup'], calls)
1143
1160
 
1144
1161
    def test_not_applicable(self):
1145
1162
        # run a test that is skipped because it's not applicable
1702
1719
        self.loader = TestUtil.TestLoader()
1703
1720
        self.suite.addTest(self.loader.loadTestsFromModuleNames([
1704
1721
            'bzrlib.tests.test_selftest']))
1705
 
        self.all_names = self._test_ids(self.suite)
1706
 
 
1707
 
    def _test_ids(self, test_suite):
1708
 
        """Get the ids for the tests in a test suite."""
1709
 
        return [t.id() for t in iter_suite_tests(test_suite)]
 
1722
        self.all_names = _test_ids(self.suite)
1710
1723
 
1711
1724
    def test_condition_id_re(self):
1712
1725
        test_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1713
1726
            'test_condition_id_re')
1714
1727
        filtered_suite = filter_suite_by_condition(self.suite,
1715
1728
            condition_id_re('test_condition_id_re'))
1716
 
        self.assertEqual([test_name], self._test_ids(filtered_suite))
 
1729
        self.assertEqual([test_name], _test_ids(filtered_suite))
1717
1730
 
1718
1731
    def test_condition_id_in_list(self):
1719
1732
        test_names = ['bzrlib.tests.test_selftest.TestSelftestFiltering.'
1723
1736
            self.suite, tests.condition_id_in_list(id_list))
1724
1737
        my_pattern = 'TestSelftestFiltering.*test_condition_id_in_list'
1725
1738
        re_filtered = filter_suite_by_re(self.suite, my_pattern)
1726
 
        self.assertEqual(self._test_ids(re_filtered),
1727
 
                         self._test_ids(filtered_suite))
 
1739
        self.assertEqual(_test_ids(re_filtered), _test_ids(filtered_suite))
 
1740
 
 
1741
    def test_condition_id_startswith(self):
 
1742
        klass = 'bzrlib.tests.test_selftest.TestSelftestFiltering.'
 
1743
        start = klass + 'test_condition_id_starts'
 
1744
        test_names = [klass + 'test_condition_id_startswith']
 
1745
        filtered_suite = filter_suite_by_condition(
 
1746
            self.suite, tests.condition_id_startswith(start))
 
1747
        my_pattern = 'TestSelftestFiltering.*test_condition_id_startswith'
 
1748
        re_filtered = filter_suite_by_re(self.suite, my_pattern)
 
1749
        self.assertEqual(_test_ids(re_filtered), _test_ids(filtered_suite))
1728
1750
 
1729
1751
    def test_condition_isinstance(self):
1730
1752
        filtered_suite = filter_suite_by_condition(self.suite,
1731
1753
            condition_isinstance(self.__class__))
1732
1754
        class_pattern = 'bzrlib.tests.test_selftest.TestSelftestFiltering.'
1733
1755
        re_filtered = filter_suite_by_re(self.suite, class_pattern)
1734
 
        self.assertEqual(self._test_ids(re_filtered),
1735
 
            self._test_ids(filtered_suite))
 
1756
        self.assertEqual(_test_ids(re_filtered), _test_ids(filtered_suite))
1736
1757
 
1737
1758
    def test_exclude_tests_by_condition(self):
1738
1759
        excluded_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1741
1762
            lambda x:x.id() == excluded_name)
1742
1763
        self.assertEqual(len(self.all_names) - 1,
1743
1764
            filtered_suite.countTestCases())
1744
 
        self.assertFalse(excluded_name in self._test_ids(filtered_suite))
 
1765
        self.assertFalse(excluded_name in _test_ids(filtered_suite))
1745
1766
        remaining_names = list(self.all_names)
1746
1767
        remaining_names.remove(excluded_name)
1747
 
        self.assertEqual(remaining_names, self._test_ids(filtered_suite))
 
1768
        self.assertEqual(remaining_names, _test_ids(filtered_suite))
1748
1769
 
1749
1770
    def test_exclude_tests_by_re(self):
1750
 
        self.all_names = self._test_ids(self.suite)
 
1771
        self.all_names = _test_ids(self.suite)
1751
1772
        filtered_suite = exclude_tests_by_re(self.suite, 'exclude_tests_by_re')
1752
1773
        excluded_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1753
1774
            'test_exclude_tests_by_re')
1754
1775
        self.assertEqual(len(self.all_names) - 1,
1755
1776
            filtered_suite.countTestCases())
1756
 
        self.assertFalse(excluded_name in self._test_ids(filtered_suite))
 
1777
        self.assertFalse(excluded_name in _test_ids(filtered_suite))
1757
1778
        remaining_names = list(self.all_names)
1758
1779
        remaining_names.remove(excluded_name)
1759
 
        self.assertEqual(remaining_names, self._test_ids(filtered_suite))
 
1780
        self.assertEqual(remaining_names, _test_ids(filtered_suite))
1760
1781
 
1761
1782
    def test_filter_suite_by_condition(self):
1762
1783
        test_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1763
1784
            'test_filter_suite_by_condition')
1764
1785
        filtered_suite = filter_suite_by_condition(self.suite,
1765
1786
            lambda x:x.id() == test_name)
1766
 
        self.assertEqual([test_name], self._test_ids(filtered_suite))
 
1787
        self.assertEqual([test_name], _test_ids(filtered_suite))
1767
1788
 
1768
1789
    def test_filter_suite_by_re(self):
1769
1790
        filtered_suite = filter_suite_by_re(self.suite, 'test_filter_suite_by_r')
1770
 
        filtered_names = self._test_ids(filtered_suite)
 
1791
        filtered_names = _test_ids(filtered_suite)
1771
1792
        self.assertEqual(filtered_names, ['bzrlib.tests.test_selftest.'
1772
1793
            'TestSelftestFiltering.test_filter_suite_by_re'])
1773
1794
 
1776
1797
                     'TestSelftestFiltering.test_filter_suite_by_id_list']
1777
1798
        filtered_suite = tests.filter_suite_by_id_list(
1778
1799
            self.suite, tests.TestIdList(test_list))
1779
 
        filtered_names = self._test_ids(filtered_suite)
 
1800
        filtered_names = _test_ids(filtered_suite)
1780
1801
        self.assertEqual(
1781
1802
            filtered_names,
1782
1803
            ['bzrlib.tests.test_selftest.'
1783
1804
             'TestSelftestFiltering.test_filter_suite_by_id_list'])
1784
1805
 
 
1806
    def test_filter_suite_by_id_startswith(self):
 
1807
        # By design this test may fail if another test is added whose name also
 
1808
        # begins with the start value used.
 
1809
        klass = 'bzrlib.tests.test_selftest.TestSelftestFiltering.'
 
1810
        start = klass + 'test_filter_suite_by_id_starts'
 
1811
        test_list = [klass + 'test_filter_suite_by_id_startswith']
 
1812
        filtered_suite = tests.filter_suite_by_id_startswith(self.suite, start)
 
1813
        filtered_names = _test_ids(filtered_suite)
 
1814
        self.assertEqual(
 
1815
            filtered_names,
 
1816
            ['bzrlib.tests.test_selftest.'
 
1817
             'TestSelftestFiltering.test_filter_suite_by_id_startswith'])
 
1818
 
1785
1819
    def test_preserve_input(self):
1786
1820
        # NB: Surely this is something in the stdlib to do this?
1787
1821
        self.assertTrue(self.suite is preserve_input(self.suite))
1790
1824
    def test_randomize_suite(self):
1791
1825
        randomized_suite = randomize_suite(self.suite)
1792
1826
        # randomizing should not add or remove test names.
1793
 
        self.assertEqual(set(self._test_ids(self.suite)),
1794
 
            set(self._test_ids(randomized_suite)))
 
1827
        self.assertEqual(set(_test_ids(self.suite)),
 
1828
                         set(_test_ids(randomized_suite)))
1795
1829
        # Technically, this *can* fail, because random.shuffle(list) can be
1796
1830
        # equal to list. Trying multiple times just pushes the frequency back.
1797
1831
        # As its len(self.all_names)!:1, the failure frequency should be low
1798
1832
        # enough to ignore. RBC 20071021.
1799
1833
        # It should change the order.
1800
 
        self.assertNotEqual(self.all_names, self._test_ids(randomized_suite))
 
1834
        self.assertNotEqual(self.all_names, _test_ids(randomized_suite))
1801
1835
        # But not the length. (Possibly redundant with the set test, but not
1802
1836
        # necessarily.)
1803
 
        self.assertEqual(len(self.all_names),
1804
 
            len(self._test_ids(randomized_suite)))
 
1837
        self.assertEqual(len(self.all_names), len(_test_ids(randomized_suite)))
1805
1838
 
1806
 
    def test_sort_suite_by_re(self):
1807
 
        sorted_suite = self.applyDeprecated(one_zero,
1808
 
            sort_suite_by_re, self.suite, 'test_filter_suite_by_r')
1809
 
        sorted_names = self._test_ids(sorted_suite)
1810
 
        self.assertEqual(sorted_names[0], 'bzrlib.tests.test_selftest.'
1811
 
            'TestSelftestFiltering.test_filter_suite_by_re')
1812
 
        self.assertEquals(sorted(self.all_names), sorted(sorted_names))
 
1839
    def test_split_suit_by_condition(self):
 
1840
        self.all_names = _test_ids(self.suite)
 
1841
        condition = condition_id_re('test_filter_suite_by_r')
 
1842
        split_suite = split_suite_by_condition(self.suite, condition)
 
1843
        filtered_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
 
1844
            'test_filter_suite_by_re')
 
1845
        self.assertEqual([filtered_name], _test_ids(split_suite[0]))
 
1846
        self.assertFalse(filtered_name in _test_ids(split_suite[1]))
 
1847
        remaining_names = list(self.all_names)
 
1848
        remaining_names.remove(filtered_name)
 
1849
        self.assertEqual(remaining_names, _test_ids(split_suite[1]))
1813
1850
 
1814
1851
    def test_split_suit_by_re(self):
1815
 
        self.all_names = self._test_ids(self.suite)
 
1852
        self.all_names = _test_ids(self.suite)
1816
1853
        split_suite = split_suite_by_re(self.suite, 'test_filter_suite_by_r')
1817
1854
        filtered_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1818
1855
            'test_filter_suite_by_re')
1819
 
        self.assertEqual([filtered_name], self._test_ids(split_suite[0]))
1820
 
        self.assertFalse(filtered_name in self._test_ids(split_suite[1]))
 
1856
        self.assertEqual([filtered_name], _test_ids(split_suite[0]))
 
1857
        self.assertFalse(filtered_name in _test_ids(split_suite[1]))
1821
1858
        remaining_names = list(self.all_names)
1822
1859
        remaining_names.remove(filtered_name)
1823
 
        self.assertEqual(remaining_names, self._test_ids(split_suite[1]))
 
1860
        self.assertEqual(remaining_names, _test_ids(split_suite[1]))
1824
1861
 
1825
1862
 
1826
1863
class TestCheckInventoryShape(TestCaseWithTransport):
1897
1934
        module.__class__.load_tests = load_tests
1898
1935
        self.assertEqual(2, loader.loadTestsFromModule(module).countTestCases())
1899
1936
 
 
1937
    def test_load_tests_from_module_name_smoke_test(self):
 
1938
        loader = TestUtil.TestLoader()
 
1939
        suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
 
1940
        self.assertEquals(['bzrlib.tests.test_sampler.DemoTest.test_nothing'],
 
1941
                          _test_ids(suite))
 
1942
 
 
1943
    def test_load_tests_from_module_name_with_bogus_module_name(self):
 
1944
        loader = TestUtil.TestLoader()
 
1945
        self.assertRaises(ImportError, loader.loadTestsFromModuleName, 'bogus')
 
1946
 
1900
1947
 
1901
1948
class TestTestIdList(tests.TestCase):
1902
1949
 
1935
1982
             'mod1.submod1',
1936
1983
             'mod1.submod2.cl1.meth1', 'mod1.submod2.cl2.meth2',
1937
1984
             ])
1938
 
        self.assertTrue(id_list.is_module_name_used('mod1'))
1939
 
        self.assertTrue(id_list.is_module_name_used('mod1.submod1'))
1940
 
        self.assertTrue(id_list.is_module_name_used('mod1.submod2'))
1941
 
        self.assertTrue(id_list.test_in('mod1.cl1.meth1'))
1942
 
        self.assertTrue(id_list.test_in('mod1.submod1'))
1943
 
        self.assertTrue(id_list.test_in('mod1.func1'))
 
1985
        self.assertTrue(id_list.refers_to('mod1'))
 
1986
        self.assertTrue(id_list.refers_to('mod1.submod1'))
 
1987
        self.assertTrue(id_list.refers_to('mod1.submod2'))
 
1988
        self.assertTrue(id_list.includes('mod1.cl1.meth1'))
 
1989
        self.assertTrue(id_list.includes('mod1.submod1'))
 
1990
        self.assertTrue(id_list.includes('mod1.func1'))
1944
1991
 
1945
1992
    def test_bad_chars_in_params(self):
1946
1993
        id_list = self._create_id_list(['mod1.cl1.meth1(xx.yy)'])
1947
 
        self.assertTrue(id_list.is_module_name_used('mod1'))
1948
 
        self.assertTrue(id_list.test_in('mod1.cl1.meth1(xx.yy)'))
 
1994
        self.assertTrue(id_list.refers_to('mod1'))
 
1995
        self.assertTrue(id_list.includes('mod1.cl1.meth1(xx.yy)'))
1949
1996
 
1950
1997
    def test_module_used(self):
1951
1998
        id_list = self._create_id_list(['mod.class.meth'])
1952
 
        self.assertTrue(id_list.is_module_name_used('mod'))
1953
 
        self.assertTrue(id_list.is_module_name_used('mod.class'))
1954
 
        self.assertTrue(id_list.is_module_name_used('mod.class.meth'))
 
1999
        self.assertTrue(id_list.refers_to('mod'))
 
2000
        self.assertTrue(id_list.refers_to('mod.class'))
 
2001
        self.assertTrue(id_list.refers_to('mod.class.meth'))
1955
2002
 
1956
2003
    def test_test_suite(self):
1957
2004
        # This test is slow, so we do a single test with one test in each
1958
2005
        # category
1959
2006
        test_list = [
1960
2007
            # testmod_names
 
2008
            'bzrlib.tests.blackbox.test_branch.TestBranch.test_branch',
1961
2009
            'bzrlib.tests.test_selftest.TestTestIdList.test_test_suite',
1962
2010
            # transport implementations
1963
2011
            'bzrlib.tests.test_transport_implementations.TransportTests'
1964
2012
            '.test_abspath(LocalURLServer)',
1965
 
            # packages_to_test()
1966
 
            'bzrlib.tests.blackbox.test_branch.TestBranch.test_branch',
1967
 
            # MODULES_TO_DOCTEST
 
2013
            # modules_to_doctest
1968
2014
            'bzrlib.timestamp.format_highres_date',
1969
2015
            # plugins can't be tested that way since selftest may be run with
1970
2016
            # --no-plugins
1971
2017
            ]
1972
2018
        suite = tests.test_suite(test_list)
1973
 
        self.assertEquals(test_list, self._test_ids(suite))
 
2019
        self.assertEquals(test_list, _test_ids(suite))
 
2020
 
 
2021
    def test_test_suite_matches_id_list_with_unknown(self):
 
2022
        loader = TestUtil.TestLoader()
 
2023
        suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
 
2024
        test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing',
 
2025
                     'bogus']
 
2026
        not_found, duplicates = tests.suite_matches_id_list(suite, test_list)
 
2027
        self.assertEquals(['bogus'], not_found)
 
2028
        self.assertEquals([], duplicates)
 
2029
 
 
2030
    def test_suite_matches_id_list_with_duplicates(self):
 
2031
        loader = TestUtil.TestLoader()
 
2032
        suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
 
2033
        dupes = loader.suiteClass()
 
2034
        for test in iter_suite_tests(suite):
 
2035
            dupes.addTest(test)
 
2036
            dupes.addTest(test) # Add it again
 
2037
 
 
2038
        test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing',]
 
2039
        not_found, duplicates = tests.suite_matches_id_list(
 
2040
            dupes, test_list)
 
2041
        self.assertEquals([], not_found)
 
2042
        self.assertEquals(['bzrlib.tests.test_sampler.DemoTest.test_nothing'],
 
2043
                          duplicates)
1974
2044
 
1975
2045
 
1976
2046
class TestLoadTestIdList(tests.TestCaseInTempDir):
2006
2076
        self.assertEquals('bar baz', tlist[3])
2007
2077
 
2008
2078
 
 
2079
class TestFilteredByModuleTestLoader(tests.TestCase):
 
2080
 
 
2081
    def _create_loader(self, test_list):
 
2082
        id_filter = tests.TestIdList(test_list)
 
2083
        loader = TestUtil.FilteredByModuleTestLoader(id_filter.refers_to)
 
2084
        return loader
 
2085
 
 
2086
    def test_load_tests(self):
 
2087
        test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing']
 
2088
        loader = self._create_loader(test_list)
 
2089
 
 
2090
        suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
 
2091
        self.assertEquals(test_list, _test_ids(suite))
 
2092
 
 
2093
    def test_exclude_tests(self):
 
2094
        test_list = ['bogus']
 
2095
        loader = self._create_loader(test_list)
 
2096
 
 
2097
        suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
 
2098
        self.assertEquals([], _test_ids(suite))
 
2099
 
 
2100
 
 
2101
class TestFilteredByNameStartTestLoader(tests.TestCase):
 
2102
 
 
2103
    def _create_loader(self, name_start):
 
2104
        def needs_module(name):
 
2105
            return name.startswith(name_start) or name_start.startswith(name)
 
2106
        loader = TestUtil.FilteredByModuleTestLoader(needs_module)
 
2107
        return loader
 
2108
 
 
2109
    def test_load_tests(self):
 
2110
        test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing']
 
2111
        loader = self._create_loader('bzrlib.tests.test_samp')
 
2112
 
 
2113
        suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
 
2114
        self.assertEquals(test_list, _test_ids(suite))
 
2115
 
 
2116
    def test_load_tests_inside_module(self):
 
2117
        test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing']
 
2118
        loader = self._create_loader('bzrlib.tests.test_sampler.Demo')
 
2119
 
 
2120
        suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
 
2121
        self.assertEquals(test_list, _test_ids(suite))
 
2122
 
 
2123
    def test_exclude_tests(self):
 
2124
        test_list = ['bogus']
 
2125
        loader = self._create_loader('bogus')
 
2126
 
 
2127
        suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
 
2128
        self.assertEquals([], _test_ids(suite))