← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_selftest.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2007-04-26 21:11:03 UTC
  • mfrom: (2447.1.7 bundle_empty_properties)
  • Revision ID: pqm@pqm.ubuntu.com-20070426211103-h84prqh7a4ad3ez2
(John Arbash Meinel) Fix bug #109613 by teaching Bundle how to properly read/write revision properties with no value.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_selftest.py
54
54
                          iter_suite_tests,
55
55
                          filter_suite_by_re,
56
56
                          sort_suite_by_re,
57
 
                          test_lsprof,
58
 
                          test_suite,
 
57
                          test_suite
59
58
                          )
60
59
from bzrlib.tests.test_sftp_transport import TestCaseWithSFTPServer
61
60
from bzrlib.tests.TestUtil import _load_module_by_name
114
113
            def get_test_permutations(self):
115
114
                return sample_permutation
116
115
        sample_permutation = [(1,2), (3,4)]
117
 
        from bzrlib.tests.test_transport_implementations \
118
 
            import TransportTestProviderAdapter
 
116
        from bzrlib.transport import TransportTestProviderAdapter
119
117
        adapter = TransportTestProviderAdapter()
120
118
        self.assertEqual(sample_permutation,
121
119
                         adapter.get_transport_test_permutations(MockModule()))
126
124
        # - we assume if this matches its probably doing the right thing
127
125
        # especially in combination with the tests for setting the right
128
126
        # classes below.
129
 
        from bzrlib.tests.test_transport_implementations \
130
 
            import TransportTestProviderAdapter
131
 
        from bzrlib.transport import _get_transport_modules
 
127
        from bzrlib.transport import (TransportTestProviderAdapter,
 
128
                                      _get_transport_modules
 
129
                                      )
132
130
        modules = _get_transport_modules()
133
131
        permutation_count = 0
134
132
        for module in modules:
151
149
        # This test used to know about all the possible transports and the
152
150
        # order they were returned but that seems overly brittle (mbp
153
151
        # 20060307)
154
 
        from bzrlib.tests.test_transport_implementations \
155
 
            import TransportTestProviderAdapter
156
 
        scenarios = TransportTestProviderAdapter().scenarios
 
152
        input_test = TestTransportProviderAdapter(
 
153
            "test_adapter_sets_transport_class")
 
154
        from bzrlib.transport import TransportTestProviderAdapter
 
155
        suite = TransportTestProviderAdapter().adapt(input_test)
 
156
        tests = list(iter(suite))
 
157
        self.assertTrue(len(tests) > 6)
157
158
        # there are at least that many builtin transports
158
 
        self.assertTrue(len(scenarios) > 6)
159
 
        one_scenario = scenarios[0]
160
 
        self.assertIsInstance(one_scenario[0], str)
161
 
        self.assertTrue(issubclass(one_scenario[1]["transport_class"],
 
159
        one_test = tests[0]
 
160
        self.assertTrue(issubclass(one_test.transport_class, 
162
161
                                   bzrlib.transport.Transport))
163
 
        self.assertTrue(issubclass(one_scenario[1]["transport_server"],
 
162
        self.assertTrue(issubclass(one_test.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_constructor(self):
 
169
    def test_adapted_tests(self):
171
170
        # check that constructor parameters are passed through to the adapted
172
171
        # test.
173
 
        from bzrlib.tests.branch_implementations import BranchTestProviderAdapter
 
172
        from bzrlib.branch import BranchTestProviderAdapter
 
173
        input_test = TestBranchProviderAdapter(
 
174
            "test_adapted_tests")
174
175
        server1 = "a"
175
176
        server2 = "b"
176
177
        formats = [("c", "C"), ("d", "D")]
177
178
        adapter = BranchTestProviderAdapter(server1, server2, formats)
178
 
        self.assertEqual(2, len(adapter.scenarios))
179
 
        self.assertEqual([
180
 
            ('str',
181
 
             {'branch_format': 'c',
182
 
              'bzrdir_format': 'C',
183
 
              'transport_readonly_server': 'b',
184
 
              'transport_server': 'a'}),
185
 
            ('str',
186
 
             {'branch_format': 'd',
187
 
              'bzrdir_format': 'D',
188
 
              'transport_readonly_server': 'b',
189
 
              'transport_server': 'a'})],
190
 
            adapter.scenarios)
 
179
        suite = adapter.adapt(input_test)
 
180
        tests = list(iter(suite))
 
181
        self.assertEqual(2, len(tests))
 
182
        self.assertEqual(tests[0].branch_format, formats[0][0])
 
183
        self.assertEqual(tests[0].bzrdir_format, formats[0][1])
 
184
        self.assertEqual(tests[0].transport_server, server1)
 
185
        self.assertEqual(tests[0].transport_readonly_server, server2)
 
186
        self.assertEqual(tests[1].branch_format, formats[1][0])
 
187
        self.assertEqual(tests[1].bzrdir_format, formats[1][1])
 
188
        self.assertEqual(tests[1].transport_server, server1)
 
189
        self.assertEqual(tests[1].transport_readonly_server, server2)
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.tests.bzrdir_implementations import BzrDirTestProviderAdapter
 
198
        from bzrlib.bzrdir import BzrDirTestProviderAdapter
 
199
        input_test = TestBzrDirProviderAdapter(
 
200
            "test_adapted_tests")
200
201
        vfs_factory = "v"
201
202
        server1 = "a"
202
203
        server2 = "b"
203
204
        formats = ["c", "d"]
204
205
        adapter = BzrDirTestProviderAdapter(vfs_factory,
205
206
            server1, server2, formats)
206
 
        self.assertEqual([
207
 
            ('str',
208
 
             {'bzrdir_format': 'c',
209
 
              'transport_readonly_server': 'b',
210
 
              'transport_server': 'a',
211
 
              'vfs_transport_factory': 'v'}),
212
 
            ('str',
213
 
             {'bzrdir_format': 'd',
214
 
              'transport_readonly_server': 'b',
215
 
              'transport_server': 'a',
216
 
              'vfs_transport_factory': 'v'})],
217
 
            adapter.scenarios)
 
207
        suite = adapter.adapt(input_test)
 
208
        tests = list(iter(suite))
 
209
        self.assertEqual(2, len(tests))
 
210
        self.assertEqual(tests[0].bzrdir_format, formats[0])
 
211
        self.assertEqual(tests[0].vfs_transport_factory, vfs_factory)
 
212
        self.assertEqual(tests[0].transport_server, server1)
 
213
        self.assertEqual(tests[0].transport_readonly_server, server2)
 
214
        self.assertEqual(tests[1].bzrdir_format, formats[1])
 
215
        self.assertEqual(tests[1].vfs_transport_factory, vfs_factory)
 
216
        self.assertEqual(tests[1].transport_server, server1)
 
217
        self.assertEqual(tests[1].transport_readonly_server, server2)
218
218
 
219
219
 
220
220
class TestRepositoryProviderAdapter(TestCase):
221
221
    """A group of tests that test the repository implementation test adapter."""
222
222
 
223
 
    def test_constructor(self):
224
 
        # check that constructor parameters are passed through to the
225
 
        # scenarios.
226
 
        from bzrlib.tests.repository_implementations import RepositoryTestProviderAdapter
 
223
    def test_adapted_tests(self):
 
224
        # check that constructor parameters are passed through to the adapted
 
225
        # test.
 
226
        from bzrlib.repository import RepositoryTestProviderAdapter
 
227
        input_test = TestRepositoryProviderAdapter(
 
228
            "test_adapted_tests")
227
229
        server1 = "a"
228
230
        server2 = "b"
229
231
        formats = [("c", "C"), ("d", "D")]
230
232
        adapter = RepositoryTestProviderAdapter(server1, server2, formats)
231
 
        self.assertEqual([
232
 
            ('str',
233
 
             {'bzrdir_format': 'C',
234
 
              'repository_format': 'c',
235
 
              'transport_readonly_server': 'b',
236
 
              'transport_server': 'a'}),
237
 
            ('str',
238
 
             {'bzrdir_format': 'D',
239
 
              'repository_format': 'd',
240
 
              'transport_readonly_server': 'b',
241
 
              'transport_server': 'a'})],
242
 
            adapter.scenarios)
 
233
        suite = adapter.adapt(input_test)
 
234
        tests = list(iter(suite))
 
235
        self.assertEqual(2, len(tests))
 
236
        self.assertEqual(tests[0].bzrdir_format, formats[0][1])
 
237
        self.assertEqual(tests[0].repository_format, formats[0][0])
 
238
        self.assertEqual(tests[0].transport_server, server1)
 
239
        self.assertEqual(tests[0].transport_readonly_server, server2)
 
240
        self.assertEqual(tests[1].bzrdir_format, formats[1][1])
 
241
        self.assertEqual(tests[1].repository_format, formats[1][0])
 
242
        self.assertEqual(tests[1].transport_server, server1)
 
243
        self.assertEqual(tests[1].transport_readonly_server, server2)
243
244
 
244
245
    def test_setting_vfs_transport(self):
245
246
        """The vfs_transport_factory can be set optionally."""
246
 
        from bzrlib.tests.repository_implementations import RepositoryTestProviderAdapter
247
 
        formats = [("a", "b"), ("c", "d")]
 
247
        from bzrlib.repository import RepositoryTestProviderAdapter
 
248
        input_test = TestRepositoryProviderAdapter(
 
249
            "test_adapted_tests")
 
250
        formats = [("c", "C")]
248
251
        adapter = RepositoryTestProviderAdapter(None, None, formats,
249
252
            vfs_transport_factory="vfs")
250
 
        self.assertEqual([
251
 
            ('str',
252
 
             {'bzrdir_format': 'b',
253
 
              'repository_format': 'a',
254
 
              'transport_readonly_server': None,
255
 
              'transport_server': None,
256
 
              'vfs_transport_factory': 'vfs'}),
257
 
            ('str',
258
 
             {'bzrdir_format': 'd',
259
 
              'repository_format': 'c',
260
 
              'transport_readonly_server': None,
261
 
              'transport_server': None,
262
 
              'vfs_transport_factory': 'vfs'})],
263
 
            adapter.scenarios)
264
 
 
265
 
    def test_formats_to_scenarios(self):
266
 
        """The adapter can generate all the scenarios needed."""
267
 
        from bzrlib.tests.repository_implementations import RepositoryTestProviderAdapter
268
 
        no_vfs_adapter = RepositoryTestProviderAdapter("server", "readonly",
269
 
            [], None)
270
 
        vfs_adapter = RepositoryTestProviderAdapter("server", "readonly",
271
 
            [], vfs_transport_factory="vfs")
272
 
        # no_vfs generate scenarios without vfs_transport_factor
273
 
        formats = [("c", "C"), (1, "D")]
274
 
        self.assertEqual([
275
 
            ('str',
276
 
             {'bzrdir_format': 'C',
277
 
              'repository_format': 'c',
278
 
              'transport_readonly_server': 'readonly',
279
 
              'transport_server': 'server'}),
280
 
            ('int',
281
 
             {'bzrdir_format': 'D',
282
 
              'repository_format': 1,
283
 
              'transport_readonly_server': 'readonly',
284
 
              'transport_server': 'server'})],
285
 
            no_vfs_adapter.formats_to_scenarios(formats))
286
 
        self.assertEqual([
287
 
            ('str',
288
 
             {'bzrdir_format': 'C',
289
 
              'repository_format': 'c',
290
 
              'transport_readonly_server': 'readonly',
291
 
              'transport_server': 'server',
292
 
              'vfs_transport_factory': 'vfs'}),
293
 
            ('int',
294
 
             {'bzrdir_format': 'D',
295
 
              'repository_format': 1,
296
 
              'transport_readonly_server': 'readonly',
297
 
              'transport_server': 'server',
298
 
              'vfs_transport_factory': 'vfs'})],
299
 
            vfs_adapter.formats_to_scenarios(formats))
300
 
 
301
 
 
302
 
class TestTestScenarioApplier(TestCase):
303
 
    """Tests for the test adaption facilities."""
304
 
 
305
 
    def test_adapt_applies_scenarios(self):
306
 
        from bzrlib.tests.repository_implementations import TestScenarioApplier
307
 
        input_test = TestTestScenarioApplier("test_adapt_test_to_scenario")
308
 
        adapter = TestScenarioApplier()
309
 
        adapter.scenarios = [("1", "dict"), ("2", "settings")]
310
 
        calls = []
311
 
        def capture_call(test, scenario):
312
 
            calls.append((test, scenario))
313
 
            return test
314
 
        adapter.adapt_test_to_scenario = capture_call
315
 
        adapter.adapt(input_test)
316
 
        self.assertEqual([(input_test, ("1", "dict")),
317
 
            (input_test, ("2", "settings"))], calls)
318
 
 
319
 
    def test_adapt_test_to_scenario(self):
320
 
        from bzrlib.tests.repository_implementations import TestScenarioApplier
321
 
        input_test = TestTestScenarioApplier("test_adapt_test_to_scenario")
322
 
        adapter = TestScenarioApplier()
323
 
        # setup two adapted tests
324
 
        adapted_test1 = adapter.adapt_test_to_scenario(input_test,
325
 
            ("new id",
326
 
            {"bzrdir_format":"bzr_format",
327
 
             "repository_format":"repo_fmt",
328
 
             "transport_server":"transport_server",
329
 
             "transport_readonly_server":"readonly-server"}))
330
 
        adapted_test2 = adapter.adapt_test_to_scenario(input_test,
331
 
            ("new id 2", {"bzrdir_format":None}))
332
 
        # input_test should have been altered.
333
 
        self.assertRaises(AttributeError, getattr, input_test, "bzrdir_format")
334
 
        # the new tests are mutually incompatible, ensuring it has 
335
 
        # made new ones, and unspecified elements in the scenario
336
 
        # should not have been altered.
337
 
        self.assertEqual("bzr_format", adapted_test1.bzrdir_format)
338
 
        self.assertEqual("repo_fmt", adapted_test1.repository_format)
339
 
        self.assertEqual("transport_server", adapted_test1.transport_server)
340
 
        self.assertEqual("readonly-server",
341
 
            adapted_test1.transport_readonly_server)
342
 
        self.assertEqual(
343
 
            "bzrlib.tests.test_selftest.TestTestScenarioApplier."
344
 
            "test_adapt_test_to_scenario(new id)",
345
 
            adapted_test1.id())
346
 
        self.assertEqual(None, adapted_test2.bzrdir_format)
347
 
        self.assertEqual(
348
 
            "bzrlib.tests.test_selftest.TestTestScenarioApplier."
349
 
            "test_adapt_test_to_scenario(new id 2)",
350
 
            adapted_test2.id())
 
253
        suite = adapter.adapt(input_test)
 
254
        tests = list(iter(suite))
 
255
        self.assertEqual(1, len(tests))
 
256
        self.assertEqual(tests[0].vfs_transport_factory, "vfs")
351
257
 
352
258
 
353
259
class TestInterRepositoryProviderAdapter(TestCase):
356
262
    def test_adapted_tests(self):
357
263
        # check that constructor parameters are passed through to the adapted
358
264
        # test.
359
 
        from bzrlib.tests.interrepository_implementations import \
360
 
            InterRepositoryTestProviderAdapter
 
265
        from bzrlib.repository import InterRepositoryTestProviderAdapter
 
266
        input_test = TestInterRepositoryProviderAdapter(
 
267
            "test_adapted_tests")
361
268
        server1 = "a"
362
269
        server2 = "b"
363
270
        formats = [(str, "C1", "C2"), (int, "D1", "D2")]
364
271
        adapter = InterRepositoryTestProviderAdapter(server1, server2, formats)
365
 
        self.assertEqual([
366
 
            ('str',
367
 
             {'interrepo_class': str,
368
 
              'repository_format': 'C1',
369
 
              'repository_format_to': 'C2',
370
 
              'transport_readonly_server': 'b',
371
 
              'transport_server': 'a'}),
372
 
            ('int',
373
 
             {'interrepo_class': int,
374
 
              'repository_format': 'D1',
375
 
              'repository_format_to': 'D2',
376
 
              'transport_readonly_server': 'b',
377
 
              'transport_server': 'a'})],
378
 
            adapter.formats_to_scenarios(formats))
 
272
        suite = adapter.adapt(input_test)
 
273
        tests = list(iter(suite))
 
274
        self.assertEqual(2, len(tests))
 
275
        self.assertEqual(tests[0].interrepo_class, formats[0][0])
 
276
        self.assertEqual(tests[0].repository_format, formats[0][1])
 
277
        self.assertEqual(tests[0].repository_format_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].interrepo_class, formats[1][0])
 
281
        self.assertEqual(tests[1].repository_format, formats[1][1])
 
282
        self.assertEqual(tests[1].repository_format_to, formats[1][2])
 
283
        self.assertEqual(tests[1].transport_server, server1)
 
284
        self.assertEqual(tests[1].transport_readonly_server, server2)
379
285
 
380
286
 
381
287
class TestInterVersionedFileProviderAdapter(TestCase):
382
288
    """A group of tests that test the InterVersionedFile test adapter."""
383
289
 
384
 
    def test_scenarios(self):
 
290
    def test_adapted_tests(self):
385
291
        # check that constructor parameters are passed through to the adapted
386
292
        # test.
387
 
        from bzrlib.tests.interversionedfile_implementations \
388
 
            import InterVersionedFileTestProviderAdapter
 
293
        from bzrlib.versionedfile import InterVersionedFileTestProviderAdapter
 
294
        input_test = TestInterRepositoryProviderAdapter(
 
295
            "test_adapted_tests")
389
296
        server1 = "a"
390
297
        server2 = "b"
391
298
        formats = [(str, "C1", "C2"), (int, "D1", "D2")]
392
299
        adapter = InterVersionedFileTestProviderAdapter(server1, server2, formats)
393
 
        self.assertEqual([
394
 
            ('str',
395
 
             {'interversionedfile_class':str,
396
 
              'transport_readonly_server': 'b',
397
 
              'transport_server': 'a',
398
 
              'versionedfile_factory': 'C1',
399
 
              'versionedfile_factory_to': 'C2'}),
400
 
            ('int',
401
 
             {'interversionedfile_class': int,
402
 
              'transport_readonly_server': 'b',
403
 
              'transport_server': 'a',
404
 
              'versionedfile_factory': 'D1',
405
 
              'versionedfile_factory_to': 'D2'})],
406
 
            adapter.scenarios)
 
300
        suite = adapter.adapt(input_test)
 
301
        tests = list(iter(suite))
 
302
        self.assertEqual(2, len(tests))
 
303
        self.assertEqual(tests[0].interversionedfile_class, formats[0][0])
 
304
        self.assertEqual(tests[0].versionedfile_factory, formats[0][1])
 
305
        self.assertEqual(tests[0].versionedfile_factory_to, formats[0][2])
 
306
        self.assertEqual(tests[0].transport_server, server1)
 
307
        self.assertEqual(tests[0].transport_readonly_server, server2)
 
308
        self.assertEqual(tests[1].interversionedfile_class, formats[1][0])
 
309
        self.assertEqual(tests[1].versionedfile_factory, formats[1][1])
 
310
        self.assertEqual(tests[1].versionedfile_factory_to, formats[1][2])
 
311
        self.assertEqual(tests[1].transport_server, server1)
 
312
        self.assertEqual(tests[1].transport_readonly_server, server2)
407
313
 
408
314
 
409
315
class TestRevisionStoreProviderAdapter(TestCase):
410
316
    """A group of tests that test the RevisionStore test adapter."""
411
317
 
412
 
    def test_scenarios(self):
 
318
    def test_adapted_tests(self):
413
319
        # check that constructor parameters are passed through to the adapted
414
320
        # test.
415
 
        from bzrlib.tests.revisionstore_implementations \
416
 
            import RevisionStoreTestProviderAdapter
 
321
        from bzrlib.store.revision import RevisionStoreTestProviderAdapter
 
322
        input_test = TestRevisionStoreProviderAdapter(
 
323
            "test_adapted_tests")
417
324
        # revision stores need a store factory - i.e. RevisionKnit
418
325
        #, a readonly and rw transport 
419
326
        # transport servers:
421
328
        server2 = "b"
422
329
        store_factories = ["c", "d"]
423
330
        adapter = RevisionStoreTestProviderAdapter(server1, server2, store_factories)
424
 
        self.assertEqual([
425
 
            ('c',
426
 
             {'store_factory': 'c',
427
 
              'transport_readonly_server': 'b',
428
 
              'transport_server': 'a'}),
429
 
            ('d',
430
 
             {'store_factory': 'd',
431
 
              'transport_readonly_server': 'b',
432
 
              'transport_server': 'a'})],
433
 
            adapter.scenarios)
 
331
        suite = adapter.adapt(input_test)
 
332
        tests = list(iter(suite))
 
333
        self.assertEqual(2, len(tests))
 
334
        self.assertEqual(tests[0].store_factory, store_factories[0][0])
 
335
        self.assertEqual(tests[0].transport_server, server1)
 
336
        self.assertEqual(tests[0].transport_readonly_server, server2)
 
337
        self.assertEqual(tests[1].store_factory, store_factories[1][0])
 
338
        self.assertEqual(tests[1].transport_server, server1)
 
339
        self.assertEqual(tests[1].transport_readonly_server, server2)
434
340
 
435
341
 
436
342
class TestWorkingTreeProviderAdapter(TestCase):
437
343
    """A group of tests that test the workingtree implementation test adapter."""
438
344
 
439
 
    def test_scenarios(self):
 
345
    def test_adapted_tests(self):
440
346
        # check that constructor parameters are passed through to the adapted
441
347
        # test.
442
 
        from bzrlib.tests.workingtree_implementations \
443
 
            import WorkingTreeTestProviderAdapter
 
348
        from bzrlib.workingtree import WorkingTreeTestProviderAdapter
 
349
        input_test = TestWorkingTreeProviderAdapter(
 
350
            "test_adapted_tests")
444
351
        server1 = "a"
445
352
        server2 = "b"
446
353
        formats = [("c", "C"), ("d", "D")]
447
354
        adapter = WorkingTreeTestProviderAdapter(server1, server2, formats)
448
 
        self.assertEqual([
449
 
            ('str',
450
 
             {'bzrdir_format': 'C',
451
 
              'transport_readonly_server': 'b',
452
 
              'transport_server': 'a',
453
 
              'workingtree_format': 'c'}),
454
 
            ('str',
455
 
             {'bzrdir_format': 'D',
456
 
              'transport_readonly_server': 'b',
457
 
              'transport_server': 'a',
458
 
              'workingtree_format': 'd'})],
459
 
            adapter.scenarios)
 
355
        suite = adapter.adapt(input_test)
 
356
        tests = list(iter(suite))
 
357
        self.assertEqual(2, len(tests))
 
358
        self.assertEqual(tests[0].workingtree_format, formats[0][0])
 
359
        self.assertEqual(tests[0].bzrdir_format, formats[0][1])
 
360
        self.assertEqual(tests[0].transport_server, server1)
 
361
        self.assertEqual(tests[0].transport_readonly_server, server2)
 
362
        self.assertEqual(tests[1].workingtree_format, formats[1][0])
 
363
        self.assertEqual(tests[1].bzrdir_format, formats[1][1])
 
364
        self.assertEqual(tests[1].transport_server, server1)
 
365
        self.assertEqual(tests[1].transport_readonly_server, server2)
460
366
 
461
367
 
462
368
class TestTreeProviderAdapter(TestCase):
714
620
        result.extractBenchmarkTime(self)
715
621
        timed_string = result._testTimeString()
716
622
        # without explicit benchmarking, we should get a simple time.
717
 
        self.assertContainsRe(timed_string, "^ +[0-9]+ms$")
 
623
        self.assertContainsRe(timed_string, "^ *[ 1-9][0-9]ms$")
718
624
        # if a benchmark time is given, we want a x of y style result.
719
625
        self.time(time.sleep, 0.001)
720
626
        result.extractBenchmarkTime(self)
721
627
        timed_string = result._testTimeString()
722
 
        self.assertContainsRe(
723
 
            timed_string, "^ +[0-9]+ms/ +[0-9]+ms$")
 
628
        self.assertContainsRe(timed_string, "^ *[ 1-9][0-9]ms/ *[ 1-9][0-9]ms$")
724
629
        # extracting the time from a non-bzrlib testcase sets to None
725
630
        result._recordTestStartTime()
726
631
        result.extractBenchmarkTime(
727
632
            unittest.FunctionTestCase(self.test_elapsed_time_with_benchmarking))
728
633
        timed_string = result._testTimeString()
729
 
        self.assertContainsRe(timed_string, "^ +[0-9]+ms$")
 
634
        self.assertContainsRe(timed_string, "^ *[ 1-9][0-9]ms$")
730
635
        # cheat. Yes, wash thy mouth out with soap.
731
636
        self._benchtime = None
732
637
 
774
679
 
775
680
    def test_lsprofiling(self):
776
681
        """Verbose test result prints lsprof statistics from test cases."""
777
 
        self.requireFeature(test_lsprof.LSProfFeature)
 
682
        try:
 
683
            import bzrlib.lsprof
 
684
        except ImportError:
 
685
            raise TestSkipped("lsprof not installed.")
778
686
        result_stream = StringIO()
779
687
        result = bzrlib.tests.VerboseTestResult(
780
688
            unittest._WritelnDecorator(result_stream),
1063
971
        def skipping_test():
1064
972
            raise TestSkipped('test intentionally skipped')
1065
973
 
1066
 
        runner = TextTestRunner(stream=self._log_file)
 
974
        runner = TextTestRunner(stream=self._log_file, keep_output=True)
1067
975
        test = unittest.FunctionTestCase(skipping_test)
1068
976
        result = self.run_test_runner(runner, test)
1069
977
        self.assertTrue(result.wasSuccessful())
1082
990
            def cleanup(self):
1083
991
                self.counter -= 1
1084
992
 
1085
 
        runner = TextTestRunner(stream=self._log_file)
 
993
        runner = TextTestRunner(stream=self._log_file, keep_output=True)
1086
994
        test = SkippedSetupTest('test_skip')
1087
995
        result = self.run_test_runner(runner, test)
1088
996
        self.assertTrue(result.wasSuccessful())
1102
1010
            def cleanup(self):
1103
1011
                self.counter -= 1
1104
1012
 
1105
 
        runner = TextTestRunner(stream=self._log_file)
 
1013
        runner = TextTestRunner(stream=self._log_file, keep_output=True)
1106
1014
        test = SkippedTest('test_skip')
1107
1015
        result = self.run_test_runner(runner, test)
1108
1016
        self.assertTrue(result.wasSuccessful())
1221
1129
class TestTestCase(TestCase):
1222
1130
    """Tests that test the core bzrlib TestCase."""
1223
1131
 
1224
 
    def test_debug_flags_sanitised(self):
1225
 
        """The bzrlib debug flags should be sanitised by setUp."""
1226
 
        # we could set something and run a test that will check
1227
 
        # it gets santised, but this is probably sufficient for now:
1228
 
        # if someone runs the test with -Dsomething it will error.
1229
 
        self.assertEqual(set(), bzrlib.debug.debug_flags)
1230
 
 
1231
1132
    def inner_test(self):
1232
1133
        # the inner child test
1233
1134
        note("inner_test")
1293
1194
        
1294
1195
        Each self.time() call is individually and separately profiled.
1295
1196
        """
1296
 
        self.requireFeature(test_lsprof.LSProfFeature)
 
1197
        try:
 
1198
            import bzrlib.lsprof
 
1199
        except ImportError:
 
1200
            raise TestSkipped("lsprof not installed.")
1297
1201
        # overrides the class member with an instance member so no cleanup 
1298
1202
        # needed.
1299
1203
        self._gather_lsprof_in_benchmarks = True
1631
1535
            'TestSelftestFiltering.test_filter_suite_by_re')
1632
1536
        self.assertEquals(sorted(self.all_names), sorted(sorted_names))
1633
1537
 
1634
 
 
1635
 
class TestCheckInventoryShape(TestCaseWithTransport):
1636
 
 
1637
 
    def test_check_inventory_shape(self):
1638
 
        files = ['a', 'b/', 'b/c']
1639
 
        tree = self.make_branch_and_tree('.')
1640
 
        self.build_tree(files)
1641
 
        tree.add(files)
1642
 
        tree.lock_read()
1643
 
        try:
1644
 
            self.check_inventory_shape(tree.inventory, files)
1645
 
        finally:
1646
 
            tree.unlock()