/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 bzr.dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_selftest.py
50
50
                          TestUtil,
51
51
                          TextTestRunner,
52
52
                          UnavailableFeature,
53
 
                          clean_selftest_output,
54
53
                          iter_suite_tests,
55
54
                          filter_suite_by_re,
56
55
                          sort_suite_by_re,
114
113
            def get_test_permutations(self):
115
114
                return sample_permutation
116
115
        sample_permutation = [(1,2), (3,4)]
117
 
        from bzrlib.transport import TransportTestProviderAdapter
 
116
        from bzrlib.tests.test_transport_implementations \
 
117
            import TransportTestProviderAdapter
118
118
        adapter = TransportTestProviderAdapter()
119
119
        self.assertEqual(sample_permutation,
120
120
                         adapter.get_transport_test_permutations(MockModule()))
125
125
        # - we assume if this matches its probably doing the right thing
126
126
        # especially in combination with the tests for setting the right
127
127
        # classes below.
128
 
        from bzrlib.transport import (TransportTestProviderAdapter,
129
 
                                      _get_transport_modules
130
 
                                      )
 
128
        from bzrlib.tests.test_transport_implementations \
 
129
            import TransportTestProviderAdapter
 
130
        from bzrlib.transport import _get_transport_modules
131
131
        modules = _get_transport_modules()
132
132
        permutation_count = 0
133
133
        for module in modules:
150
150
        # This test used to know about all the possible transports and the
151
151
        # order they were returned but that seems overly brittle (mbp
152
152
        # 20060307)
153
 
        input_test = TestTransportProviderAdapter(
154
 
            "test_adapter_sets_transport_class")
155
 
        from bzrlib.transport import TransportTestProviderAdapter
156
 
        suite = TransportTestProviderAdapter().adapt(input_test)
157
 
        tests = list(iter(suite))
158
 
        self.assertTrue(len(tests) > 6)
 
153
        from bzrlib.tests.test_transport_implementations \
 
154
            import TransportTestProviderAdapter
 
155
        scenarios = TransportTestProviderAdapter().scenarios
159
156
        # there are at least that many builtin transports
160
 
        one_test = tests[0]
161
 
        self.assertTrue(issubclass(one_test.transport_class, 
 
157
        self.assertTrue(len(scenarios) > 6)
 
158
        one_scenario = scenarios[0]
 
159
        self.assertIsInstance(one_scenario[0], str)
 
160
        self.assertTrue(issubclass(one_scenario[1]["transport_class"],
162
161
                                   bzrlib.transport.Transport))
163
 
        self.assertTrue(issubclass(one_test.transport_server, 
 
162
        self.assertTrue(issubclass(one_scenario[1]["transport_server"],
164
163
                                   bzrlib.transport.Server))
165
164
 
166
165
 
167
166
class TestBranchProviderAdapter(TestCase):
168
167
    """A group of tests that test the branch implementation test adapter."""
169
168
 
170
 
    def test_adapted_tests(self):
 
169
    def test_constructor(self):
171
170
        # check that constructor parameters are passed through to the adapted
172
171
        # test.
173
 
        from bzrlib.branch import BranchTestProviderAdapter
174
 
        input_test = TestBranchProviderAdapter(
175
 
            "test_adapted_tests")
 
172
        from bzrlib.tests.branch_implementations import BranchTestProviderAdapter
176
173
        server1 = "a"
177
174
        server2 = "b"
178
175
        formats = [("c", "C"), ("d", "D")]
179
176
        adapter = BranchTestProviderAdapter(server1, server2, formats)
180
 
        suite = adapter.adapt(input_test)
181
 
        tests = list(iter(suite))
182
 
        self.assertEqual(2, len(tests))
183
 
        self.assertEqual(tests[0].branch_format, formats[0][0])
184
 
        self.assertEqual(tests[0].bzrdir_format, formats[0][1])
185
 
        self.assertEqual(tests[0].transport_server, server1)
186
 
        self.assertEqual(tests[0].transport_readonly_server, server2)
187
 
        self.assertEqual(tests[1].branch_format, formats[1][0])
188
 
        self.assertEqual(tests[1].bzrdir_format, formats[1][1])
189
 
        self.assertEqual(tests[1].transport_server, server1)
190
 
        self.assertEqual(tests[1].transport_readonly_server, server2)
 
177
        self.assertEqual(2, len(adapter.scenarios))
 
178
        self.assertEqual([
 
179
            ('str',
 
180
             {'branch_format': 'c',
 
181
              'bzrdir_format': 'C',
 
182
              'transport_readonly_server': 'b',
 
183
              'transport_server': 'a'}),
 
184
            ('str',
 
185
             {'branch_format': 'd',
 
186
              'bzrdir_format': 'D',
 
187
              'transport_readonly_server': 'b',
 
188
              'transport_server': 'a'})],
 
189
            adapter.scenarios)
191
190
 
192
191
 
193
192
class TestBzrDirProviderAdapter(TestCase):
196
195
    def test_adapted_tests(self):
197
196
        # check that constructor parameters are passed through to the adapted
198
197
        # test.
199
 
        from bzrlib.bzrdir import BzrDirTestProviderAdapter
200
 
        input_test = TestBzrDirProviderAdapter(
201
 
            "test_adapted_tests")
 
198
        from bzrlib.tests.bzrdir_implementations import BzrDirTestProviderAdapter
202
199
        vfs_factory = "v"
203
200
        server1 = "a"
204
201
        server2 = "b"
205
202
        formats = ["c", "d"]
206
203
        adapter = BzrDirTestProviderAdapter(vfs_factory,
207
204
            server1, server2, formats)
208
 
        suite = adapter.adapt(input_test)
209
 
        tests = list(iter(suite))
210
 
        self.assertEqual(2, len(tests))
211
 
        self.assertEqual(tests[0].bzrdir_format, formats[0])
212
 
        self.assertEqual(tests[0].vfs_transport_factory, vfs_factory)
213
 
        self.assertEqual(tests[0].transport_server, server1)
214
 
        self.assertEqual(tests[0].transport_readonly_server, server2)
215
 
        self.assertEqual(tests[1].bzrdir_format, formats[1])
216
 
        self.assertEqual(tests[1].vfs_transport_factory, vfs_factory)
217
 
        self.assertEqual(tests[1].transport_server, server1)
218
 
        self.assertEqual(tests[1].transport_readonly_server, server2)
 
205
        self.assertEqual([
 
206
            ('str',
 
207
             {'bzrdir_format': 'c',
 
208
              'transport_readonly_server': 'b',
 
209
              'transport_server': 'a',
 
210
              'vfs_transport_factory': 'v'}),
 
211
            ('str',
 
212
             {'bzrdir_format': 'd',
 
213
              'transport_readonly_server': 'b',
 
214
              'transport_server': 'a',
 
215
              'vfs_transport_factory': 'v'})],
 
216
            adapter.scenarios)
219
217
 
220
218
 
221
219
class TestRepositoryProviderAdapter(TestCase):
222
220
    """A group of tests that test the repository implementation test adapter."""
223
221
 
224
 
    def test_adapted_tests(self):
225
 
        # check that constructor parameters are passed through to the adapted
226
 
        # test.
227
 
        from bzrlib.repository import RepositoryTestProviderAdapter
228
 
        input_test = TestRepositoryProviderAdapter(
229
 
            "test_adapted_tests")
 
222
    def test_constructor(self):
 
223
        # check that constructor parameters are passed through to the
 
224
        # scenarios.
 
225
        from bzrlib.tests.repository_implementations import RepositoryTestProviderAdapter
230
226
        server1 = "a"
231
227
        server2 = "b"
232
228
        formats = [("c", "C"), ("d", "D")]
233
229
        adapter = RepositoryTestProviderAdapter(server1, server2, formats)
234
 
        suite = adapter.adapt(input_test)
235
 
        tests = list(iter(suite))
236
 
        self.assertEqual(2, len(tests))
237
 
        self.assertEqual(tests[0].bzrdir_format, formats[0][1])
238
 
        self.assertEqual(tests[0].repository_format, formats[0][0])
239
 
        self.assertEqual(tests[0].transport_server, server1)
240
 
        self.assertEqual(tests[0].transport_readonly_server, server2)
241
 
        self.assertEqual(tests[1].bzrdir_format, formats[1][1])
242
 
        self.assertEqual(tests[1].repository_format, formats[1][0])
243
 
        self.assertEqual(tests[1].transport_server, server1)
244
 
        self.assertEqual(tests[1].transport_readonly_server, server2)
 
230
        self.assertEqual([
 
231
            ('str',
 
232
             {'bzrdir_format': 'C',
 
233
              'repository_format': 'c',
 
234
              'transport_readonly_server': 'b',
 
235
              'transport_server': 'a'}),
 
236
            ('str',
 
237
             {'bzrdir_format': 'D',
 
238
              'repository_format': 'd',
 
239
              'transport_readonly_server': 'b',
 
240
              'transport_server': 'a'})],
 
241
            adapter.scenarios)
245
242
 
246
243
    def test_setting_vfs_transport(self):
247
244
        """The vfs_transport_factory can be set optionally."""
248
 
        from bzrlib.repository import RepositoryTestProviderAdapter
249
 
        input_test = TestRepositoryProviderAdapter(
250
 
            "test_adapted_tests")
251
 
        formats = [("c", "C")]
 
245
        from bzrlib.tests.repository_implementations import RepositoryTestProviderAdapter
 
246
        formats = [("a", "b"), ("c", "d")]
252
247
        adapter = RepositoryTestProviderAdapter(None, None, formats,
253
248
            vfs_transport_factory="vfs")
254
 
        suite = adapter.adapt(input_test)
255
 
        tests = list(iter(suite))
256
 
        self.assertEqual(1, len(tests))
257
 
        self.assertEqual(tests[0].vfs_transport_factory, "vfs")
 
249
        self.assertEqual([
 
250
            ('str',
 
251
             {'bzrdir_format': 'b',
 
252
              'repository_format': 'a',
 
253
              'transport_readonly_server': None,
 
254
              'transport_server': None,
 
255
              'vfs_transport_factory': 'vfs'}),
 
256
            ('str',
 
257
             {'bzrdir_format': 'd',
 
258
              'repository_format': 'c',
 
259
              'transport_readonly_server': None,
 
260
              'transport_server': None,
 
261
              'vfs_transport_factory': 'vfs'})],
 
262
            adapter.scenarios)
 
263
 
 
264
    def test_formats_to_scenarios(self):
 
265
        """The adapter can generate all the scenarios needed."""
 
266
        from bzrlib.tests.repository_implementations import RepositoryTestProviderAdapter
 
267
        no_vfs_adapter = RepositoryTestProviderAdapter("server", "readonly",
 
268
            [], None)
 
269
        vfs_adapter = RepositoryTestProviderAdapter("server", "readonly",
 
270
            [], vfs_transport_factory="vfs")
 
271
        # no_vfs generate scenarios without vfs_transport_factor
 
272
        formats = [("c", "C"), (1, "D")]
 
273
        self.assertEqual([
 
274
            ('str',
 
275
             {'bzrdir_format': 'C',
 
276
              'repository_format': 'c',
 
277
              'transport_readonly_server': 'readonly',
 
278
              'transport_server': 'server'}),
 
279
            ('int',
 
280
             {'bzrdir_format': 'D',
 
281
              'repository_format': 1,
 
282
              'transport_readonly_server': 'readonly',
 
283
              'transport_server': 'server'})],
 
284
            no_vfs_adapter.formats_to_scenarios(formats))
 
285
        self.assertEqual([
 
286
            ('str',
 
287
             {'bzrdir_format': 'C',
 
288
              'repository_format': 'c',
 
289
              'transport_readonly_server': 'readonly',
 
290
              'transport_server': 'server',
 
291
              'vfs_transport_factory': 'vfs'}),
 
292
            ('int',
 
293
             {'bzrdir_format': 'D',
 
294
              'repository_format': 1,
 
295
              'transport_readonly_server': 'readonly',
 
296
              'transport_server': 'server',
 
297
              'vfs_transport_factory': 'vfs'})],
 
298
            vfs_adapter.formats_to_scenarios(formats))
 
299
 
 
300
 
 
301
class TestTestScenarioApplier(TestCase):
 
302
    """Tests for the test adaption facilities."""
 
303
 
 
304
    def test_adapt_applies_scenarios(self):
 
305
        from bzrlib.tests.repository_implementations import TestScenarioApplier
 
306
        input_test = TestTestScenarioApplier("test_adapt_test_to_scenario")
 
307
        adapter = TestScenarioApplier()
 
308
        adapter.scenarios = [("1", "dict"), ("2", "settings")]
 
309
        calls = []
 
310
        def capture_call(test, scenario):
 
311
            calls.append((test, scenario))
 
312
            return test
 
313
        adapter.adapt_test_to_scenario = capture_call
 
314
        adapter.adapt(input_test)
 
315
        self.assertEqual([(input_test, ("1", "dict")),
 
316
            (input_test, ("2", "settings"))], calls)
 
317
 
 
318
    def test_adapt_test_to_scenario(self):
 
319
        from bzrlib.tests.repository_implementations import TestScenarioApplier
 
320
        input_test = TestTestScenarioApplier("test_adapt_test_to_scenario")
 
321
        adapter = TestScenarioApplier()
 
322
        # setup two adapted tests
 
323
        adapted_test1 = adapter.adapt_test_to_scenario(input_test,
 
324
            ("new id",
 
325
            {"bzrdir_format":"bzr_format",
 
326
             "repository_format":"repo_fmt",
 
327
             "transport_server":"transport_server",
 
328
             "transport_readonly_server":"readonly-server"}))
 
329
        adapted_test2 = adapter.adapt_test_to_scenario(input_test,
 
330
            ("new id 2", {"bzrdir_format":None}))
 
331
        # input_test should have been altered.
 
332
        self.assertRaises(AttributeError, getattr, input_test, "bzrdir_format")
 
333
        # the new tests are mutually incompatible, ensuring it has 
 
334
        # made new ones, and unspecified elements in the scenario
 
335
        # should not have been altered.
 
336
        self.assertEqual("bzr_format", adapted_test1.bzrdir_format)
 
337
        self.assertEqual("repo_fmt", adapted_test1.repository_format)
 
338
        self.assertEqual("transport_server", adapted_test1.transport_server)
 
339
        self.assertEqual("readonly-server",
 
340
            adapted_test1.transport_readonly_server)
 
341
        self.assertEqual(
 
342
            "bzrlib.tests.test_selftest.TestTestScenarioApplier."
 
343
            "test_adapt_test_to_scenario(new id)",
 
344
            adapted_test1.id())
 
345
        self.assertEqual(None, adapted_test2.bzrdir_format)
 
346
        self.assertEqual(
 
347
            "bzrlib.tests.test_selftest.TestTestScenarioApplier."
 
348
            "test_adapt_test_to_scenario(new id 2)",
 
349
            adapted_test2.id())
258
350
 
259
351
 
260
352
class TestInterRepositoryProviderAdapter(TestCase):
263
355
    def test_adapted_tests(self):
264
356
        # check that constructor parameters are passed through to the adapted
265
357
        # test.
266
 
        from bzrlib.repository import InterRepositoryTestProviderAdapter
267
 
        input_test = TestInterRepositoryProviderAdapter(
268
 
            "test_adapted_tests")
 
358
        from bzrlib.tests.interrepository_implementations import \
 
359
            InterRepositoryTestProviderAdapter
269
360
        server1 = "a"
270
361
        server2 = "b"
271
362
        formats = [(str, "C1", "C2"), (int, "D1", "D2")]
272
363
        adapter = InterRepositoryTestProviderAdapter(server1, server2, formats)
273
 
        suite = adapter.adapt(input_test)
274
 
        tests = list(iter(suite))
275
 
        self.assertEqual(2, len(tests))
276
 
        self.assertEqual(tests[0].interrepo_class, formats[0][0])
277
 
        self.assertEqual(tests[0].repository_format, formats[0][1])
278
 
        self.assertEqual(tests[0].repository_format_to, formats[0][2])
279
 
        self.assertEqual(tests[0].transport_server, server1)
280
 
        self.assertEqual(tests[0].transport_readonly_server, server2)
281
 
        self.assertEqual(tests[1].interrepo_class, formats[1][0])
282
 
        self.assertEqual(tests[1].repository_format, formats[1][1])
283
 
        self.assertEqual(tests[1].repository_format_to, formats[1][2])
284
 
        self.assertEqual(tests[1].transport_server, server1)
285
 
        self.assertEqual(tests[1].transport_readonly_server, server2)
 
364
        self.assertEqual([
 
365
            ('str',
 
366
             {'interrepo_class': str,
 
367
              'repository_format': 'C1',
 
368
              'repository_format_to': 'C2',
 
369
              'transport_readonly_server': 'b',
 
370
              'transport_server': 'a'}),
 
371
            ('int',
 
372
             {'interrepo_class': int,
 
373
              'repository_format': 'D1',
 
374
              'repository_format_to': 'D2',
 
375
              'transport_readonly_server': 'b',
 
376
              'transport_server': 'a'})],
 
377
            adapter.formats_to_scenarios(formats))
286
378
 
287
379
 
288
380
class TestInterVersionedFileProviderAdapter(TestCase):
289
381
    """A group of tests that test the InterVersionedFile test adapter."""
290
382
 
291
 
    def test_adapted_tests(self):
 
383
    def test_scenarios(self):
292
384
        # check that constructor parameters are passed through to the adapted
293
385
        # test.
294
 
        from bzrlib.versionedfile import InterVersionedFileTestProviderAdapter
295
 
        input_test = TestInterRepositoryProviderAdapter(
296
 
            "test_adapted_tests")
 
386
        from bzrlib.tests.interversionedfile_implementations \
 
387
            import InterVersionedFileTestProviderAdapter
297
388
        server1 = "a"
298
389
        server2 = "b"
299
390
        formats = [(str, "C1", "C2"), (int, "D1", "D2")]
300
391
        adapter = InterVersionedFileTestProviderAdapter(server1, server2, formats)
301
 
        suite = adapter.adapt(input_test)
302
 
        tests = list(iter(suite))
303
 
        self.assertEqual(2, len(tests))
304
 
        self.assertEqual(tests[0].interversionedfile_class, formats[0][0])
305
 
        self.assertEqual(tests[0].versionedfile_factory, formats[0][1])
306
 
        self.assertEqual(tests[0].versionedfile_factory_to, formats[0][2])
307
 
        self.assertEqual(tests[0].transport_server, server1)
308
 
        self.assertEqual(tests[0].transport_readonly_server, server2)
309
 
        self.assertEqual(tests[1].interversionedfile_class, formats[1][0])
310
 
        self.assertEqual(tests[1].versionedfile_factory, formats[1][1])
311
 
        self.assertEqual(tests[1].versionedfile_factory_to, formats[1][2])
312
 
        self.assertEqual(tests[1].transport_server, server1)
313
 
        self.assertEqual(tests[1].transport_readonly_server, server2)
 
392
        self.assertEqual([
 
393
            ('str',
 
394
             {'interversionedfile_class':str,
 
395
              'transport_readonly_server': 'b',
 
396
              'transport_server': 'a',
 
397
              'versionedfile_factory': 'C1',
 
398
              'versionedfile_factory_to': 'C2'}),
 
399
            ('int',
 
400
             {'interversionedfile_class': int,
 
401
              'transport_readonly_server': 'b',
 
402
              'transport_server': 'a',
 
403
              'versionedfile_factory': 'D1',
 
404
              'versionedfile_factory_to': 'D2'})],
 
405
            adapter.scenarios)
314
406
 
315
407
 
316
408
class TestRevisionStoreProviderAdapter(TestCase):
317
409
    """A group of tests that test the RevisionStore test adapter."""
318
410
 
319
 
    def test_adapted_tests(self):
 
411
    def test_scenarios(self):
320
412
        # check that constructor parameters are passed through to the adapted
321
413
        # test.
322
 
        from bzrlib.store.revision import RevisionStoreTestProviderAdapter
323
 
        input_test = TestRevisionStoreProviderAdapter(
324
 
            "test_adapted_tests")
 
414
        from bzrlib.tests.revisionstore_implementations \
 
415
            import RevisionStoreTestProviderAdapter
325
416
        # revision stores need a store factory - i.e. RevisionKnit
326
417
        #, a readonly and rw transport 
327
418
        # transport servers:
329
420
        server2 = "b"
330
421
        store_factories = ["c", "d"]
331
422
        adapter = RevisionStoreTestProviderAdapter(server1, server2, store_factories)
332
 
        suite = adapter.adapt(input_test)
333
 
        tests = list(iter(suite))
334
 
        self.assertEqual(2, len(tests))
335
 
        self.assertEqual(tests[0].store_factory, store_factories[0][0])
336
 
        self.assertEqual(tests[0].transport_server, server1)
337
 
        self.assertEqual(tests[0].transport_readonly_server, server2)
338
 
        self.assertEqual(tests[1].store_factory, store_factories[1][0])
339
 
        self.assertEqual(tests[1].transport_server, server1)
340
 
        self.assertEqual(tests[1].transport_readonly_server, server2)
 
423
        self.assertEqual([
 
424
            ('c',
 
425
             {'store_factory': 'c',
 
426
              'transport_readonly_server': 'b',
 
427
              'transport_server': 'a'}),
 
428
            ('d',
 
429
             {'store_factory': 'd',
 
430
              'transport_readonly_server': 'b',
 
431
              'transport_server': 'a'})],
 
432
            adapter.scenarios)
341
433
 
342
434
 
343
435
class TestWorkingTreeProviderAdapter(TestCase):
344
436
    """A group of tests that test the workingtree implementation test adapter."""
345
437
 
346
 
    def test_adapted_tests(self):
 
438
    def test_scenarios(self):
347
439
        # check that constructor parameters are passed through to the adapted
348
440
        # test.
349
 
        from bzrlib.workingtree import WorkingTreeTestProviderAdapter
350
 
        input_test = TestWorkingTreeProviderAdapter(
351
 
            "test_adapted_tests")
 
441
        from bzrlib.tests.workingtree_implementations \
 
442
            import WorkingTreeTestProviderAdapter
352
443
        server1 = "a"
353
444
        server2 = "b"
354
445
        formats = [("c", "C"), ("d", "D")]
355
446
        adapter = WorkingTreeTestProviderAdapter(server1, server2, formats)
356
 
        suite = adapter.adapt(input_test)
357
 
        tests = list(iter(suite))
358
 
        self.assertEqual(2, len(tests))
359
 
        self.assertEqual(tests[0].workingtree_format, formats[0][0])
360
 
        self.assertEqual(tests[0].bzrdir_format, formats[0][1])
361
 
        self.assertEqual(tests[0].transport_server, server1)
362
 
        self.assertEqual(tests[0].transport_readonly_server, server2)
363
 
        self.assertEqual(tests[1].workingtree_format, formats[1][0])
364
 
        self.assertEqual(tests[1].bzrdir_format, formats[1][1])
365
 
        self.assertEqual(tests[1].transport_server, server1)
366
 
        self.assertEqual(tests[1].transport_readonly_server, server2)
 
447
        self.assertEqual([
 
448
            ('str',
 
449
             {'bzrdir_format': 'C',
 
450
              'transport_readonly_server': 'b',
 
451
              'transport_server': 'a',
 
452
              'workingtree_format': 'c'}),
 
453
            ('str',
 
454
             {'bzrdir_format': 'D',
 
455
              'transport_readonly_server': 'b',
 
456
              'transport_server': 'a',
 
457
              'workingtree_format': 'd'})],
 
458
            adapter.scenarios)
367
459
 
368
460
 
369
461
class TestTreeProviderAdapter(TestCase):
1419
1511
        self.assertEqual([True], factory_called)
1420
1512
 
1421
1513
 
1422
 
class TestSelftestCleanOutput(TestCaseInTempDir):
1423
 
 
1424
 
    def test_clean_output(self):
1425
 
        # test functionality of clean_selftest_output()
1426
 
        self.build_tree(['test0000.tmp/', 'test0001.tmp/',
1427
 
                         'bzrlib/', 'tests/',
1428
 
                         'bzr', 'setup.py', 'test9999.tmp'])
1429
 
 
1430
 
        root = os.getcwdu()
1431
 
        before = os.listdir(root)
1432
 
        before.sort()
1433
 
        self.assertEquals(['bzr','bzrlib','setup.py',
1434
 
                           'test0000.tmp','test0001.tmp',
1435
 
                           'test9999.tmp','tests'],
1436
 
                           before)
1437
 
        clean_selftest_output(root, quiet=True)
1438
 
        after = os.listdir(root)
1439
 
        after.sort()
1440
 
        self.assertEquals(['bzr','bzrlib','setup.py',
1441
 
                           'test9999.tmp','tests'],
1442
 
                           after)
1443
 
 
1444
 
    def test_clean_readonly(self):
1445
 
        # test for delete read-only files
1446
 
        self.build_tree(['test0000.tmp/', 'test0000.tmp/foo'])
1447
 
        osutils.make_readonly('test0000.tmp/foo')
1448
 
        root = os.getcwdu()
1449
 
        before = os.listdir(root);  before.sort()
1450
 
        self.assertEquals(['test0000.tmp'], before)
1451
 
        clean_selftest_output(root, quiet=True)
1452
 
        after = os.listdir(root);   after.sort()
1453
 
        self.assertEquals([], after)
1454
 
 
1455
 
 
1456
1514
class TestKnownFailure(TestCase):
1457
1515
 
1458
1516
    def test_known_failure(self):