/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

  • Committer: John Arbash Meinel
  • Date: 2007-07-11 23:45:20 UTC
  • mfrom: (2601 +trunk)
  • mto: This revision was merged to the branch mainline in revision 2643.
  • Revision ID: john@arbash-meinel.com-20070711234520-do3h7zw8skbathpz
[merge] bzr.dev 2601

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_suite
 
57
                          test_lsprof,
 
58
                          test_suite,
58
59
                          )
59
60
from bzrlib.tests.test_sftp_transport import TestCaseWithSFTPServer
60
61
from bzrlib.tests.TestUtil import _load_module_by_name
113
114
            def get_test_permutations(self):
114
115
                return sample_permutation
115
116
        sample_permutation = [(1,2), (3,4)]
116
 
        from bzrlib.transport import TransportTestProviderAdapter
 
117
        from bzrlib.tests.test_transport_implementations \
 
118
            import TransportTestProviderAdapter
117
119
        adapter = TransportTestProviderAdapter()
118
120
        self.assertEqual(sample_permutation,
119
121
                         adapter.get_transport_test_permutations(MockModule()))
124
126
        # - we assume if this matches its probably doing the right thing
125
127
        # especially in combination with the tests for setting the right
126
128
        # classes below.
127
 
        from bzrlib.transport import (TransportTestProviderAdapter,
128
 
                                      _get_transport_modules
129
 
                                      )
 
129
        from bzrlib.tests.test_transport_implementations \
 
130
            import TransportTestProviderAdapter
 
131
        from bzrlib.transport import _get_transport_modules
130
132
        modules = _get_transport_modules()
131
133
        permutation_count = 0
132
134
        for module in modules:
149
151
        # This test used to know about all the possible transports and the
150
152
        # order they were returned but that seems overly brittle (mbp
151
153
        # 20060307)
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)
 
154
        from bzrlib.tests.test_transport_implementations \
 
155
            import TransportTestProviderAdapter
 
156
        scenarios = TransportTestProviderAdapter().scenarios
158
157
        # there are at least that many builtin transports
159
 
        one_test = tests[0]
160
 
        self.assertTrue(issubclass(one_test.transport_class, 
 
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"],
161
162
                                   bzrlib.transport.Transport))
162
 
        self.assertTrue(issubclass(one_test.transport_server, 
 
163
        self.assertTrue(issubclass(one_scenario[1]["transport_server"],
163
164
                                   bzrlib.transport.Server))
164
165
 
165
166
 
166
167
class TestBranchProviderAdapter(TestCase):
167
168
    """A group of tests that test the branch implementation test adapter."""
168
169
 
169
 
    def test_adapted_tests(self):
 
170
    def test_constructor(self):
170
171
        # check that constructor parameters are passed through to the adapted
171
172
        # test.
172
 
        from bzrlib.branch import BranchTestProviderAdapter
173
 
        input_test = TestBranchProviderAdapter(
174
 
            "test_adapted_tests")
 
173
        from bzrlib.tests.branch_implementations import BranchTestProviderAdapter
175
174
        server1 = "a"
176
175
        server2 = "b"
177
176
        formats = [("c", "C"), ("d", "D")]
178
177
        adapter = BranchTestProviderAdapter(server1, server2, formats)
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)
 
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)
190
191
 
191
192
 
192
193
class TestBzrDirProviderAdapter(TestCase):
195
196
    def test_adapted_tests(self):
196
197
        # check that constructor parameters are passed through to the adapted
197
198
        # test.
198
 
        from bzrlib.bzrdir import BzrDirTestProviderAdapter
199
 
        input_test = TestBzrDirProviderAdapter(
200
 
            "test_adapted_tests")
 
199
        from bzrlib.tests.bzrdir_implementations import BzrDirTestProviderAdapter
201
200
        vfs_factory = "v"
202
201
        server1 = "a"
203
202
        server2 = "b"
204
203
        formats = ["c", "d"]
205
204
        adapter = BzrDirTestProviderAdapter(vfs_factory,
206
205
            server1, server2, formats)
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)
 
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)
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_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")
 
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
229
227
        server1 = "a"
230
228
        server2 = "b"
231
229
        formats = [("c", "C"), ("d", "D")]
232
230
        adapter = RepositoryTestProviderAdapter(server1, server2, formats)
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)
 
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)
244
243
 
245
244
    def test_setting_vfs_transport(self):
246
245
        """The vfs_transport_factory can be set optionally."""
247
 
        from bzrlib.repository import RepositoryTestProviderAdapter
248
 
        input_test = TestRepositoryProviderAdapter(
249
 
            "test_adapted_tests")
250
 
        formats = [("c", "C")]
 
246
        from bzrlib.tests.repository_implementations import RepositoryTestProviderAdapter
 
247
        formats = [("a", "b"), ("c", "d")]
251
248
        adapter = RepositoryTestProviderAdapter(None, None, formats,
252
249
            vfs_transport_factory="vfs")
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")
 
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())
257
351
 
258
352
 
259
353
class TestInterRepositoryProviderAdapter(TestCase):
262
356
    def test_adapted_tests(self):
263
357
        # check that constructor parameters are passed through to the adapted
264
358
        # test.
265
 
        from bzrlib.repository import InterRepositoryTestProviderAdapter
266
 
        input_test = TestInterRepositoryProviderAdapter(
267
 
            "test_adapted_tests")
 
359
        from bzrlib.tests.interrepository_implementations import \
 
360
            InterRepositoryTestProviderAdapter
268
361
        server1 = "a"
269
362
        server2 = "b"
270
363
        formats = [(str, "C1", "C2"), (int, "D1", "D2")]
271
364
        adapter = InterRepositoryTestProviderAdapter(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].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)
 
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))
285
379
 
286
380
 
287
381
class TestInterVersionedFileProviderAdapter(TestCase):
288
382
    """A group of tests that test the InterVersionedFile test adapter."""
289
383
 
290
 
    def test_adapted_tests(self):
 
384
    def test_scenarios(self):
291
385
        # check that constructor parameters are passed through to the adapted
292
386
        # test.
293
 
        from bzrlib.versionedfile import InterVersionedFileTestProviderAdapter
294
 
        input_test = TestInterRepositoryProviderAdapter(
295
 
            "test_adapted_tests")
 
387
        from bzrlib.tests.interversionedfile_implementations \
 
388
            import InterVersionedFileTestProviderAdapter
296
389
        server1 = "a"
297
390
        server2 = "b"
298
391
        formats = [(str, "C1", "C2"), (int, "D1", "D2")]
299
392
        adapter = InterVersionedFileTestProviderAdapter(server1, server2, formats)
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)
 
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)
313
407
 
314
408
 
315
409
class TestRevisionStoreProviderAdapter(TestCase):
316
410
    """A group of tests that test the RevisionStore test adapter."""
317
411
 
318
 
    def test_adapted_tests(self):
 
412
    def test_scenarios(self):
319
413
        # check that constructor parameters are passed through to the adapted
320
414
        # test.
321
 
        from bzrlib.store.revision import RevisionStoreTestProviderAdapter
322
 
        input_test = TestRevisionStoreProviderAdapter(
323
 
            "test_adapted_tests")
 
415
        from bzrlib.tests.revisionstore_implementations \
 
416
            import RevisionStoreTestProviderAdapter
324
417
        # revision stores need a store factory - i.e. RevisionKnit
325
418
        #, a readonly and rw transport 
326
419
        # transport servers:
328
421
        server2 = "b"
329
422
        store_factories = ["c", "d"]
330
423
        adapter = RevisionStoreTestProviderAdapter(server1, server2, store_factories)
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)
 
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)
340
434
 
341
435
 
342
436
class TestWorkingTreeProviderAdapter(TestCase):
343
437
    """A group of tests that test the workingtree implementation test adapter."""
344
438
 
345
 
    def test_adapted_tests(self):
 
439
    def test_scenarios(self):
346
440
        # check that constructor parameters are passed through to the adapted
347
441
        # test.
348
 
        from bzrlib.workingtree import WorkingTreeTestProviderAdapter
349
 
        input_test = TestWorkingTreeProviderAdapter(
350
 
            "test_adapted_tests")
 
442
        from bzrlib.tests.workingtree_implementations \
 
443
            import WorkingTreeTestProviderAdapter
351
444
        server1 = "a"
352
445
        server2 = "b"
353
446
        formats = [("c", "C"), ("d", "D")]
354
447
        adapter = WorkingTreeTestProviderAdapter(server1, server2, formats)
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)
 
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)
366
460
 
367
461
 
368
462
class TestTreeProviderAdapter(TestCase):
620
714
        result.extractBenchmarkTime(self)
621
715
        timed_string = result._testTimeString()
622
716
        # without explicit benchmarking, we should get a simple time.
623
 
        self.assertContainsRe(timed_string, "^ *[ 1-9][0-9]ms$")
 
717
        self.assertContainsRe(timed_string, "^ +[0-9]+ms$")
624
718
        # if a benchmark time is given, we want a x of y style result.
625
719
        self.time(time.sleep, 0.001)
626
720
        result.extractBenchmarkTime(self)
627
721
        timed_string = result._testTimeString()
628
 
        self.assertContainsRe(timed_string, "^ *[ 1-9][0-9]ms/ *[ 1-9][0-9]ms$")
 
722
        self.assertContainsRe(
 
723
            timed_string, "^ +[0-9]+ms/ +[0-9]+ms$")
629
724
        # extracting the time from a non-bzrlib testcase sets to None
630
725
        result._recordTestStartTime()
631
726
        result.extractBenchmarkTime(
632
727
            unittest.FunctionTestCase(self.test_elapsed_time_with_benchmarking))
633
728
        timed_string = result._testTimeString()
634
 
        self.assertContainsRe(timed_string, "^ *[ 1-9][0-9]ms$")
 
729
        self.assertContainsRe(timed_string, "^ +[0-9]+ms$")
635
730
        # cheat. Yes, wash thy mouth out with soap.
636
731
        self._benchtime = None
637
732
 
679
774
 
680
775
    def test_lsprofiling(self):
681
776
        """Verbose test result prints lsprof statistics from test cases."""
682
 
        try:
683
 
            import bzrlib.lsprof
684
 
        except ImportError:
685
 
            raise TestSkipped("lsprof not installed.")
 
777
        self.requireFeature(test_lsprof.LSProfFeature)
686
778
        result_stream = StringIO()
687
779
        result = bzrlib.tests.VerboseTestResult(
688
780
            unittest._WritelnDecorator(result_stream),
971
1063
        def skipping_test():
972
1064
            raise TestSkipped('test intentionally skipped')
973
1065
 
974
 
        runner = TextTestRunner(stream=self._log_file, keep_output=True)
 
1066
        runner = TextTestRunner(stream=self._log_file)
975
1067
        test = unittest.FunctionTestCase(skipping_test)
976
1068
        result = self.run_test_runner(runner, test)
977
1069
        self.assertTrue(result.wasSuccessful())
990
1082
            def cleanup(self):
991
1083
                self.counter -= 1
992
1084
 
993
 
        runner = TextTestRunner(stream=self._log_file, keep_output=True)
 
1085
        runner = TextTestRunner(stream=self._log_file)
994
1086
        test = SkippedSetupTest('test_skip')
995
1087
        result = self.run_test_runner(runner, test)
996
1088
        self.assertTrue(result.wasSuccessful())
1010
1102
            def cleanup(self):
1011
1103
                self.counter -= 1
1012
1104
 
1013
 
        runner = TextTestRunner(stream=self._log_file, keep_output=True)
 
1105
        runner = TextTestRunner(stream=self._log_file)
1014
1106
        test = SkippedTest('test_skip')
1015
1107
        result = self.run_test_runner(runner, test)
1016
1108
        self.assertTrue(result.wasSuccessful())
1129
1221
class TestTestCase(TestCase):
1130
1222
    """Tests that test the core bzrlib TestCase."""
1131
1223
 
 
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
 
1132
1231
    def inner_test(self):
1133
1232
        # the inner child test
1134
1233
        note("inner_test")
1194
1293
        
1195
1294
        Each self.time() call is individually and separately profiled.
1196
1295
        """
1197
 
        try:
1198
 
            import bzrlib.lsprof
1199
 
        except ImportError:
1200
 
            raise TestSkipped("lsprof not installed.")
 
1296
        self.requireFeature(test_lsprof.LSProfFeature)
1201
1297
        # overrides the class member with an instance member so no cleanup 
1202
1298
        # needed.
1203
1299
        self._gather_lsprof_in_benchmarks = True
1535
1631
            'TestSelftestFiltering.test_filter_suite_by_re')
1536
1632
        self.assertEquals(sorted(self.all_names), sorted(sorted_names))
1537
1633
 
 
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()