226
184
def test_adapted_tests(self):
227
185
# check that constructor parameters are passed through to the adapted
229
from bzrlib.tests.bzrdir_implementations import BzrDirTestProviderAdapter
187
from bzrlib.bzrdir import BzrDirTestProviderAdapter
188
input_test = TestBzrDirProviderAdapter(
189
"test_adapted_tests")
233
192
formats = ["c", "d"]
234
adapter = BzrDirTestProviderAdapter(vfs_factory,
235
server1, server2, formats)
238
{'bzrdir_format': 'c',
239
'transport_readonly_server': 'b',
240
'transport_server': 'a',
241
'vfs_transport_factory': 'v'}),
243
{'bzrdir_format': 'd',
244
'transport_readonly_server': 'b',
245
'transport_server': 'a',
246
'vfs_transport_factory': 'v'})],
250
class TestRepositoryParameterisation(TestCase):
193
adapter = BzrDirTestProviderAdapter(server1, server2, formats)
194
suite = adapter.adapt(input_test)
195
tests = list(iter(suite))
196
self.assertEqual(2, len(tests))
197
self.assertEqual(tests[0].bzrdir_format, formats[0])
198
self.assertEqual(tests[0].transport_server, server1)
199
self.assertEqual(tests[0].transport_readonly_server, server2)
200
self.assertEqual(tests[1].bzrdir_format, formats[1])
201
self.assertEqual(tests[1].transport_server, server1)
202
self.assertEqual(tests[1].transport_readonly_server, server2)
205
class TestRepositoryProviderAdapter(TestCase):
251
206
"""A group of tests that test the repository implementation test adapter."""
253
def test_formats_to_scenarios(self):
254
"""The adapter can generate all the scenarios needed."""
255
from bzrlib.tests.repository_implementations import formats_to_scenarios
256
formats = [("(c)", remote.RemoteRepositoryFormat()),
257
("(d)", repository.format_registry.get(
258
'Bazaar pack repository format 1 (needs bzr 0.92)\n'))]
259
no_vfs_scenarios = formats_to_scenarios(formats, "server", "readonly",
261
vfs_scenarios = formats_to_scenarios(formats, "server", "readonly",
262
vfs_transport_factory="vfs")
263
# no_vfs generate scenarios without vfs_transport_factory
265
('RemoteRepositoryFormat(c)',
266
{'bzrdir_format': remote.RemoteBzrDirFormat(),
267
'repository_format': remote.RemoteRepositoryFormat(),
268
'transport_readonly_server': 'readonly',
269
'transport_server': 'server'}),
270
('RepositoryFormatKnitPack1(d)',
271
{'bzrdir_format': bzrdir.BzrDirMetaFormat1(),
272
'repository_format': pack_repo.RepositoryFormatKnitPack1(),
273
'transport_readonly_server': 'readonly',
274
'transport_server': 'server'})],
277
('RemoteRepositoryFormat(c)',
278
{'bzrdir_format': remote.RemoteBzrDirFormat(),
279
'repository_format': remote.RemoteRepositoryFormat(),
280
'transport_readonly_server': 'readonly',
281
'transport_server': 'server',
282
'vfs_transport_factory': 'vfs'}),
283
('RepositoryFormatKnitPack1(d)',
284
{'bzrdir_format': bzrdir.BzrDirMetaFormat1(),
285
'repository_format': pack_repo.RepositoryFormatKnitPack1(),
286
'transport_readonly_server': 'readonly',
287
'transport_server': 'server',
288
'vfs_transport_factory': 'vfs'})],
292
class TestTestScenarioApplier(TestCase):
293
"""Tests for the test adaption facilities."""
295
def test_adapt_applies_scenarios(self):
296
from bzrlib.tests.repository_implementations import TestScenarioApplier
297
input_test = TestTestScenarioApplier("test_adapt_test_to_scenario")
298
adapter = TestScenarioApplier()
299
adapter.scenarios = [("1", "dict"), ("2", "settings")]
301
def capture_call(test, scenario):
302
calls.append((test, scenario))
304
adapter.adapt_test_to_scenario = capture_call
305
adapter.adapt(input_test)
306
self.assertEqual([(input_test, ("1", "dict")),
307
(input_test, ("2", "settings"))], calls)
309
def test_adapt_test_to_scenario(self):
310
from bzrlib.tests.repository_implementations import TestScenarioApplier
311
input_test = TestTestScenarioApplier("test_adapt_test_to_scenario")
312
adapter = TestScenarioApplier()
313
# setup two adapted tests
314
adapted_test1 = adapter.adapt_test_to_scenario(input_test,
316
{"bzrdir_format":"bzr_format",
317
"repository_format":"repo_fmt",
318
"transport_server":"transport_server",
319
"transport_readonly_server":"readonly-server"}))
320
adapted_test2 = adapter.adapt_test_to_scenario(input_test,
321
("new id 2", {"bzrdir_format":None}))
322
# input_test should have been altered.
323
self.assertRaises(AttributeError, getattr, input_test, "bzrdir_format")
324
# the new tests are mutually incompatible, ensuring it has
325
# made new ones, and unspecified elements in the scenario
326
# should not have been altered.
327
self.assertEqual("bzr_format", adapted_test1.bzrdir_format)
328
self.assertEqual("repo_fmt", adapted_test1.repository_format)
329
self.assertEqual("transport_server", adapted_test1.transport_server)
330
self.assertEqual("readonly-server",
331
adapted_test1.transport_readonly_server)
333
"bzrlib.tests.test_selftest.TestTestScenarioApplier."
334
"test_adapt_test_to_scenario(new id)",
336
self.assertEqual(None, adapted_test2.bzrdir_format)
338
"bzrlib.tests.test_selftest.TestTestScenarioApplier."
339
"test_adapt_test_to_scenario(new id 2)",
208
def test_adapted_tests(self):
209
# check that constructor parameters are passed through to the adapted
211
from bzrlib.repository import RepositoryTestProviderAdapter
212
input_test = TestRepositoryProviderAdapter(
213
"test_adapted_tests")
216
formats = [("c", "C"), ("d", "D")]
217
adapter = RepositoryTestProviderAdapter(server1, server2, formats)
218
suite = adapter.adapt(input_test)
219
tests = list(iter(suite))
220
self.assertEqual(2, len(tests))
221
self.assertEqual(tests[0].bzrdir_format, formats[0][1])
222
self.assertEqual(tests[0].repository_format, formats[0][0])
223
self.assertEqual(tests[0].transport_server, server1)
224
self.assertEqual(tests[0].transport_readonly_server, server2)
225
self.assertEqual(tests[1].bzrdir_format, formats[1][1])
226
self.assertEqual(tests[1].repository_format, formats[1][0])
227
self.assertEqual(tests[1].transport_server, server1)
228
self.assertEqual(tests[1].transport_readonly_server, server2)
343
231
class TestInterRepositoryProviderAdapter(TestCase):
346
234
def test_adapted_tests(self):
347
235
# check that constructor parameters are passed through to the adapted
349
from bzrlib.tests.interrepository_implementations import \
350
InterRepositoryTestProviderAdapter
237
from bzrlib.repository import InterRepositoryTestProviderAdapter
238
input_test = TestInterRepositoryProviderAdapter(
239
"test_adapted_tests")
353
242
formats = [(str, "C1", "C2"), (int, "D1", "D2")]
354
243
adapter = InterRepositoryTestProviderAdapter(server1, server2, formats)
357
{'interrepo_class': str,
358
'repository_format': 'C1',
359
'repository_format_to': 'C2',
360
'transport_readonly_server': 'b',
361
'transport_server': 'a'}),
363
{'interrepo_class': int,
364
'repository_format': 'D1',
365
'repository_format_to': 'D2',
366
'transport_readonly_server': 'b',
367
'transport_server': 'a'})],
368
adapter.formats_to_scenarios(formats))
244
suite = adapter.adapt(input_test)
245
tests = list(iter(suite))
246
self.assertEqual(2, len(tests))
247
self.assertEqual(tests[0].interrepo_class, formats[0][0])
248
self.assertEqual(tests[0].repository_format, formats[0][1])
249
self.assertEqual(tests[0].repository_format_to, formats[0][2])
250
self.assertEqual(tests[0].transport_server, server1)
251
self.assertEqual(tests[0].transport_readonly_server, server2)
252
self.assertEqual(tests[1].interrepo_class, formats[1][0])
253
self.assertEqual(tests[1].repository_format, formats[1][1])
254
self.assertEqual(tests[1].repository_format_to, formats[1][2])
255
self.assertEqual(tests[1].transport_server, server1)
256
self.assertEqual(tests[1].transport_readonly_server, server2)
259
class TestInterVersionedFileProviderAdapter(TestCase):
260
"""A group of tests that test the InterVersionedFile test adapter."""
262
def test_adapted_tests(self):
263
# check that constructor parameters are passed through to the adapted
265
from bzrlib.versionedfile import InterVersionedFileTestProviderAdapter
266
input_test = TestInterRepositoryProviderAdapter(
267
"test_adapted_tests")
270
formats = [(str, "C1", "C2"), (int, "D1", "D2")]
271
adapter = InterVersionedFileTestProviderAdapter(server1, server2, formats)
272
suite = adapter.adapt(input_test)
273
tests = list(iter(suite))
274
self.assertEqual(2, len(tests))
275
self.assertEqual(tests[0].interversionedfile_class, formats[0][0])
276
self.assertEqual(tests[0].versionedfile_factory, formats[0][1])
277
self.assertEqual(tests[0].versionedfile_factory_to, formats[0][2])
278
self.assertEqual(tests[0].transport_server, server1)
279
self.assertEqual(tests[0].transport_readonly_server, server2)
280
self.assertEqual(tests[1].interversionedfile_class, formats[1][0])
281
self.assertEqual(tests[1].versionedfile_factory, formats[1][1])
282
self.assertEqual(tests[1].versionedfile_factory_to, formats[1][2])
283
self.assertEqual(tests[1].transport_server, server1)
284
self.assertEqual(tests[1].transport_readonly_server, server2)
287
class TestRevisionStoreProviderAdapter(TestCase):
288
"""A group of tests that test the RevisionStore test adapter."""
290
def test_adapted_tests(self):
291
# check that constructor parameters are passed through to the adapted
293
from bzrlib.store.revision import RevisionStoreTestProviderAdapter
294
input_test = TestRevisionStoreProviderAdapter(
295
"test_adapted_tests")
296
# revision stores need a store factory - i.e. RevisionKnit
297
#, a readonly and rw transport
301
store_factories = ["c", "d"]
302
adapter = RevisionStoreTestProviderAdapter(server1, server2, store_factories)
303
suite = adapter.adapt(input_test)
304
tests = list(iter(suite))
305
self.assertEqual(2, len(tests))
306
self.assertEqual(tests[0].store_factory, store_factories[0][0])
307
self.assertEqual(tests[0].transport_server, server1)
308
self.assertEqual(tests[0].transport_readonly_server, server2)
309
self.assertEqual(tests[1].store_factory, store_factories[1][0])
310
self.assertEqual(tests[1].transport_server, server1)
311
self.assertEqual(tests[1].transport_readonly_server, server2)
371
314
class TestWorkingTreeProviderAdapter(TestCase):
372
315
"""A group of tests that test the workingtree implementation test adapter."""
374
def test_scenarios(self):
317
def test_adapted_tests(self):
375
318
# check that constructor parameters are passed through to the adapted
377
from bzrlib.tests.workingtree_implementations \
378
import WorkingTreeTestProviderAdapter
320
from bzrlib.workingtree import WorkingTreeTestProviderAdapter
321
input_test = TestWorkingTreeProviderAdapter(
322
"test_adapted_tests")
381
formats = [workingtree.WorkingTreeFormat2(),
382
workingtree.WorkingTreeFormat3(),]
325
formats = [("c", "C"), ("d", "D")]
383
326
adapter = WorkingTreeTestProviderAdapter(server1, server2, formats)
385
('WorkingTreeFormat2',
386
{'bzrdir_format': formats[0]._matchingbzrdir,
387
'transport_readonly_server': 'b',
388
'transport_server': 'a',
389
'workingtree_format': formats[0]}),
390
('WorkingTreeFormat3',
391
{'bzrdir_format': formats[1]._matchingbzrdir,
392
'transport_readonly_server': 'b',
393
'transport_server': 'a',
394
'workingtree_format': formats[1]})],
327
suite = adapter.adapt(input_test)
328
tests = list(iter(suite))
329
self.assertEqual(2, len(tests))
330
self.assertEqual(tests[0].workingtree_format, formats[0][0])
331
self.assertEqual(tests[0].bzrdir_format, formats[0][1])
332
self.assertEqual(tests[0].transport_server, server1)
333
self.assertEqual(tests[0].transport_readonly_server, server2)
334
self.assertEqual(tests[1].workingtree_format, formats[1][0])
335
self.assertEqual(tests[1].bzrdir_format, formats[1][1])
336
self.assertEqual(tests[1].transport_server, server1)
337
self.assertEqual(tests[1].transport_readonly_server, server2)
398
340
class TestTreeProviderAdapter(TestCase):
812
686
self.assertContainsRe(output,
813
687
r"LSProf output for <type 'unicode'>\(\('world',\), {'errors': 'replace'}\)\n")
815
def test_known_failure(self):
816
"""A KnownFailure being raised should trigger several result actions."""
817
class InstrumentedTestResult(ExtendedTestResult):
819
def report_test_start(self, test): pass
820
def report_known_failure(self, test, err):
821
self._call = test, err
822
result = InstrumentedTestResult(None, None, None, None)
824
raise KnownFailure('failed!')
825
test = unittest.FunctionTestCase(test_function)
827
# it should invoke 'report_known_failure'.
828
self.assertEqual(2, len(result._call))
829
self.assertEqual(test, result._call[0])
830
self.assertEqual(KnownFailure, result._call[1][0])
831
self.assertIsInstance(result._call[1][1], KnownFailure)
832
# we dont introspec the traceback, if the rest is ok, it would be
833
# exceptional for it not to be.
834
# it should update the known_failure_count on the object.
835
self.assertEqual(1, result.known_failure_count)
836
# the result should be successful.
837
self.assertTrue(result.wasSuccessful())
839
def test_verbose_report_known_failure(self):
840
# verbose test output formatting
841
result_stream = StringIO()
842
result = bzrlib.tests.VerboseTestResult(
843
unittest._WritelnDecorator(result_stream),
847
test = self.get_passing_test()
848
result.startTest(test)
849
prefix = len(result_stream.getvalue())
850
# the err parameter has the shape:
851
# (class, exception object, traceback)
852
# KnownFailures dont get their tracebacks shown though, so we
854
err = (KnownFailure, KnownFailure('foo'), None)
855
result.report_known_failure(test, err)
856
output = result_stream.getvalue()[prefix:]
857
lines = output.splitlines()
858
self.assertContainsRe(lines[0], r'XFAIL *\d+ms$')
859
self.assertEqual(lines[1], ' foo')
860
self.assertEqual(2, len(lines))
862
def test_text_report_known_failure(self):
863
# text test output formatting
865
result = bzrlib.tests.TextTestResult(
871
test = self.get_passing_test()
872
# this seeds the state to handle reporting the test.
873
result.startTest(test)
874
# the err parameter has the shape:
875
# (class, exception object, traceback)
876
# KnownFailures dont get their tracebacks shown though, so we
878
err = (KnownFailure, KnownFailure('foo'), None)
879
result.report_known_failure(test, err)
882
('update', '[1 in 0s] passing_test', None, None),
883
('note', 'XFAIL: %s\n%s\n', ('passing_test', err[1]))
886
# known_failures should be printed in the summary, so if we run a test
887
# after there are some known failures, the update prefix should match
889
result.known_failure_count = 3
893
('update', '[2 in 0s] passing_test', None, None),
897
def get_passing_test(self):
898
"""Return a test object that can't be run usefully."""
901
return unittest.FunctionTestCase(passing_test)
903
def test_add_not_supported(self):
904
"""Test the behaviour of invoking addNotSupported."""
905
class InstrumentedTestResult(ExtendedTestResult):
906
def report_test_start(self, test): pass
907
def report_unsupported(self, test, feature):
908
self._call = test, feature
909
result = InstrumentedTestResult(None, None, None, None)
910
test = SampleTestCase('_test_pass')
912
result.startTest(test)
913
result.addNotSupported(test, feature)
914
# it should invoke 'report_unsupported'.
915
self.assertEqual(2, len(result._call))
916
self.assertEqual(test, result._call[0])
917
self.assertEqual(feature, result._call[1])
918
# the result should be successful.
919
self.assertTrue(result.wasSuccessful())
920
# it should record the test against a count of tests not run due to
922
self.assertEqual(1, result.unsupported['Feature'])
923
# and invoking it again should increment that counter
924
result.addNotSupported(test, feature)
925
self.assertEqual(2, result.unsupported['Feature'])
927
def test_verbose_report_unsupported(self):
928
# verbose test output formatting
929
result_stream = StringIO()
930
result = bzrlib.tests.VerboseTestResult(
931
unittest._WritelnDecorator(result_stream),
935
test = self.get_passing_test()
937
result.startTest(test)
938
prefix = len(result_stream.getvalue())
939
result.report_unsupported(test, feature)
940
output = result_stream.getvalue()[prefix:]
941
lines = output.splitlines()
942
self.assertEqual(lines, ['NODEP 0ms', " The feature 'Feature' is not available."])
944
def test_text_report_unsupported(self):
945
# text test output formatting
947
result = bzrlib.tests.TextTestResult(
953
test = self.get_passing_test()
955
# this seeds the state to handle reporting the test.
956
result.startTest(test)
957
result.report_unsupported(test, feature)
958
# no output on unsupported features
960
[('update', '[1 in 0s] passing_test', None, None)
963
# the number of missing features should be printed in the progress
964
# summary, so check for that.
965
result.unsupported = {'foo':0, 'bar':0}
969
('update', '[2 in 0s, 2 missing] passing_test', None, None),
973
def test_unavailable_exception(self):
974
"""An UnavailableFeature being raised should invoke addNotSupported."""
975
class InstrumentedTestResult(ExtendedTestResult):
977
def report_test_start(self, test): pass
978
def addNotSupported(self, test, feature):
979
self._call = test, feature
980
result = InstrumentedTestResult(None, None, None, None)
983
raise UnavailableFeature(feature)
984
test = unittest.FunctionTestCase(test_function)
986
# it should invoke 'addNotSupported'.
987
self.assertEqual(2, len(result._call))
988
self.assertEqual(test, result._call[0])
989
self.assertEqual(feature, result._call[1])
990
# and not count as an error
991
self.assertEqual(0, result.error_count)
993
def test_strict_with_unsupported_feature(self):
994
result = bzrlib.tests.TextTestResult(self._log_file, descriptions=0,
996
test = self.get_passing_test()
997
feature = "Unsupported Feature"
998
result.addNotSupported(test, feature)
999
self.assertFalse(result.wasStrictlySuccessful())
1000
self.assertEqual(None, result._extractBenchmarkTime(test))
1002
def test_strict_with_known_failure(self):
1003
result = bzrlib.tests.TextTestResult(self._log_file, descriptions=0,
1005
test = self.get_passing_test()
1006
err = (KnownFailure, KnownFailure('foo'), None)
1007
result._addKnownFailure(test, err)
1008
self.assertFalse(result.wasStrictlySuccessful())
1009
self.assertEqual(None, result._extractBenchmarkTime(test))
1011
def test_strict_with_success(self):
1012
result = bzrlib.tests.TextTestResult(self._log_file, descriptions=0,
1014
test = self.get_passing_test()
1015
result.addSuccess(test)
1016
self.assertTrue(result.wasStrictlySuccessful())
1017
self.assertEqual(None, result._extractBenchmarkTime(test))
1020
class TestUnicodeFilenameFeature(TestCase):
1022
def test_probe_passes(self):
1023
"""UnicodeFilenameFeature._probe passes."""
1024
# We can't test much more than that because the behaviour depends
1026
tests.UnicodeFilenameFeature._probe()
1029
690
class TestRunner(TestCase):
1048
709
TestCaseInTempDir.TEST_ROOT = old_root
1050
def test_known_failure_failed_run(self):
1051
# run a test that generates a known failure which should be printed in
1052
# the final output when real failures occur.
1053
def known_failure_test():
1054
raise KnownFailure('failed')
1055
test = unittest.TestSuite()
1056
test.addTest(unittest.FunctionTestCase(known_failure_test))
1058
raise AssertionError('foo')
1059
test.addTest(unittest.FunctionTestCase(failing_test))
1061
runner = TextTestRunner(stream=stream)
1062
result = self.run_test_runner(runner, test)
1063
lines = stream.getvalue().splitlines()
1066
'======================================================================',
1067
'FAIL: unittest.FunctionTestCase (failing_test)',
1068
'----------------------------------------------------------------------',
1069
'Traceback (most recent call last):',
1070
' raise AssertionError(\'foo\')',
1071
'AssertionError: foo',
1073
'----------------------------------------------------------------------',
1075
'FAILED (failures=1, known_failure_count=1)'],
1076
lines[0:5] + lines[6:10] + lines[11:])
1078
def test_known_failure_ok_run(self):
1079
# run a test that generates a known failure which should be printed in the final output.
1080
def known_failure_test():
1081
raise KnownFailure('failed')
1082
test = unittest.FunctionTestCase(known_failure_test)
1084
runner = TextTestRunner(stream=stream)
1085
result = self.run_test_runner(runner, test)
1086
self.assertContainsRe(stream.getvalue(),
1089
'Ran 1 test in .*\n'
1091
'OK \\(known_failures=1\\)\n')
1093
711
def test_skipped_test(self):
1094
712
# run a test that is skipped, and check the suite as a whole still
1096
714
# skipping_test must be hidden in here so it's not run as a real test
1097
715
def skipping_test():
1098
716
raise TestSkipped('test intentionally skipped')
1100
runner = TextTestRunner(stream=self._log_file)
717
runner = TextTestRunner(stream=self._log_file, keep_output=True)
1101
718
test = unittest.FunctionTestCase(skipping_test)
1102
719
result = self.run_test_runner(runner, test)
1103
720
self.assertTrue(result.wasSuccessful())
1105
def test_skipped_from_setup(self):
1107
class SkippedSetupTest(TestCase):
1110
calls.append('setUp')
1111
self.addCleanup(self.cleanup)
1112
raise TestSkipped('skipped setup')
1114
def test_skip(self):
1115
self.fail('test reached')
1118
calls.append('cleanup')
1120
runner = TextTestRunner(stream=self._log_file)
1121
test = SkippedSetupTest('test_skip')
1122
result = self.run_test_runner(runner, test)
1123
self.assertTrue(result.wasSuccessful())
1124
# Check if cleanup was called the right number of times.
1125
self.assertEqual(['setUp', 'cleanup'], calls)
1127
def test_skipped_from_test(self):
1129
class SkippedTest(TestCase):
1132
calls.append('setUp')
1133
self.addCleanup(self.cleanup)
1135
def test_skip(self):
1136
raise TestSkipped('skipped test')
1139
calls.append('cleanup')
1141
runner = TextTestRunner(stream=self._log_file)
1142
test = SkippedTest('test_skip')
1143
result = self.run_test_runner(runner, test)
1144
self.assertTrue(result.wasSuccessful())
1145
# Check if cleanup was called the right number of times.
1146
self.assertEqual(['setUp', 'cleanup'], calls)
1148
def test_not_applicable(self):
1149
# run a test that is skipped because it's not applicable
1150
def not_applicable_test():
1151
from bzrlib.tests import TestNotApplicable
1152
raise TestNotApplicable('this test never runs')
1154
runner = TextTestRunner(stream=out, verbosity=2)
1155
test = unittest.FunctionTestCase(not_applicable_test)
1156
result = self.run_test_runner(runner, test)
1157
self._log_file.write(out.getvalue())
1158
self.assertTrue(result.wasSuccessful())
1159
self.assertTrue(result.wasStrictlySuccessful())
1160
self.assertContainsRe(out.getvalue(),
1161
r'(?m)not_applicable_test * N/A')
1162
self.assertContainsRe(out.getvalue(),
1163
r'(?m)^ this test never runs')
1165
def test_not_applicable_demo(self):
1166
# just so you can see it in the test output
1167
raise TestNotApplicable('this test is just a demonstation')
1169
def test_unsupported_features_listed(self):
1170
"""When unsupported features are encountered they are detailed."""
1171
class Feature1(Feature):
1172
def _probe(self): return False
1173
class Feature2(Feature):
1174
def _probe(self): return False
1175
# create sample tests
1176
test1 = SampleTestCase('_test_pass')
1177
test1._test_needs_features = [Feature1()]
1178
test2 = SampleTestCase('_test_pass')
1179
test2._test_needs_features = [Feature2()]
1180
test = unittest.TestSuite()
1184
runner = TextTestRunner(stream=stream)
1185
result = self.run_test_runner(runner, test)
1186
lines = stream.getvalue().splitlines()
1189
"Missing feature 'Feature1' skipped 1 tests.",
1190
"Missing feature 'Feature2' skipped 1 tests.",
1194
722
def test_bench_history(self):
1195
723
# tests that the running the benchmark produces a history file
1196
724
# containing a timestamp and the revision id of the bzrlib source which
1415
878
self.assertIsInstance(self._benchcalls[0][1], bzrlib.lsprof.Stats)
1416
879
self.assertIsInstance(self._benchcalls[1][1], bzrlib.lsprof.Stats)
1418
def test_knownFailure(self):
1419
"""Self.knownFailure() should raise a KnownFailure exception."""
1420
self.assertRaises(KnownFailure, self.knownFailure, "A Failure")
1422
def test_requireFeature_available(self):
1423
"""self.requireFeature(available) is a no-op."""
1424
class Available(Feature):
1425
def _probe(self):return True
1426
feature = Available()
1427
self.requireFeature(feature)
1429
def test_requireFeature_unavailable(self):
1430
"""self.requireFeature(unavailable) raises UnavailableFeature."""
1431
class Unavailable(Feature):
1432
def _probe(self):return False
1433
feature = Unavailable()
1434
self.assertRaises(UnavailableFeature, self.requireFeature, feature)
1436
def test_run_no_parameters(self):
1437
test = SampleTestCase('_test_pass')
1440
def test_run_enabled_unittest_result(self):
1441
"""Test we revert to regular behaviour when the test is enabled."""
1442
test = SampleTestCase('_test_pass')
1443
class EnabledFeature(object):
1444
def available(self):
1446
test._test_needs_features = [EnabledFeature()]
1447
result = unittest.TestResult()
1449
self.assertEqual(1, result.testsRun)
1450
self.assertEqual([], result.errors)
1451
self.assertEqual([], result.failures)
1453
def test_run_disabled_unittest_result(self):
1454
"""Test our compatability for disabled tests with unittest results."""
1455
test = SampleTestCase('_test_pass')
1456
class DisabledFeature(object):
1457
def available(self):
1459
test._test_needs_features = [DisabledFeature()]
1460
result = unittest.TestResult()
1462
self.assertEqual(1, result.testsRun)
1463
self.assertEqual([], result.errors)
1464
self.assertEqual([], result.failures)
1466
def test_run_disabled_supporting_result(self):
1467
"""Test disabled tests behaviour with support aware results."""
1468
test = SampleTestCase('_test_pass')
1469
class DisabledFeature(object):
1470
def available(self):
1472
the_feature = DisabledFeature()
1473
test._test_needs_features = [the_feature]
1474
class InstrumentedTestResult(unittest.TestResult):
1476
unittest.TestResult.__init__(self)
1478
def startTest(self, test):
1479
self.calls.append(('startTest', test))
1480
def stopTest(self, test):
1481
self.calls.append(('stopTest', test))
1482
def addNotSupported(self, test, feature):
1483
self.calls.append(('addNotSupported', test, feature))
1484
result = InstrumentedTestResult()
1487
('startTest', test),
1488
('addNotSupported', test, the_feature),
1493
def test_assert_list_raises_on_generator(self):
1494
def generator_which_will_raise():
1495
# This will not raise until after the first yield
1497
raise _TestException()
1499
e = self.assertListRaises(_TestException, generator_which_will_raise)
1500
self.assertIsInstance(e, _TestException)
1502
e = self.assertListRaises(Exception, generator_which_will_raise)
1503
self.assertIsInstance(e, _TestException)
1505
def test_assert_list_raises_on_plain(self):
1506
def plain_exception():
1507
raise _TestException()
1510
e = self.assertListRaises(_TestException, plain_exception)
1511
self.assertIsInstance(e, _TestException)
1513
e = self.assertListRaises(Exception, plain_exception)
1514
self.assertIsInstance(e, _TestException)
1516
def test_assert_list_raises_assert_wrong_exception(self):
1517
class _NotTestException(Exception):
1520
def wrong_exception():
1521
raise _NotTestException()
1523
def wrong_exception_generator():
1526
raise _NotTestException()
1528
# Wrong exceptions are not intercepted
1529
self.assertRaises(_NotTestException,
1530
self.assertListRaises, _TestException, wrong_exception)
1531
self.assertRaises(_NotTestException,
1532
self.assertListRaises, _TestException, wrong_exception_generator)
1534
def test_assert_list_raises_no_exception(self):
1538
def success_generator():
1542
self.assertRaises(AssertionError,
1543
self.assertListRaises, _TestException, success)
1545
self.assertRaises(AssertionError,
1546
self.assertListRaises, _TestException, success_generator)
1549
882
@symbol_versioning.deprecated_function(zero_eleven)
1550
883
def sample_deprecated_function():
1693
1010
self.assertEqual([True], factory_called)
1696
class TestKnownFailure(TestCase):
1698
def test_known_failure(self):
1699
"""Check that KnownFailure is defined appropriately."""
1700
# a KnownFailure is an assertion error for compatability with unaware
1702
self.assertIsInstance(KnownFailure(""), AssertionError)
1704
def test_expect_failure(self):
1706
self.expectFailure("Doomed to failure", self.assertTrue, False)
1707
except KnownFailure, e:
1708
self.assertEqual('Doomed to failure', e.args[0])
1710
self.expectFailure("Doomed to failure", self.assertTrue, True)
1711
except AssertionError, e:
1712
self.assertEqual('Unexpected success. Should have failed:'
1713
' Doomed to failure', e.args[0])
1715
self.fail('Assertion not raised')
1718
class TestFeature(TestCase):
1720
def test_caching(self):
1721
"""Feature._probe is called by the feature at most once."""
1722
class InstrumentedFeature(Feature):
1724
Feature.__init__(self)
1727
self.calls.append('_probe')
1729
feature = InstrumentedFeature()
1731
self.assertEqual(['_probe'], feature.calls)
1733
self.assertEqual(['_probe'], feature.calls)
1735
def test_named_str(self):
1736
"""Feature.__str__ should thunk to feature_name()."""
1737
class NamedFeature(Feature):
1738
def feature_name(self):
1740
feature = NamedFeature()
1741
self.assertEqual('symlinks', str(feature))
1743
def test_default_str(self):
1744
"""Feature.__str__ should default to __class__.__name__."""
1745
class NamedFeature(Feature):
1747
feature = NamedFeature()
1748
self.assertEqual('NamedFeature', str(feature))
1751
class TestUnavailableFeature(TestCase):
1753
def test_access_feature(self):
1755
exception = UnavailableFeature(feature)
1756
self.assertIs(feature, exception.args[0])
1759
class TestSelftestFiltering(TestCase):
1762
self.suite = TestUtil.TestSuite()
1763
self.loader = TestUtil.TestLoader()
1764
self.suite.addTest(self.loader.loadTestsFromModuleNames([
1765
'bzrlib.tests.test_selftest']))
1766
self.all_names = _test_ids(self.suite)
1768
def test_condition_id_re(self):
1769
test_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1770
'test_condition_id_re')
1771
filtered_suite = filter_suite_by_condition(self.suite,
1772
condition_id_re('test_condition_id_re'))
1773
self.assertEqual([test_name], _test_ids(filtered_suite))
1775
def test_condition_id_in_list(self):
1776
test_names = ['bzrlib.tests.test_selftest.TestSelftestFiltering.'
1777
'test_condition_id_in_list']
1778
id_list = tests.TestIdList(test_names)
1779
filtered_suite = filter_suite_by_condition(
1780
self.suite, tests.condition_id_in_list(id_list))
1781
my_pattern = 'TestSelftestFiltering.*test_condition_id_in_list'
1782
re_filtered = filter_suite_by_re(self.suite, my_pattern)
1783
self.assertEqual(_test_ids(re_filtered), _test_ids(filtered_suite))
1785
def test_condition_id_startswith(self):
1786
klass = 'bzrlib.tests.test_selftest.TestSelftestFiltering.'
1787
start = klass + 'test_condition_id_starts'
1788
test_names = [klass + 'test_condition_id_startswith']
1789
filtered_suite = filter_suite_by_condition(
1790
self.suite, tests.condition_id_startswith(start))
1791
my_pattern = 'TestSelftestFiltering.*test_condition_id_startswith'
1792
re_filtered = filter_suite_by_re(self.suite, my_pattern)
1793
self.assertEqual(_test_ids(re_filtered), _test_ids(filtered_suite))
1795
def test_condition_isinstance(self):
1796
filtered_suite = filter_suite_by_condition(self.suite,
1797
condition_isinstance(self.__class__))
1798
class_pattern = 'bzrlib.tests.test_selftest.TestSelftestFiltering.'
1799
re_filtered = filter_suite_by_re(self.suite, class_pattern)
1800
self.assertEqual(_test_ids(re_filtered), _test_ids(filtered_suite))
1802
def test_exclude_tests_by_condition(self):
1803
excluded_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1804
'test_exclude_tests_by_condition')
1805
filtered_suite = exclude_tests_by_condition(self.suite,
1806
lambda x:x.id() == excluded_name)
1807
self.assertEqual(len(self.all_names) - 1,
1808
filtered_suite.countTestCases())
1809
self.assertFalse(excluded_name in _test_ids(filtered_suite))
1810
remaining_names = list(self.all_names)
1811
remaining_names.remove(excluded_name)
1812
self.assertEqual(remaining_names, _test_ids(filtered_suite))
1814
def test_exclude_tests_by_re(self):
1815
self.all_names = _test_ids(self.suite)
1816
filtered_suite = exclude_tests_by_re(self.suite, 'exclude_tests_by_re')
1817
excluded_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1818
'test_exclude_tests_by_re')
1819
self.assertEqual(len(self.all_names) - 1,
1820
filtered_suite.countTestCases())
1821
self.assertFalse(excluded_name in _test_ids(filtered_suite))
1822
remaining_names = list(self.all_names)
1823
remaining_names.remove(excluded_name)
1824
self.assertEqual(remaining_names, _test_ids(filtered_suite))
1826
def test_filter_suite_by_condition(self):
1827
test_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1828
'test_filter_suite_by_condition')
1829
filtered_suite = filter_suite_by_condition(self.suite,
1830
lambda x:x.id() == test_name)
1831
self.assertEqual([test_name], _test_ids(filtered_suite))
1833
def test_filter_suite_by_re(self):
1834
filtered_suite = filter_suite_by_re(self.suite, 'test_filter_suite_by_r')
1835
filtered_names = _test_ids(filtered_suite)
1836
self.assertEqual(filtered_names, ['bzrlib.tests.test_selftest.'
1837
'TestSelftestFiltering.test_filter_suite_by_re'])
1839
def test_filter_suite_by_id_list(self):
1840
test_list = ['bzrlib.tests.test_selftest.'
1841
'TestSelftestFiltering.test_filter_suite_by_id_list']
1842
filtered_suite = tests.filter_suite_by_id_list(
1843
self.suite, tests.TestIdList(test_list))
1844
filtered_names = _test_ids(filtered_suite)
1847
['bzrlib.tests.test_selftest.'
1848
'TestSelftestFiltering.test_filter_suite_by_id_list'])
1850
def test_filter_suite_by_id_startswith(self):
1851
# By design this test may fail if another test is added whose name also
1852
# begins with the start value used.
1853
klass = 'bzrlib.tests.test_selftest.TestSelftestFiltering.'
1854
start = klass + 'test_filter_suite_by_id_starts'
1855
test_list = [klass + 'test_filter_suite_by_id_startswith']
1856
filtered_suite = tests.filter_suite_by_id_startswith(self.suite, start)
1857
filtered_names = _test_ids(filtered_suite)
1860
['bzrlib.tests.test_selftest.'
1861
'TestSelftestFiltering.test_filter_suite_by_id_startswith'])
1863
def test_preserve_input(self):
1864
# NB: Surely this is something in the stdlib to do this?
1865
self.assertTrue(self.suite is preserve_input(self.suite))
1866
self.assertTrue("@#$" is preserve_input("@#$"))
1868
def test_randomize_suite(self):
1869
randomized_suite = randomize_suite(self.suite)
1870
# randomizing should not add or remove test names.
1871
self.assertEqual(set(_test_ids(self.suite)),
1872
set(_test_ids(randomized_suite)))
1873
# Technically, this *can* fail, because random.shuffle(list) can be
1874
# equal to list. Trying multiple times just pushes the frequency back.
1875
# As its len(self.all_names)!:1, the failure frequency should be low
1876
# enough to ignore. RBC 20071021.
1877
# It should change the order.
1878
self.assertNotEqual(self.all_names, _test_ids(randomized_suite))
1879
# But not the length. (Possibly redundant with the set test, but not
1881
self.assertEqual(len(self.all_names), len(_test_ids(randomized_suite)))
1883
def test_split_suit_by_condition(self):
1884
self.all_names = _test_ids(self.suite)
1885
condition = condition_id_re('test_filter_suite_by_r')
1886
split_suite = split_suite_by_condition(self.suite, condition)
1887
filtered_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1888
'test_filter_suite_by_re')
1889
self.assertEqual([filtered_name], _test_ids(split_suite[0]))
1890
self.assertFalse(filtered_name in _test_ids(split_suite[1]))
1891
remaining_names = list(self.all_names)
1892
remaining_names.remove(filtered_name)
1893
self.assertEqual(remaining_names, _test_ids(split_suite[1]))
1895
def test_split_suit_by_re(self):
1896
self.all_names = _test_ids(self.suite)
1897
split_suite = split_suite_by_re(self.suite, 'test_filter_suite_by_r')
1898
filtered_name = ('bzrlib.tests.test_selftest.TestSelftestFiltering.'
1899
'test_filter_suite_by_re')
1900
self.assertEqual([filtered_name], _test_ids(split_suite[0]))
1901
self.assertFalse(filtered_name in _test_ids(split_suite[1]))
1902
remaining_names = list(self.all_names)
1903
remaining_names.remove(filtered_name)
1904
self.assertEqual(remaining_names, _test_ids(split_suite[1]))
1907
class TestCheckInventoryShape(TestCaseWithTransport):
1909
def test_check_inventory_shape(self):
1910
files = ['a', 'b/', 'b/c']
1911
tree = self.make_branch_and_tree('.')
1912
self.build_tree(files)
1916
self.check_inventory_shape(tree.inventory, files)
1921
class TestBlackboxSupport(TestCase):
1922
"""Tests for testsuite blackbox features."""
1924
def test_run_bzr_failure_not_caught(self):
1925
# When we run bzr in blackbox mode, we want any unexpected errors to
1926
# propagate up to the test suite so that it can show the error in the
1927
# usual way, and we won't get a double traceback.
1928
e = self.assertRaises(
1930
self.run_bzr, ['assert-fail'])
1931
# make sure we got the real thing, not an error from somewhere else in
1932
# the test framework
1933
self.assertEquals('always fails', str(e))
1934
# check that there's no traceback in the test log
1935
self.assertNotContainsRe(self._get_log(keep_log_file=True),
1938
def test_run_bzr_user_error_caught(self):
1939
# Running bzr in blackbox mode, normal/expected/user errors should be
1940
# caught in the regular way and turned into an error message plus exit
1942
out, err = self.run_bzr(["log", "/nonexistantpath"], retcode=3)
1943
self.assertEqual(out, '')
1944
self.assertContainsRe(err,
1945
'bzr: ERROR: Not a branch: ".*nonexistantpath/".\n')
1948
class TestTestLoader(TestCase):
1949
"""Tests for the test loader."""
1951
def _get_loader_and_module(self):
1952
"""Gets a TestLoader and a module with one test in it."""
1953
loader = TestUtil.TestLoader()
1955
class Stub(TestCase):
1958
class MyModule(object):
1960
MyModule.a_class = Stub
1962
return loader, module
1964
def test_module_no_load_tests_attribute_loads_classes(self):
1965
loader, module = self._get_loader_and_module()
1966
self.assertEqual(1, loader.loadTestsFromModule(module).countTestCases())
1968
def test_module_load_tests_attribute_gets_called(self):
1969
loader, module = self._get_loader_and_module()
1970
# 'self' is here because we're faking the module with a class. Regular
1971
# load_tests do not need that :)
1972
def load_tests(self, standard_tests, module, loader):
1973
result = loader.suiteClass()
1974
for test in iter_suite_tests(standard_tests):
1975
result.addTests([test, test])
1977
# add a load_tests() method which multiplies the tests from the module.
1978
module.__class__.load_tests = load_tests
1979
self.assertEqual(2, loader.loadTestsFromModule(module).countTestCases())
1981
def test_load_tests_from_module_name_smoke_test(self):
1982
loader = TestUtil.TestLoader()
1983
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
1984
self.assertEquals(['bzrlib.tests.test_sampler.DemoTest.test_nothing'],
1987
def test_load_tests_from_module_name_with_bogus_module_name(self):
1988
loader = TestUtil.TestLoader()
1989
self.assertRaises(ImportError, loader.loadTestsFromModuleName, 'bogus')
1992
class TestTestIdList(tests.TestCase):
1994
def _create_id_list(self, test_list):
1995
return tests.TestIdList(test_list)
1997
def _create_suite(self, test_id_list):
1999
class Stub(TestCase):
2003
def _create_test_id(id):
2006
suite = TestUtil.TestSuite()
2007
for id in test_id_list:
2008
t = Stub('test_foo')
2009
t.id = _create_test_id(id)
2013
def _test_ids(self, test_suite):
2014
"""Get the ids for the tests in a test suite."""
2015
return [t.id() for t in iter_suite_tests(test_suite)]
2017
def test_empty_list(self):
2018
id_list = self._create_id_list([])
2019
self.assertEquals({}, id_list.tests)
2020
self.assertEquals({}, id_list.modules)
2022
def test_valid_list(self):
2023
id_list = self._create_id_list(
2024
['mod1.cl1.meth1', 'mod1.cl1.meth2',
2025
'mod1.func1', 'mod1.cl2.meth2',
2027
'mod1.submod2.cl1.meth1', 'mod1.submod2.cl2.meth2',
2029
self.assertTrue(id_list.refers_to('mod1'))
2030
self.assertTrue(id_list.refers_to('mod1.submod1'))
2031
self.assertTrue(id_list.refers_to('mod1.submod2'))
2032
self.assertTrue(id_list.includes('mod1.cl1.meth1'))
2033
self.assertTrue(id_list.includes('mod1.submod1'))
2034
self.assertTrue(id_list.includes('mod1.func1'))
2036
def test_bad_chars_in_params(self):
2037
id_list = self._create_id_list(['mod1.cl1.meth1(xx.yy)'])
2038
self.assertTrue(id_list.refers_to('mod1'))
2039
self.assertTrue(id_list.includes('mod1.cl1.meth1(xx.yy)'))
2041
def test_module_used(self):
2042
id_list = self._create_id_list(['mod.class.meth'])
2043
self.assertTrue(id_list.refers_to('mod'))
2044
self.assertTrue(id_list.refers_to('mod.class'))
2045
self.assertTrue(id_list.refers_to('mod.class.meth'))
2047
def test_test_suite(self):
2048
# This test is slow, so we do a single test with one test in each
2052
'bzrlib.tests.blackbox.test_branch.TestBranch.test_branch',
2053
'bzrlib.tests.test_selftest.TestTestIdList.test_test_suite',
2054
# transport implementations
2055
'bzrlib.tests.test_transport_implementations.TransportTests'
2056
'.test_abspath(LocalURLServer)',
2057
# modules_to_doctest
2058
'bzrlib.timestamp.format_highres_date',
2059
# plugins can't be tested that way since selftest may be run with
2062
suite = tests.test_suite(test_list)
2063
self.assertEquals(test_list, _test_ids(suite))
2065
def test_test_suite_matches_id_list_with_unknown(self):
2066
loader = TestUtil.TestLoader()
2067
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2068
test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing',
2070
not_found, duplicates = tests.suite_matches_id_list(suite, test_list)
2071
self.assertEquals(['bogus'], not_found)
2072
self.assertEquals([], duplicates)
2074
def test_suite_matches_id_list_with_duplicates(self):
2075
loader = TestUtil.TestLoader()
2076
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2077
dupes = loader.suiteClass()
2078
for test in iter_suite_tests(suite):
2080
dupes.addTest(test) # Add it again
2082
test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing',]
2083
not_found, duplicates = tests.suite_matches_id_list(
2085
self.assertEquals([], not_found)
2086
self.assertEquals(['bzrlib.tests.test_sampler.DemoTest.test_nothing'],
2090
class TestLoadTestIdList(tests.TestCaseInTempDir):
2092
def _create_test_list_file(self, file_name, content):
2093
fl = open(file_name, 'wt')
2097
def test_load_unknown(self):
2098
self.assertRaises(errors.NoSuchFile,
2099
tests.load_test_id_list, 'i_do_not_exist')
2101
def test_load_test_list(self):
2102
test_list_fname = 'test.list'
2103
self._create_test_list_file(test_list_fname,
2104
'mod1.cl1.meth1\nmod2.cl2.meth2\n')
2105
tlist = tests.load_test_id_list(test_list_fname)
2106
self.assertEquals(2, len(tlist))
2107
self.assertEquals('mod1.cl1.meth1', tlist[0])
2108
self.assertEquals('mod2.cl2.meth2', tlist[1])
2110
def test_load_dirty_file(self):
2111
test_list_fname = 'test.list'
2112
self._create_test_list_file(test_list_fname,
2113
' mod1.cl1.meth1\n\nmod2.cl2.meth2 \n'
2115
tlist = tests.load_test_id_list(test_list_fname)
2116
self.assertEquals(4, len(tlist))
2117
self.assertEquals('mod1.cl1.meth1', tlist[0])
2118
self.assertEquals('', tlist[1])
2119
self.assertEquals('mod2.cl2.meth2', tlist[2])
2120
self.assertEquals('bar baz', tlist[3])
2123
class TestFilteredByModuleTestLoader(tests.TestCase):
2125
def _create_loader(self, test_list):
2126
id_filter = tests.TestIdList(test_list)
2127
loader = TestUtil.FilteredByModuleTestLoader(id_filter.refers_to)
2130
def test_load_tests(self):
2131
test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing']
2132
loader = self._create_loader(test_list)
2134
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2135
self.assertEquals(test_list, _test_ids(suite))
2137
def test_exclude_tests(self):
2138
test_list = ['bogus']
2139
loader = self._create_loader(test_list)
2141
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2142
self.assertEquals([], _test_ids(suite))
2145
class TestFilteredByNameStartTestLoader(tests.TestCase):
2147
def _create_loader(self, name_start):
2148
def needs_module(name):
2149
return name.startswith(name_start) or name_start.startswith(name)
2150
loader = TestUtil.FilteredByModuleTestLoader(needs_module)
2153
def test_load_tests(self):
2154
test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing']
2155
loader = self._create_loader('bzrlib.tests.test_samp')
2157
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2158
self.assertEquals(test_list, _test_ids(suite))
2160
def test_load_tests_inside_module(self):
2161
test_list = ['bzrlib.tests.test_sampler.DemoTest.test_nothing']
2162
loader = self._create_loader('bzrlib.tests.test_sampler.Demo')
2164
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2165
self.assertEquals(test_list, _test_ids(suite))
2167
def test_exclude_tests(self):
2168
test_list = ['bogus']
2169
loader = self._create_loader('bogus')
2171
suite = loader.loadTestsFromModuleName('bzrlib.tests.test_sampler')
2172
self.assertEquals([], _test_ids(suite))
1013
class TestSelftestCleanOutput(TestCaseInTempDir):
1015
def test_clean_output(self):
1016
# test functionality of clean_selftest_output()
1017
from bzrlib.tests import clean_selftest_output
1019
dirs = ('test0000.tmp', 'test0001.tmp', 'bzrlib', 'tests')
1020
files = ('bzr', 'setup.py', 'test9999.tmp')
1025
f.write('content of ')
1030
before = os.listdir(root)
1032
self.assertEquals(['bzr','bzrlib','setup.py',
1033
'test0000.tmp','test0001.tmp',
1034
'test9999.tmp','tests'],
1036
clean_selftest_output(root, quiet=True)
1037
after = os.listdir(root)
1039
self.assertEquals(['bzr','bzrlib','setup.py',
1040
'test9999.tmp','tests'],
added
removed
bzrlib/tests/test_selftest.py
