489
490
self.assertEqualStat(real, fake)
491
492
def test_assertEqualStat_notequal(self):
492
self.build_tree(["foo", "bar"])
493
self.build_tree(["foo", "longname"])
493
494
self.assertRaises(AssertionError, self.assertEqualStat,
494
os.lstat("foo"), os.lstat("bar"))
495
os.lstat("foo"), os.lstat("longname"))
497
498
class TestTestCaseWithMemoryTransport(tests.TestCaseWithMemoryTransport):
515
516
cwd = osutils.getcwd()
516
517
self.assertIsSameRealPath(self.test_dir, cwd)
519
def test_BZR_HOME_and_HOME_are_bytestrings(self):
520
"""The $BZR_HOME and $HOME environment variables should not be unicode.
522
See https://bugs.launchpad.net/bzr/+bug/464174
524
self.assertIsInstance(os.environ['BZR_HOME'], str)
525
self.assertIsInstance(os.environ['HOME'], str)
518
527
def test_make_branch_and_memory_tree(self):
519
528
"""In TestCaseWithMemoryTransport we should not make the branch on disk.
576
585
self.get_transport().get_bytes(
577
586
'dir/.bzr/repository/format'))
579
def test_safety_net(self):
580
"""No test should modify the safety .bzr directory.
582
We just test that the _check_safety_net private method raises
583
AssertionError, it's easier than building a test suite with the same
586
# Oops, a commit in the current directory (i.e. without local .bzr
587
# directory) will crawl up the hierarchy to find a .bzr directory.
588
self.run_bzr(['commit', '-mfoo', '--unchanged'])
589
# But we have a safety net in place.
590
self.assertRaises(AssertionError, self._check_safety_net)
592
588
def test_dangling_locks_cause_failures(self):
593
589
class TestDanglingLock(tests.TestCaseWithMemoryTransport):
594
590
def test_function(self):
687
683
self.assertEqual(url, t.clone('..').base)
686
class TestProfileResult(tests.TestCase):
688
def test_profiles_tests(self):
689
self.requireFeature(test_lsprof.LSProfFeature)
690
terminal = unittest.TestResult()
691
result = tests.ProfileResult(terminal)
692
class Sample(tests.TestCase):
694
self.sample_function()
695
def sample_function(self):
698
test.attrs_to_keep = test.attrs_to_keep + ('_benchcalls',)
700
self.assertLength(1, test._benchcalls)
701
# We must be able to unpack it as the test reporting code wants
702
(_, _, _), stats = test._benchcalls[0]
703
self.assertTrue(callable(stats.pprint))
690
706
class TestTestResult(tests.TestCase):
692
708
def check_timing(self, test_case, expected_re):
719
735
self.check_timing(ShortDelayTestCase('test_short_delay'),
738
def _patch_get_bzr_source_tree(self):
739
# Reading from the actual source tree breaks isolation, but we don't
740
# want to assume that thats *all* that would happen.
741
def _get_bzr_source_tree():
743
orig_get_bzr_source_tree = bzrlib.version._get_bzr_source_tree
744
bzrlib.version._get_bzr_source_tree = _get_bzr_source_tree
746
bzrlib.version._get_bzr_source_tree = orig_get_bzr_source_tree
747
self.addCleanup(restore)
722
749
def test_assigned_benchmark_file_stores_date(self):
750
self._patch_get_bzr_source_tree()
723
751
output = StringIO()
724
752
result = bzrlib.tests.TextTestResult(self._log_file,
800
829
def test_known_failure(self):
801
830
"""A KnownFailure being raised should trigger several result actions."""
802
831
class InstrumentedTestResult(tests.ExtendedTestResult):
832
def stopTestRun(self): pass
804
833
def startTests(self): pass
805
834
def report_test_start(self, test): pass
806
835
def report_known_failure(self, test, err):
807
836
self._call = test, err
808
837
result = InstrumentedTestResult(None, None, None, None)
810
raise tests.KnownFailure('failed!')
811
test = unittest.FunctionTestCase(test_function)
838
class Test(tests.TestCase):
839
def test_function(self):
840
raise tests.KnownFailure('failed!')
841
test = Test("test_function")
813
843
# it should invoke 'report_known_failure'.
814
844
self.assertEqual(2, len(result._call))
898
928
def test_unavailable_exception(self):
899
929
"""An UnavailableFeature being raised should invoke addNotSupported."""
900
930
class InstrumentedTestResult(tests.ExtendedTestResult):
931
def stopTestRun(self): pass
902
932
def startTests(self): pass
903
933
def report_test_start(self, test): pass
904
934
def addNotSupported(self, test, feature):
905
935
self._call = test, feature
906
936
result = InstrumentedTestResult(None, None, None, None)
907
937
feature = tests.Feature()
909
raise tests.UnavailableFeature(feature)
910
test = unittest.FunctionTestCase(test_function)
938
class Test(tests.TestCase):
939
def test_function(self):
940
raise tests.UnavailableFeature(feature)
941
test = Test("test_function")
912
943
# it should invoke 'addNotSupported'.
913
944
self.assertEqual(2, len(result._call))
981
1012
because of our use of global state.
983
1014
old_root = tests.TestCaseInTempDir.TEST_ROOT
1015
old_leak = tests.TestCase._first_thread_leaker_id
985
1017
tests.TestCaseInTempDir.TEST_ROOT = None
1018
tests.TestCase._first_thread_leaker_id = None
986
1019
return testrunner.run(test)
988
1021
tests.TestCaseInTempDir.TEST_ROOT = old_root
1022
tests.TestCase._first_thread_leaker_id = old_leak
990
1024
def test_known_failure_failed_run(self):
991
1025
# run a test that generates a known failure which should be printed in
992
1026
# the final output when real failures occur.
993
def known_failure_test():
994
raise tests.KnownFailure('failed')
1027
class Test(tests.TestCase):
1028
def known_failure_test(self):
1029
raise tests.KnownFailure('failed')
995
1030
test = unittest.TestSuite()
996
test.addTest(unittest.FunctionTestCase(known_failure_test))
1031
test.addTest(Test("known_failure_test"))
997
1032
def failing_test():
998
1033
raise AssertionError('foo')
999
1034
test.addTest(unittest.FunctionTestCase(failing_test))
1019
1054
def test_known_failure_ok_run(self):
1020
# run a test that generates a known failure which should be printed in the final output.
1021
def known_failure_test():
1022
raise tests.KnownFailure('failed')
1023
test = unittest.FunctionTestCase(known_failure_test)
1055
# run a test that generates a known failure which should be printed in
1057
class Test(tests.TestCase):
1058
def known_failure_test(self):
1059
raise tests.KnownFailure('failed')
1060
test = Test("known_failure_test")
1024
1061
stream = StringIO()
1025
1062
runner = tests.TextTestRunner(stream=stream)
1026
1063
result = self.run_test_runner(runner, test)
1032
1069
'OK \\(known_failures=1\\)\n')
1071
def test_result_decorator(self):
1074
class LoggingDecorator(tests.ForwardingResult):
1075
def startTest(self, test):
1076
tests.ForwardingResult.startTest(self, test)
1077
calls.append('start')
1078
test = unittest.FunctionTestCase(lambda:None)
1080
runner = tests.TextTestRunner(stream=stream,
1081
result_decorators=[LoggingDecorator])
1082
result = self.run_test_runner(runner, test)
1083
self.assertLength(1, calls)
1034
1085
def test_skipped_test(self):
1035
1086
# run a test that is skipped, and check the suite as a whole still
1090
1141
def test_not_applicable(self):
1091
1142
# run a test that is skipped because it's not applicable
1092
def not_applicable_test():
1093
raise tests.TestNotApplicable('this test never runs')
1143
class Test(tests.TestCase):
1144
def not_applicable_test(self):
1145
raise tests.TestNotApplicable('this test never runs')
1094
1146
out = StringIO()
1095
1147
runner = tests.TextTestRunner(stream=out, verbosity=2)
1096
test = unittest.FunctionTestCase(not_applicable_test)
1148
test = Test("not_applicable_test")
1097
1149
result = self.run_test_runner(runner, test)
1098
1150
self._log_file.write(out.getvalue())
1099
1151
self.assertTrue(result.wasSuccessful())
1183
def _patch_get_bzr_source_tree(self):
1184
# Reading from the actual source tree breaks isolation, but we don't
1185
# want to assume that thats *all* that would happen.
1186
self._get_source_tree_calls = []
1187
def _get_bzr_source_tree():
1188
self._get_source_tree_calls.append("called")
1190
orig_get_bzr_source_tree = bzrlib.version._get_bzr_source_tree
1191
bzrlib.version._get_bzr_source_tree = _get_bzr_source_tree
1193
bzrlib.version._get_bzr_source_tree = orig_get_bzr_source_tree
1194
self.addCleanup(restore)
1135
1196
def test_bench_history(self):
1136
# tests that the running the benchmark produces a history file
1137
# containing a timestamp and the revision id of the bzrlib source which
1139
workingtree = _get_bzr_source_tree()
1197
# tests that the running the benchmark passes bench_history into
1198
# the test result object. We can tell that happens if
1199
# _get_bzr_source_tree is called.
1200
self._patch_get_bzr_source_tree()
1140
1201
test = TestRunner('dummy_test')
1141
1202
output = StringIO()
1142
1203
runner = tests.TextTestRunner(stream=self._log_file,
1144
1205
result = self.run_test_runner(runner, test)
1145
1206
output_string = output.getvalue()
1146
1207
self.assertContainsRe(output_string, "--date [0-9.]+")
1147
if workingtree is not None:
1148
revision_id = workingtree.get_parent_ids()[0]
1149
self.assertEndsWith(output_string.rstrip(), revision_id)
1208
self.assertLength(1, self._get_source_tree_calls)
1151
1210
def assertLogDeleted(self, test):
1152
1211
log = test._get_log()
1261
1320
self.assertContainsRe(log, 'this will be kept')
1262
1321
self.assertEqual(log, test._log_contents)
1323
def test_startTestRun(self):
1324
"""run should call result.startTestRun()"""
1326
class LoggingDecorator(tests.ForwardingResult):
1327
def startTestRun(self):
1328
tests.ForwardingResult.startTestRun(self)
1329
calls.append('startTestRun')
1330
test = unittest.FunctionTestCase(lambda:None)
1332
runner = tests.TextTestRunner(stream=stream,
1333
result_decorators=[LoggingDecorator])
1334
result = self.run_test_runner(runner, test)
1335
self.assertLength(1, calls)
1337
def test_stopTestRun(self):
1338
"""run should call result.stopTestRun()"""
1340
class LoggingDecorator(tests.ForwardingResult):
1341
def stopTestRun(self):
1342
tests.ForwardingResult.stopTestRun(self)
1343
calls.append('stopTestRun')
1344
test = unittest.FunctionTestCase(lambda:None)
1346
runner = tests.TextTestRunner(stream=stream,
1347
result_decorators=[LoggingDecorator])
1348
result = self.run_test_runner(runner, test)
1349
self.assertLength(1, calls)
1265
1352
class SampleTestCase(tests.TestCase):
1480
1568
self.assertEqual((time.sleep, (0.003,), {}), self._benchcalls[1][0])
1481
1569
self.assertIsInstance(self._benchcalls[0][1], bzrlib.lsprof.Stats)
1482
1570
self.assertIsInstance(self._benchcalls[1][1], bzrlib.lsprof.Stats)
1571
del self._benchcalls[:]
1484
1573
def test_knownFailure(self):
1485
1574
"""Self.knownFailure() should raise a KnownFailure exception."""
1486
1575
self.assertRaises(tests.KnownFailure, self.knownFailure, "A Failure")
1577
def test_open_bzrdir_safe_roots(self):
1578
# even a memory transport should fail to open when its url isn't
1580
# Manually set one up (TestCase doesn't and shouldn't provide magic
1582
transport_server = MemoryServer()
1583
transport_server.setUp()
1584
self.addCleanup(transport_server.tearDown)
1585
t = transport.get_transport(transport_server.get_url())
1586
bzrdir.BzrDir.create(t.base)
1587
self.assertRaises(errors.BzrError,
1588
bzrdir.BzrDir.open_from_transport, t)
1589
# But if we declare this as safe, we can open the bzrdir.
1590
self.permit_url(t.base)
1591
self._bzr_selftest_roots.append(t.base)
1592
bzrdir.BzrDir.open_from_transport(t)
1488
1594
def test_requireFeature_available(self):
1489
1595
"""self.requireFeature(available) is a no-op."""
1490
1596
class Available(tests.Feature):
1666
def test_start_server_registers_url(self):
1667
transport_server = MemoryServer()
1668
# A little strict, but unlikely to be changed soon.
1669
self.assertEqual([], self._bzr_selftest_roots)
1670
self.start_server(transport_server)
1671
self.assertSubset([transport_server.get_url()],
1672
self._bzr_selftest_roots)
1560
1674
def test_assert_list_raises_on_generator(self):
1561
1675
def generator_which_will_raise():
1562
1676
# This will not raise until after the first yield
1660
1774
self.assertEndsWith('foo', 'oo')
1661
1775
self.assertRaises(AssertionError, self.assertEndsWith, 'o', 'oo')
1777
def test_assertEqualDiff(self):
1778
e = self.assertRaises(AssertionError,
1779
self.assertEqualDiff, '', '\n')
1780
self.assertEquals(str(e),
1781
# Don't blink ! The '+' applies to the second string
1782
'first string is missing a final newline.\n+ \n')
1783
e = self.assertRaises(AssertionError,
1784
self.assertEqualDiff, '\n', '')
1785
self.assertEquals(str(e),
1786
# Don't blink ! The '-' applies to the second string
1787
'second string is missing a final newline.\n- \n')
1790
class TestDeprecations(tests.TestCase):
1663
1792
def test_applyDeprecated_not_deprecated(self):
1664
1793
sample_object = ApplyDeprecatedHelper()
1665
1794
# calling an undeprecated callable raises an assertion
1742
1871
tree = self.make_branch_and_memory_tree('a')
1743
1872
self.assertIsInstance(tree, bzrlib.memorytree.MemoryTree)
1746
class TestSFTPMakeBranchAndTree(test_sftp_transport.TestCaseWithSFTPServer):
1748
def test_make_tree_for_sftp_branch(self):
1749
"""Transports backed by local directories create local trees."""
1750
# NB: This is arguably a bug in the definition of make_branch_and_tree.
1874
def test_make_tree_for_local_vfs_backed_transport(self):
1875
# make_branch_and_tree has to use local branch and repositories
1876
# when the vfs transport and local disk are colocated, even if
1877
# a different transport is in use for url generation.
1878
from bzrlib.transport.fakevfat import FakeVFATServer
1879
self.transport_server = FakeVFATServer
1880
self.assertFalse(self.get_url('t1').startswith('file://'))
1751
1881
tree = self.make_branch_and_tree('t1')
1752
1882
base = tree.bzrdir.root_transport.base
1753
self.failIf(base.startswith('sftp'),
1754
'base %r is on sftp but should be local' % base)
1883
self.assertStartsWith(base, 'file://')
1755
1884
self.assertEquals(tree.bzrdir.root_transport,
1756
1885
tree.branch.bzrdir.root_transport)
1757
1886
self.assertEquals(tree.bzrdir.root_transport,
1817
1946
self.assertNotContainsRe("Test.b", output.getvalue())
1818
1947
self.assertLength(2, output.readlines())
1949
def test_lsprof_tests(self):
1950
self.requireFeature(test_lsprof.LSProfFeature)
1953
def __call__(test, result):
1955
def run(test, result):
1956
self.assertIsInstance(result, tests.ForwardingResult)
1957
calls.append("called")
1958
def countTestCases(self):
1960
self.run_selftest(test_suite_factory=Test, lsprof_tests=True)
1961
self.assertLength(1, calls)
1820
1963
def test_random(self):
1821
1964
# test randomising by listing a number of tests.
1822
1965
output_123 = self.run_selftest(test_suite_factory=self.factory,
1915
2058
Attempts to run bzr from inside this class don't actually run it.
1917
We test how run_bzr actually invokes bzr in another location.
1918
Here we only need to test that it is run_bzr passes the right
1919
parameters to run_bzr.
2060
We test how run_bzr actually invokes bzr in another location. Here we
2061
only need to test that it passes the right parameters to run_bzr.
1921
2063
self.argv = list(argv)
1922
2064
self.retcode = retcode
1923
2065
self.encoding = encoding
1924
2066
self.stdin = stdin
1925
2067
self.working_dir = working_dir
1926
return self.out, self.err
2068
return self.retcode, self.out, self.err
1928
2070
def test_run_bzr_error(self):
1929
2071
self.out = "It sure does!\n"
1930
2072
out, err = self.run_bzr_error(['^$'], ['rocks'], retcode=34)
1931
2073
self.assertEqual(['rocks'], self.argv)
1932
2074
self.assertEqual(34, self.retcode)
1933
self.assertEqual(out, 'It sure does!\n')
2075
self.assertEqual('It sure does!\n', out)
2076
self.assertEquals(out, self.out)
2077
self.assertEqual('', err)
2078
self.assertEquals(err, self.err)
1935
2080
def test_run_bzr_error_regexes(self):
1937
2082
self.err = "bzr: ERROR: foobarbaz is not versioned"
1938
2083
out, err = self.run_bzr_error(
1939
["bzr: ERROR: foobarbaz is not versioned"],
1940
['file-id', 'foobarbaz'])
2084
["bzr: ERROR: foobarbaz is not versioned"],
2085
['file-id', 'foobarbaz'])
1942
2087
def test_encoding(self):
1943
2088
"""Test that run_bzr passes encoding to _run_bzr_core"""
2157
2306
StubProcess(), '', allow_plugins=True)
2309
class TestFinishBzrSubprocess(TestWithFakedStartBzrSubprocess):
2311
def test_finish_bzr_subprocess_with_error(self):
2312
"""finish_bzr_subprocess allows specification of the desired exit code.
2314
process = StubProcess(err="unknown command", retcode=3)
2315
result = self.finish_bzr_subprocess(process, retcode=3)
2316
self.assertEqual('', result[0])
2317
self.assertContainsRe(result[1], 'unknown command')
2319
def test_finish_bzr_subprocess_ignoring_retcode(self):
2320
"""finish_bzr_subprocess allows the exit code to be ignored."""
2321
process = StubProcess(err="unknown command", retcode=3)
2322
result = self.finish_bzr_subprocess(process, retcode=None)
2323
self.assertEqual('', result[0])
2324
self.assertContainsRe(result[1], 'unknown command')
2326
def test_finish_subprocess_with_unexpected_retcode(self):
2327
"""finish_bzr_subprocess raises self.failureException if the retcode is
2328
not the expected one.
2330
process = StubProcess(err="unknown command", retcode=3)
2331
self.assertRaises(self.failureException, self.finish_bzr_subprocess,
2160
2335
class _DontSpawnProcess(Exception):
2161
2336
"""A simple exception which just allows us to skip unnecessary steps"""
2240
2415
self.assertEqual(['foo', 'current'], chdirs)
2243
class TestBzrSubprocess(tests.TestCaseWithTransport):
2245
def test_start_and_stop_bzr_subprocess(self):
2246
"""We can start and perform other test actions while that process is
2249
process = self.start_bzr_subprocess(['--version'])
2250
result = self.finish_bzr_subprocess(process)
2251
self.assertContainsRe(result[0], 'is free software')
2252
self.assertEqual('', result[1])
2254
def test_start_and_stop_bzr_subprocess_with_error(self):
2255
"""finish_bzr_subprocess allows specification of the desired exit code.
2257
process = self.start_bzr_subprocess(['--versionn'])
2258
result = self.finish_bzr_subprocess(process, retcode=3)
2259
self.assertEqual('', result[0])
2260
self.assertContainsRe(result[1], 'unknown command')
2262
def test_start_and_stop_bzr_subprocess_ignoring_retcode(self):
2263
"""finish_bzr_subprocess allows the exit code to be ignored."""
2264
process = self.start_bzr_subprocess(['--versionn'])
2265
result = self.finish_bzr_subprocess(process, retcode=None)
2266
self.assertEqual('', result[0])
2267
self.assertContainsRe(result[1], 'unknown command')
2269
def test_start_and_stop_bzr_subprocess_with_unexpected_retcode(self):
2270
"""finish_bzr_subprocess raises self.failureException if the retcode is
2271
not the expected one.
2273
process = self.start_bzr_subprocess(['--versionn'])
2274
self.assertRaises(self.failureException, self.finish_bzr_subprocess,
2418
class TestActuallyStartBzrSubprocess(tests.TestCaseWithTransport):
2419
"""Tests that really need to do things with an external bzr."""
2277
2421
def test_start_and_stop_bzr_subprocess_send_signal(self):
2278
2422
"""finish_bzr_subprocess raises self.failureException if the retcode is
2279
2423
not the expected one.
2425
self.disable_missing_extensions_warning()
2281
2426
process = self.start_bzr_subprocess(['wait-until-signalled'],
2282
2427
skip_if_plan_to_signal=True)
2283
2428
self.assertEqual('running\n', process.stdout.readline())
2286
2431
self.assertEqual('', result[0])
2287
2432
self.assertEqual('bzr: interrupted\n', result[1])
2289
def test_start_and_stop_working_dir(self):
2290
cwd = osutils.getcwd()
2291
self.make_branch_and_tree('one')
2292
process = self.start_bzr_subprocess(['root'], working_dir='one')
2293
result = self.finish_bzr_subprocess(process, universal_newlines=True)
2294
self.assertEndsWith(result[0], 'one\n')
2295
self.assertEqual('', result[1])
2298
2435
class TestKnownFailure(tests.TestCase):
2549
2686
# Running bzr in blackbox mode, normal/expected/user errors should be
2550
2687
# caught in the regular way and turned into an error message plus exit
2552
out, err = self.run_bzr(["log", "/nonexistantpath"], retcode=3)
2689
transport_server = MemoryServer()
2690
transport_server.setUp()
2691
self.addCleanup(transport_server.tearDown)
2692
url = transport_server.get_url()
2693
self.permit_url(url)
2694
out, err = self.run_bzr(["log", "%s/nonexistantpath" % url], retcode=3)
2553
2695
self.assertEqual(out, '')
2554
2696
self.assertContainsRe(err,
2555
2697
'bzr: ERROR: Not a branch: ".*nonexistantpath/".\n')
2682
2824
class TestTestSuite(tests.TestCase):
2826
def test__test_suite_testmod_names(self):
2827
# Test that a plausible list of test module names are returned
2828
# by _test_suite_testmod_names.
2829
test_list = tests._test_suite_testmod_names()
2831
'bzrlib.tests.blackbox',
2832
'bzrlib.tests.per_transport',
2833
'bzrlib.tests.test_selftest',
2837
def test__test_suite_modules_to_doctest(self):
2838
# Test that a plausible list of modules to doctest is returned
2839
# by _test_suite_modules_to_doctest.
2840
test_list = tests._test_suite_modules_to_doctest()
2684
2846
def test_test_suite(self):
2685
# This test is slow - it loads the entire test suite to operate, so we
2686
# do a single test with one test in each category
2847
# test_suite() loads the entire test suite to operate. To avoid this
2848
# overhead, and yet still be confident that things are happening,
2849
# we temporarily replace two functions used by test_suite with
2850
# test doubles that supply a few sample tests to load, and check they
2853
def _test_suite_testmod_names():
2854
calls.append("testmod_names")
2856
'bzrlib.tests.blackbox.test_branch',
2857
'bzrlib.tests.per_transport',
2858
'bzrlib.tests.test_selftest',
2860
original_testmod_names = tests._test_suite_testmod_names
2861
def _test_suite_modules_to_doctest():
2862
calls.append("modules_to_doctest")
2863
return ['bzrlib.timestamp']
2864
orig_modules_to_doctest = tests._test_suite_modules_to_doctest
2865
def restore_names():
2866
tests._test_suite_testmod_names = original_testmod_names
2867
tests._test_suite_modules_to_doctest = orig_modules_to_doctest
2868
self.addCleanup(restore_names)
2869
tests._test_suite_testmod_names = _test_suite_testmod_names
2870
tests._test_suite_modules_to_doctest = _test_suite_modules_to_doctest
2871
expected_test_list = [
2688
2872
# testmod_names
2689
2873
'bzrlib.tests.blackbox.test_branch.TestBranch.test_branch',
2690
2874
('bzrlib.tests.per_transport.TransportTests'
2691
'.test_abspath(LocalURLServer)'),
2875
'.test_abspath(LocalTransport,LocalURLServer)'),
2692
2876
'bzrlib.tests.test_selftest.TestTestSuite.test_test_suite',
2693
2877
# modules_to_doctest
2694
2878
'bzrlib.timestamp.format_highres_date',
2695
2879
# plugins can't be tested that way since selftest may be run with
2698
suite = tests.test_suite(test_list)
2699
self.assertEquals(test_list, _test_ids(suite))
2882
suite = tests.test_suite()
2883
self.assertEqual(set(["testmod_names", "modules_to_doctest"]),
2885
self.assertSubset(expected_test_list, _test_ids(suite))
2701
2887
def test_test_suite_list_and_start(self):
2702
2888
# We cannot test this at the same time as the main load, because we want
2703
# to know that starting_with == None works. So a second full load is
2889
# to know that starting_with == None works. So a second load is
2890
# incurred - note that the starting_with parameter causes a partial load
2891
# rather than a full load so this test should be pretty quick.
2705
2892
test_list = ['bzrlib.tests.test_selftest.TestTestSuite.test_test_suite']
2706
2893
suite = tests.test_suite(test_list,
2707
2894
['bzrlib.tests.test_selftest.TestTestSuite'])
2853
3040
self.verbosity)
2854
3041
tests.run_suite(suite, runner_class=MyRunner, stream=StringIO())
2855
3042
self.assertLength(1, calls)
2857
def test_done(self):
2858
"""run_suite should call result.done()"""
2860
def one_more_call(): self.calls += 1
2861
def test_function():
2863
test = unittest.FunctionTestCase(test_function)
2864
class InstrumentedTestResult(tests.ExtendedTestResult):
2865
def done(self): one_more_call()
2866
class MyRunner(tests.TextTestRunner):
2867
def run(self, test):
2868
return InstrumentedTestResult(self.stream, self.descriptions,
2870
tests.run_suite(test, runner_class=MyRunner, stream=StringIO())
2871
self.assertEquals(1, self.calls)
added
removed
bzrlib/tests/test_selftest.py
