← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/__init__.py

  • Committer: Aaron Bentley
  • Date: 2009-11-03 15:45:56 UTC
  • mto: (4634.97.2 2.0)
  • mto: This revision was merged to the branch mainline in revision 4798.
  • Revision ID: aaron@aaronbentley.com-20091103154556-e953dmegqbinyokq
Improve patch binary section handling.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/__init__.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007, 2008, 2009 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
28
28
 
29
29
import atexit
30
30
import codecs
31
 
from copy import copy
32
31
from cStringIO import StringIO
33
32
import difflib
34
33
import doctest
46
45
import tempfile
47
46
import threading
48
47
import time
49
 
import traceback
50
48
import unittest
51
49
import warnings
52
50
 
53
 
import testtools
54
 
# nb: check this before importing anything else from within it
55
 
_testtools_version = getattr(testtools, '__version__', ())
56
 
if _testtools_version < (0, 9, 2):
57
 
    raise ImportError("need at least testtools 0.9.2: %s is %r"
58
 
        % (testtools.__file__, _testtools_version))
59
 
from testtools import content
60
51
 
61
52
from bzrlib import (
62
53
    branchbuilder,
63
54
    bzrdir,
64
 
    chk_map,
65
 
    config,
66
55
    debug,
67
56
    errors,
68
57
    hooks,
96
85
from bzrlib.symbol_versioning import (
97
86
    DEPRECATED_PARAMETER,
98
87
    deprecated_function,
99
 
    deprecated_in,
100
88
    deprecated_method,
101
89
    deprecated_passed,
102
90
    )
103
91
import bzrlib.trace
104
 
from bzrlib.transport import (
105
 
    get_transport,
106
 
    memory,
107
 
    pathfilter,
108
 
    )
 
92
from bzrlib.transport import get_transport
109
93
import bzrlib.transport
 
94
from bzrlib.transport.local import LocalURLServer
 
95
from bzrlib.transport.memory import MemoryServer
 
96
from bzrlib.transport.readonly import ReadonlyServer
110
97
from bzrlib.trace import mutter, note
111
 
from bzrlib.tests import (
112
 
    test_server,
113
 
    TestUtil,
114
 
    )
 
98
from bzrlib.tests import TestUtil
115
99
from bzrlib.tests.http_server import HttpServer
116
100
from bzrlib.tests.TestUtil import (
117
101
                          TestSuite,
128
112
# shown frame is the test code, not our assertXYZ.
129
113
__unittest = 1
130
114
 
131
 
default_transport = test_server.LocalURLServer
132
 
 
133
 
 
134
 
_unitialized_attr = object()
135
 
"""A sentinel needed to act as a default value in a method signature."""
136
 
 
 
115
default_transport = LocalURLServer
137
116
 
138
117
# Subunit result codes, defined here to prevent a hard dependency on subunit.
139
118
SUBUNIT_SEEK_SET = 0
195
174
        self._overall_start_time = time.time()
196
175
        self._strict = strict
197
176
 
198
 
    def stopTestRun(self):
199
 
        run = self.testsRun
200
 
        actionTaken = "Ran"
201
 
        stopTime = time.time()
202
 
        timeTaken = stopTime - self.startTime
203
 
        self.printErrors()
204
 
        self.stream.writeln(self.separator2)
205
 
        self.stream.writeln("%s %d test%s in %.3fs" % (actionTaken,
206
 
                            run, run != 1 and "s" or "", timeTaken))
207
 
        self.stream.writeln()
208
 
        if not self.wasSuccessful():
209
 
            self.stream.write("FAILED (")
210
 
            failed, errored = map(len, (self.failures, self.errors))
211
 
            if failed:
212
 
                self.stream.write("failures=%d" % failed)
213
 
            if errored:
214
 
                if failed: self.stream.write(", ")
215
 
                self.stream.write("errors=%d" % errored)
216
 
            if self.known_failure_count:
217
 
                if failed or errored: self.stream.write(", ")
218
 
                self.stream.write("known_failure_count=%d" %
219
 
                    self.known_failure_count)
220
 
            self.stream.writeln(")")
221
 
        else:
222
 
            if self.known_failure_count:
223
 
                self.stream.writeln("OK (known_failures=%d)" %
224
 
                    self.known_failure_count)
225
 
            else:
226
 
                self.stream.writeln("OK")
227
 
        if self.skip_count > 0:
228
 
            skipped = self.skip_count
229
 
            self.stream.writeln('%d test%s skipped' %
230
 
                                (skipped, skipped != 1 and "s" or ""))
231
 
        if self.unsupported:
232
 
            for feature, count in sorted(self.unsupported.items()):
233
 
                self.stream.writeln("Missing feature '%s' skipped %d tests." %
234
 
                    (feature, count))
 
177
    def done(self):
 
178
        # nb: called stopTestRun in the version of this that Python merged
 
179
        # upstream, according to lifeless 20090803
235
180
        if self._strict:
236
181
            ok = self.wasStrictlySuccessful()
237
182
        else:
238
183
            ok = self.wasSuccessful()
 
184
        if ok:
 
185
            self.stream.write('tests passed\n')
 
186
        else:
 
187
            self.stream.write('tests failed\n')
239
188
        if TestCase._first_thread_leaker_id:
240
189
            self.stream.write(
241
190
                '%s is leaking threads among %d leaking tests.\n' % (
242
191
                TestCase._first_thread_leaker_id,
243
192
                TestCase._leaking_threads_tests))
244
 
            # We don't report the main thread as an active one.
245
 
            self.stream.write(
246
 
                '%d non-main threads were left active in the end.\n'
247
 
                % (TestCase._active_threads - 1))
248
 
 
249
 
    def getDescription(self, test):
250
 
        return test.id()
251
 
 
252
 
    def _extractBenchmarkTime(self, testCase, details=None):
 
193
 
 
194
    def _extractBenchmarkTime(self, testCase):
253
195
        """Add a benchmark time for the current test case."""
254
 
        if details and 'benchtime' in details:
255
 
            return float(''.join(details['benchtime'].iter_bytes()))
256
196
        return getattr(testCase, "_benchtime", None)
257
197
 
258
198
    def _elapsedTestTimeString(self):
292
232
        else:
293
233
            bzr_path = sys.executable
294
234
        self.stream.write(
295
 
            'bzr selftest: %s\n' % (bzr_path,))
 
235
            'testing: %s\n' % (bzr_path,))
296
236
        self.stream.write(
297
237
            '   %s\n' % (
298
238
                    bzrlib.__path__[0],))
321
261
        Called from the TestCase run() method when the test
322
262
        fails with an unexpected error.
323
263
        """
324
 
        self._post_mortem()
325
 
        unittest.TestResult.addError(self, test, err)
326
 
        self.error_count += 1
327
 
        self.report_error(test, err)
328
 
        if self.stop_early:
329
 
            self.stop()
330
 
        self._cleanupLogFile(test)
 
264
        self._testConcluded(test)
 
265
        if isinstance(err[1], TestNotApplicable):
 
266
            return self._addNotApplicable(test, err)
 
267
        elif isinstance(err[1], UnavailableFeature):
 
268
            return self.addNotSupported(test, err[1].args[0])
 
269
        else:
 
270
            unittest.TestResult.addError(self, test, err)
 
271
            self.error_count += 1
 
272
            self.report_error(test, err)
 
273
            if self.stop_early:
 
274
                self.stop()
 
275
            self._cleanupLogFile(test)
331
276
 
332
277
    def addFailure(self, test, err):
333
278
        """Tell result that test failed.
335
280
        Called from the TestCase run() method when the test
336
281
        fails because e.g. an assert() method failed.
337
282
        """
338
 
        self._post_mortem()
339
 
        unittest.TestResult.addFailure(self, test, err)
340
 
        self.failure_count += 1
341
 
        self.report_failure(test, err)
342
 
        if self.stop_early:
343
 
            self.stop()
344
 
        self._cleanupLogFile(test)
 
283
        self._testConcluded(test)
 
284
        if isinstance(err[1], KnownFailure):
 
285
            return self._addKnownFailure(test, err)
 
286
        else:
 
287
            unittest.TestResult.addFailure(self, test, err)
 
288
            self.failure_count += 1
 
289
            self.report_failure(test, err)
 
290
            if self.stop_early:
 
291
                self.stop()
 
292
            self._cleanupLogFile(test)
345
293
 
346
 
    def addSuccess(self, test, details=None):
 
294
    def addSuccess(self, test):
347
295
        """Tell result that test completed successfully.
348
296
 
349
297
        Called from the TestCase run()
350
298
        """
 
299
        self._testConcluded(test)
351
300
        if self._bench_history is not None:
352
 
            benchmark_time = self._extractBenchmarkTime(test, details)
 
301
            benchmark_time = self._extractBenchmarkTime(test)
353
302
            if benchmark_time is not None:
354
303
                self._bench_history.write("%s %s\n" % (
355
304
                    self._formatTime(benchmark_time),
359
308
        unittest.TestResult.addSuccess(self, test)
360
309
        test._log_contents = ''
361
310
 
362
 
    def addExpectedFailure(self, test, err):
 
311
    def _testConcluded(self, test):
 
312
        """Common code when a test has finished.
 
313
 
 
314
        Called regardless of whether it succeded, failed, etc.
 
315
        """
 
316
        pass
 
317
 
 
318
    def _addKnownFailure(self, test, err):
363
319
        self.known_failure_count += 1
364
320
        self.report_known_failure(test, err)
365
321
 
367
323
        """The test will not be run because of a missing feature.
368
324
        """
369
325
        # this can be called in two different ways: it may be that the
370
 
        # test started running, and then raised (through requireFeature)
 
326
        # test started running, and then raised (through addError)
371
327
        # UnavailableFeature.  Alternatively this method can be called
372
 
        # while probing for features before running the test code proper; in
373
 
        # that case we will see startTest and stopTest, but the test will
374
 
        # never actually run.
 
328
        # while probing for features before running the tests; in that
 
329
        # case we will see startTest and stopTest, but the test will never
 
330
        # actually run.
375
331
        self.unsupported.setdefault(str(feature), 0)
376
332
        self.unsupported[str(feature)] += 1
377
333
        self.report_unsupported(test, feature)
381
337
        self.skip_count += 1
382
338
        self.report_skip(test, reason)
383
339
 
384
 
    def addNotApplicable(self, test, reason):
385
 
        self.not_applicable_count += 1
386
 
        self.report_not_applicable(test, reason)
 
340
    def _addNotApplicable(self, test, skip_excinfo):
 
341
        if isinstance(skip_excinfo[1], TestNotApplicable):
 
342
            self.not_applicable_count += 1
 
343
            self.report_not_applicable(test, skip_excinfo)
 
344
        try:
 
345
            test.tearDown()
 
346
        except KeyboardInterrupt:
 
347
            raise
 
348
        except:
 
349
            self.addError(test, test.exc_info())
 
350
        else:
 
351
            # seems best to treat this as success from point-of-view of unittest
 
352
            # -- it actually does nothing so it barely matters :)
 
353
            unittest.TestResult.addSuccess(self, test)
 
354
            test._log_contents = ''
387
355
 
388
 
    def _post_mortem(self):
389
 
        """Start a PDB post mortem session."""
390
 
        if os.environ.get('BZR_TEST_PDB', None):
391
 
            import pdb;pdb.post_mortem()
 
356
    def printErrorList(self, flavour, errors):
 
357
        for test, err in errors:
 
358
            self.stream.writeln(self.separator1)
 
359
            self.stream.write("%s: " % flavour)
 
360
            self.stream.writeln(self.getDescription(test))
 
361
            if getattr(test, '_get_log', None) is not None:
 
362
                log_contents = test._get_log()
 
363
                if log_contents:
 
364
                    self.stream.write('\n')
 
365
                    self.stream.write(
 
366
                            ('vvvv[log from %s]' % test.id()).ljust(78,'-'))
 
367
                    self.stream.write('\n')
 
368
                    self.stream.write(log_contents)
 
369
                    self.stream.write('\n')
 
370
                    self.stream.write(
 
371
                            ('^^^^[log from %s]' % test.id()).ljust(78,'-'))
 
372
                    self.stream.write('\n')
 
373
            self.stream.writeln(self.separator2)
 
374
            self.stream.writeln("%s" % err)
392
375
 
393
376
    def progress(self, offset, whence):
394
377
        """The test is adjusting the count of tests to run."""
399
382
        else:
400
383
            raise errors.BzrError("Unknown whence %r" % whence)
401
384
 
 
385
    def finished(self):
 
386
        pass
 
387
 
402
388
    def report_cleaning_up(self):
403
389
        pass
404
390
 
405
 
    def startTestRun(self):
406
 
        self.startTime = time.time()
407
 
 
408
391
    def report_success(self, test):
409
392
        pass
410
393
 
437
420
        self.pb.update_latency = 0
438
421
        self.pb.show_transport_activity = False
439
422
 
440
 
    def stopTestRun(self):
 
423
    def done(self):
441
424
        # called when the tests that are going to run have run
442
425
        self.pb.clear()
 
426
        super(TextTestResult, self).done()
 
427
 
 
428
    def finished(self):
443
429
        self.pb.finished()
444
 
        super(TextTestResult, self).stopTestRun()
445
430
 
446
 
    def startTestRun(self):
447
 
        super(TextTestResult, self).startTestRun()
 
431
    def report_starting(self):
448
432
        self.pb.update('[test 0/%d] Starting' % (self.num_tests))
449
433
 
450
434
    def printErrors(self):
470
454
            a += '%dm%ds' % (runtime / 60, runtime % 60)
471
455
        else:
472
456
            a += '%ds' % runtime
473
 
        total_fail_count = self.error_count + self.failure_count
474
 
        if total_fail_count:
475
 
            a += ', %d failed' % total_fail_count
476
 
        # if self.unsupported:
477
 
        #     a += ', %d missing' % len(self.unsupported)
 
457
        if self.error_count:
 
458
            a += ', %d err' % self.error_count
 
459
        if self.failure_count:
 
460
            a += ', %d fail' % self.failure_count
 
461
        if self.unsupported:
 
462
            a += ', %d missing' % len(self.unsupported)
478
463
        a += ']'
479
464
        return a
480
465
 
489
474
        return self._shortened_test_description(test)
490
475
 
491
476
    def report_error(self, test, err):
492
 
        self.ui.note('ERROR: %s\n    %s\n' % (
 
477
        self.pb.note('ERROR: %s\n    %s\n',
493
478
            self._test_description(test),
494
479
            err[1],
495
 
            ))
 
480
            )
496
481
 
497
482
    def report_failure(self, test, err):
498
 
        self.ui.note('FAIL: %s\n    %s\n' % (
 
483
        self.pb.note('FAIL: %s\n    %s\n',
499
484
            self._test_description(test),
500
485
            err[1],
501
 
            ))
 
486
            )
502
487
 
503
488
    def report_known_failure(self, test, err):
504
 
        pass
 
489
        self.pb.note('XFAIL: %s\n%s\n',
 
490
            self._test_description(test), err[1])
505
491
 
506
492
    def report_skip(self, test, reason):
507
493
        pass
508
494
 
509
 
    def report_not_applicable(self, test, reason):
 
495
    def report_not_applicable(self, test, skip_excinfo):
510
496
        pass
511
497
 
512
498
    def report_unsupported(self, test, feature):
527
513
            result = a_string
528
514
        return result.ljust(final_width)
529
515
 
530
 
    def startTestRun(self):
531
 
        super(VerboseTestResult, self).startTestRun()
 
516
    def report_starting(self):
532
517
        self.stream.write('running %d tests...\n' % self.num_tests)
533
518
 
534
519
    def report_test_start(self, test):
535
520
        self.count += 1
536
521
        name = self._shortened_test_description(test)
537
 
        width = osutils.terminal_width()
538
 
        if width is not None:
539
 
            # width needs space for 6 char status, plus 1 for slash, plus an
540
 
            # 11-char time string, plus a trailing blank
541
 
            # when NUMBERED_DIRS: plus 5 chars on test number, plus 1 char on
542
 
            # space
543
 
            self.stream.write(self._ellipsize_to_right(name, width-18))
544
 
        else:
545
 
            self.stream.write(name)
 
522
        # width needs space for 6 char status, plus 1 for slash, plus an
 
523
        # 11-char time string, plus a trailing blank
 
524
        # when NUMBERED_DIRS: plus 5 chars on test number, plus 1 char on space
 
525
        self.stream.write(self._ellipsize_to_right(name,
 
526
                          osutils.terminal_width()-18))
546
527
        self.stream.flush()
547
528
 
548
529
    def _error_summary(self, err):
577
558
        self.stream.writeln(' SKIP %s\n%s'
578
559
                % (self._testTimeString(test), reason))
579
560
 
580
 
    def report_not_applicable(self, test, reason):
581
 
        self.stream.writeln('  N/A %s\n    %s'
582
 
                % (self._testTimeString(test), reason))
 
561
    def report_not_applicable(self, test, skip_excinfo):
 
562
        self.stream.writeln('  N/A %s\n%s'
 
563
                % (self._testTimeString(test),
 
564
                   self._error_summary(skip_excinfo)))
583
565
 
584
566
    def report_unsupported(self, test, feature):
585
567
        """test cannot be run because feature is missing."""
595
577
                 descriptions=0,
596
578
                 verbosity=1,
597
579
                 bench_history=None,
 
580
                 list_only=False,
598
581
                 strict=False,
599
 
                 result_decorators=None,
600
582
                 ):
601
 
        """Create a TextTestRunner.
602
 
 
603
 
        :param result_decorators: An optional list of decorators to apply
604
 
            to the result object being used by the runner. Decorators are
605
 
            applied left to right - the first element in the list is the 
606
 
            innermost decorator.
607
 
        """
608
 
        # stream may know claim to know to write unicode strings, but in older
609
 
        # pythons this goes sufficiently wrong that it is a bad idea. (
610
 
        # specifically a built in file with encoding 'UTF-8' will still try
611
 
        # to encode using ascii.
612
 
        new_encoding = osutils.get_terminal_encoding()
613
 
        codec = codecs.lookup(new_encoding)
614
 
        if type(codec) is tuple:
615
 
            # Python 2.4
616
 
            encode = codec[0]
617
 
        else:
618
 
            encode = codec.encode
619
 
        stream = osutils.UnicodeOrBytesToBytesWriter(encode, stream)
620
 
        stream.encoding = new_encoding
621
583
        self.stream = unittest._WritelnDecorator(stream)
622
584
        self.descriptions = descriptions
623
585
        self.verbosity = verbosity
624
586
        self._bench_history = bench_history
 
587
        self.list_only = list_only
625
588
        self._strict = strict
626
 
        self._result_decorators = result_decorators or []
627
589
 
628
590
    def run(self, test):
629
591
        "Run the given test case or test suite."
 
592
        startTime = time.time()
630
593
        if self.verbosity == 1:
631
594
            result_class = TextTestResult
632
595
        elif self.verbosity >= 2:
633
596
            result_class = VerboseTestResult
634
 
        original_result = result_class(self.stream,
 
597
        result = result_class(self.stream,
635
598
                              self.descriptions,
636
599
                              self.verbosity,
637
600
                              bench_history=self._bench_history,
638
601
                              strict=self._strict,
639
602
                              )
640
 
        # Signal to result objects that look at stop early policy to stop,
641
 
        original_result.stop_early = self.stop_on_failure
642
 
        result = original_result
643
 
        for decorator in self._result_decorators:
644
 
            result = decorator(result)
645
 
            result.stop_early = self.stop_on_failure
646
 
        result.startTestRun()
647
 
        try:
648
 
            test.run(result)
649
 
        finally:
650
 
            result.stopTestRun()
651
 
        # higher level code uses our extended protocol to determine
652
 
        # what exit code to give.
653
 
        return original_result
 
603
        result.stop_early = self.stop_on_failure
 
604
        result.report_starting()
 
605
        if self.list_only:
 
606
            if self.verbosity >= 2:
 
607
                self.stream.writeln("Listing tests only ...\n")
 
608
            run = 0
 
609
            for t in iter_suite_tests(test):
 
610
                self.stream.writeln("%s" % (t.id()))
 
611
                run += 1
 
612
            return None
 
613
        else:
 
614
            try:
 
615
                import testtools
 
616
            except ImportError:
 
617
                test.run(result)
 
618
            else:
 
619
                if isinstance(test, testtools.ConcurrentTestSuite):
 
620
                    # We need to catch bzr specific behaviors
 
621
                    test.run(BZRTransformingResult(result))
 
622
                else:
 
623
                    test.run(result)
 
624
            run = result.testsRun
 
625
            actionTaken = "Ran"
 
626
        stopTime = time.time()
 
627
        timeTaken = stopTime - startTime
 
628
        result.printErrors()
 
629
        self.stream.writeln(result.separator2)
 
630
        self.stream.writeln("%s %d test%s in %.3fs" % (actionTaken,
 
631
                            run, run != 1 and "s" or "", timeTaken))
 
632
        self.stream.writeln()
 
633
        if not result.wasSuccessful():
 
634
            self.stream.write("FAILED (")
 
635
            failed, errored = map(len, (result.failures, result.errors))
 
636
            if failed:
 
637
                self.stream.write("failures=%d" % failed)
 
638
            if errored:
 
639
                if failed: self.stream.write(", ")
 
640
                self.stream.write("errors=%d" % errored)
 
641
            if result.known_failure_count:
 
642
                if failed or errored: self.stream.write(", ")
 
643
                self.stream.write("known_failure_count=%d" %
 
644
                    result.known_failure_count)
 
645
            self.stream.writeln(")")
 
646
        else:
 
647
            if result.known_failure_count:
 
648
                self.stream.writeln("OK (known_failures=%d)" %
 
649
                    result.known_failure_count)
 
650
            else:
 
651
                self.stream.writeln("OK")
 
652
        if result.skip_count > 0:
 
653
            skipped = result.skip_count
 
654
            self.stream.writeln('%d test%s skipped' %
 
655
                                (skipped, skipped != 1 and "s" or ""))
 
656
        if result.unsupported:
 
657
            for feature, count in sorted(result.unsupported.items()):
 
658
                self.stream.writeln("Missing feature '%s' skipped %d tests." %
 
659
                    (feature, count))
 
660
        result.finished()
 
661
        return result
654
662
 
655
663
 
656
664
def iter_suite_tests(suite):
666
674
                        % (type(suite), suite))
667
675
 
668
676
 
669
 
TestSkipped = testtools.testcase.TestSkipped
 
677
class TestSkipped(Exception):
 
678
    """Indicates that a test was intentionally skipped, rather than failing."""
670
679
 
671
680
 
672
681
class TestNotApplicable(TestSkipped):
678
687
    """
679
688
 
680
689
 
681
 
# traceback._some_str fails to format exceptions that have the default
682
 
# __str__ which does an implicit ascii conversion. However, repr() on those
683
 
# objects works, for all that its not quite what the doctor may have ordered.
684
 
def _clever_some_str(value):
685
 
    try:
686
 
        return str(value)
687
 
    except:
688
 
        try:
689
 
            return repr(value).replace('\\n', '\n')
690
 
        except:
691
 
            return '<unprintable %s object>' % type(value).__name__
692
 
 
693
 
traceback._some_str = _clever_some_str
694
 
 
695
 
 
696
 
# deprecated - use self.knownFailure(), or self.expectFailure.
697
 
KnownFailure = testtools.testcase._ExpectedFailure
 
690
class KnownFailure(AssertionError):
 
691
    """Indicates that a test failed in a precisely expected manner.
 
692
 
 
693
    Such failures dont block the whole test suite from passing because they are
 
694
    indicators of partially completed code or of future work. We have an
 
695
    explicit error for them so that we can ensure that they are always visible:
 
696
    KnownFailures are always shown in the output of bzr selftest.
 
697
    """
698
698
 
699
699
 
700
700
class UnavailableFeature(Exception):
701
701
    """A feature required for this test was not available.
702
702
 
703
 
    This can be considered a specialised form of SkippedTest.
704
 
 
705
703
    The feature should be used to construct the exception.
706
704
    """
707
705
 
708
706
 
 
707
class CommandFailed(Exception):
 
708
    pass
 
709
 
 
710
 
709
711
class StringIOWrapper(object):
710
712
    """A wrapper around cStringIO which just adds an encoding attribute.
711
713
 
772
774
        return NullProgressView()
773
775
 
774
776
 
775
 
class TestCase(testtools.TestCase):
 
777
class TestCase(unittest.TestCase):
776
778
    """Base class for bzr unit tests.
777
779
 
778
780
    Tests that need access to disk resources should subclass
797
799
    _leaking_threads_tests = 0
798
800
    _first_thread_leaker_id = None
799
801
    _log_file_name = None
 
802
    _log_contents = ''
 
803
    _keep_log_file = False
800
804
    # record lsprof data when performing benchmark calls.
801
805
    _gather_lsprof_in_benchmarks = False
 
806
    attrs_to_keep = ('id', '_testMethodName', '_testMethodDoc',
 
807
                     '_log_contents', '_log_file_name', '_benchtime',
 
808
                     '_TestCase__testMethodName', '_TestCase__testMethodDoc',)
802
809
 
803
810
    def __init__(self, methodName='testMethod'):
804
811
        super(TestCase, self).__init__(methodName)
805
812
        self._cleanups = []
806
 
        self._directory_isolation = True
807
 
        self.exception_handlers.insert(0,
808
 
            (UnavailableFeature, self._do_unsupported_or_skip))
809
 
        self.exception_handlers.insert(0,
810
 
            (TestNotApplicable, self._do_not_applicable))
 
813
        self._bzr_test_setUp_run = False
 
814
        self._bzr_test_tearDown_run = False
811
815
 
812
816
    def setUp(self):
813
 
        super(TestCase, self).setUp()
814
 
        for feature in getattr(self, '_test_needs_features', []):
815
 
            self.requireFeature(feature)
816
 
        self._log_contents = None
817
 
        self.addDetail("log", content.Content(content.ContentType("text",
818
 
            "plain", {"charset": "utf8"}),
819
 
            lambda:[self._get_log(keep_log_file=True)]))
 
817
        unittest.TestCase.setUp(self)
 
818
        self._bzr_test_setUp_run = True
820
819
        self._cleanEnvironment()
821
820
        self._silenceUI()
822
821
        self._startLogFile()
823
822
        self._benchcalls = []
824
823
        self._benchtime = None
825
824
        self._clear_hooks()
826
 
        self._track_transports()
827
825
        self._track_locks()
828
826
        self._clear_debug_flags()
829
827
        TestCase._active_threads = threading.activeCount()
838
836
        active = threading.activeCount()
839
837
        leaked_threads = active - TestCase._active_threads
840
838
        TestCase._active_threads = active
841
 
        # If some tests make the number of threads *decrease*, we'll consider
842
 
        # that they are just observing old threads dieing, not agressively kill
843
 
        # random threads. So we don't report these tests as leaking. The risk
844
 
        # is that we have false positives that way (the test see 2 threads
845
 
        # going away but leak one) but it seems less likely than the actual
846
 
        # false positives (the test see threads going away and does not leak).
847
 
        if leaked_threads > 0:
 
839
        if leaked_threads:
848
840
            TestCase._leaking_threads_tests += 1
849
841
            if TestCase._first_thread_leaker_id is None:
850
842
                TestCase._first_thread_leaker_id = self.id()
855
847
        Tests that want to use debug flags can just set them in the
856
848
        debug_flags set during setup/teardown.
857
849
        """
858
 
        # Start with a copy of the current debug flags we can safely modify.
859
 
        self.overrideAttr(debug, 'debug_flags', set(debug.debug_flags))
 
850
        self._preserved_debug_flags = set(debug.debug_flags)
860
851
        if 'allow_debug' not in selftest_debug_flags:
861
852
            debug.debug_flags.clear()
862
853
        if 'disable_lock_checks' not in selftest_debug_flags:
863
854
            debug.debug_flags.add('strict_locks')
 
855
        self.addCleanup(self._restore_debug_flags)
864
856
 
865
857
    def _clear_hooks(self):
866
858
        # prevent hooks affecting tests
876
868
        # this hook should always be installed
877
869
        request._install_hook()
878
870
 
879
 
    def disable_directory_isolation(self):
880
 
        """Turn off directory isolation checks."""
881
 
        self._directory_isolation = False
882
 
 
883
 
    def enable_directory_isolation(self):
884
 
        """Enable directory isolation checks."""
885
 
        self._directory_isolation = True
886
 
 
887
871
    def _silenceUI(self):
888
872
        """Turn off UI for duration of test"""
889
873
        # by default the UI is off; tests can turn it on if they want it.
890
 
        self.overrideAttr(ui, 'ui_factory', ui.SilentUIFactory())
 
874
        saved = ui.ui_factory
 
875
        def _restore():
 
876
            ui.ui_factory = saved
 
877
        ui.ui_factory = ui.SilentUIFactory()
 
878
        self.addCleanup(_restore)
891
879
 
892
880
    def _check_locks(self):
893
881
        """Check that all lock take/release actions have been paired."""
922
910
            self._lock_check_thorough = False
923
911
        else:
924
912
            self._lock_check_thorough = True
925
 
 
 
913
            
926
914
        self.addCleanup(self._check_locks)
927
915
        _mod_lock.Lock.hooks.install_named_hook('lock_acquired',
928
916
                                                self._lock_acquired, None)
940
928
    def _lock_broken(self, result):
941
929
        self._lock_actions.append(('broken', result))
942
930
 
943
 
    def permit_dir(self, name):
944
 
        """Permit a directory to be used by this test. See permit_url."""
945
 
        name_transport = get_transport(name)
946
 
        self.permit_url(name)
947
 
        self.permit_url(name_transport.base)
948
 
 
949
 
    def permit_url(self, url):
950
 
        """Declare that url is an ok url to use in this test.
951
 
        
952
 
        Do this for memory transports, temporary test directory etc.
953
 
        
954
 
        Do not do this for the current working directory, /tmp, or any other
955
 
        preexisting non isolated url.
956
 
        """
957
 
        if not url.endswith('/'):
958
 
            url += '/'
959
 
        self._bzr_selftest_roots.append(url)
960
 
 
961
 
    def permit_source_tree_branch_repo(self):
962
 
        """Permit the source tree bzr is running from to be opened.
963
 
 
964
 
        Some code such as bzrlib.version attempts to read from the bzr branch
965
 
        that bzr is executing from (if any). This method permits that directory
966
 
        to be used in the test suite.
967
 
        """
968
 
        path = self.get_source_path()
969
 
        self.record_directory_isolation()
970
 
        try:
971
 
            try:
972
 
                workingtree.WorkingTree.open(path)
973
 
            except (errors.NotBranchError, errors.NoWorkingTree):
974
 
                return
975
 
        finally:
976
 
            self.enable_directory_isolation()
977
 
 
978
 
    def _preopen_isolate_transport(self, transport):
979
 
        """Check that all transport openings are done in the test work area."""
980
 
        while isinstance(transport, pathfilter.PathFilteringTransport):
981
 
            # Unwrap pathfiltered transports
982
 
            transport = transport.server.backing_transport.clone(
983
 
                transport._filter('.'))
984
 
        url = transport.base
985
 
        # ReadonlySmartTCPServer_for_testing decorates the backing transport
986
 
        # urls it is given by prepending readonly+. This is appropriate as the
987
 
        # client shouldn't know that the server is readonly (or not readonly).
988
 
        # We could register all servers twice, with readonly+ prepending, but
989
 
        # that makes for a long list; this is about the same but easier to
990
 
        # read.
991
 
        if url.startswith('readonly+'):
992
 
            url = url[len('readonly+'):]
993
 
        self._preopen_isolate_url(url)
994
 
 
995
 
    def _preopen_isolate_url(self, url):
996
 
        if not self._directory_isolation:
997
 
            return
998
 
        if self._directory_isolation == 'record':
999
 
            self._bzr_selftest_roots.append(url)
1000
 
            return
1001
 
        # This prevents all transports, including e.g. sftp ones backed on disk
1002
 
        # from working unless they are explicitly granted permission. We then
1003
 
        # depend on the code that sets up test transports to check that they are
1004
 
        # appropriately isolated and enable their use by calling
1005
 
        # self.permit_transport()
1006
 
        if not osutils.is_inside_any(self._bzr_selftest_roots, url):
1007
 
            raise errors.BzrError("Attempt to escape test isolation: %r %r"
1008
 
                % (url, self._bzr_selftest_roots))
1009
 
 
1010
 
    def record_directory_isolation(self):
1011
 
        """Gather accessed directories to permit later access.
1012
 
        
1013
 
        This is used for tests that access the branch bzr is running from.
1014
 
        """
1015
 
        self._directory_isolation = "record"
1016
 
 
1017
 
    def start_server(self, transport_server, backing_server=None):
1018
 
        """Start transport_server for this test.
1019
 
 
1020
 
        This starts the server, registers a cleanup for it and permits the
1021
 
        server's urls to be used.
1022
 
        """
1023
 
        if backing_server is None:
1024
 
            transport_server.start_server()
1025
 
        else:
1026
 
            transport_server.start_server(backing_server)
1027
 
        self.addCleanup(transport_server.stop_server)
1028
 
        # Obtain a real transport because if the server supplies a password, it
1029
 
        # will be hidden from the base on the client side.
1030
 
        t = get_transport(transport_server.get_url())
1031
 
        # Some transport servers effectively chroot the backing transport;
1032
 
        # others like SFTPServer don't - users of the transport can walk up the
1033
 
        # transport to read the entire backing transport. This wouldn't matter
1034
 
        # except that the workdir tests are given - and that they expect the
1035
 
        # server's url to point at - is one directory under the safety net. So
1036
 
        # Branch operations into the transport will attempt to walk up one
1037
 
        # directory. Chrooting all servers would avoid this but also mean that
1038
 
        # we wouldn't be testing directly against non-root urls. Alternatively
1039
 
        # getting the test framework to start the server with a backing server
1040
 
        # at the actual safety net directory would work too, but this then
1041
 
        # means that the self.get_url/self.get_transport methods would need
1042
 
        # to transform all their results. On balance its cleaner to handle it
1043
 
        # here, and permit a higher url when we have one of these transports.
1044
 
        if t.base.endswith('/work/'):
1045
 
            # we have safety net/test root/work
1046
 
            t = t.clone('../..')
1047
 
        elif isinstance(transport_server,
1048
 
                        test_server.SmartTCPServer_for_testing):
1049
 
            # The smart server adds a path similar to work, which is traversed
1050
 
            # up from by the client. But the server is chrooted - the actual
1051
 
            # backing transport is not escaped from, and VFS requests to the
1052
 
            # root will error (because they try to escape the chroot).
1053
 
            t2 = t.clone('..')
1054
 
            while t2.base != t.base:
1055
 
                t = t2
1056
 
                t2 = t.clone('..')
1057
 
        self.permit_url(t.base)
1058
 
 
1059
 
    def _track_transports(self):
1060
 
        """Install checks for transport usage."""
1061
 
        # TestCase has no safe place it can write to.
1062
 
        self._bzr_selftest_roots = []
1063
 
        # Currently the easiest way to be sure that nothing is going on is to
1064
 
        # hook into bzr dir opening. This leaves a small window of error for
1065
 
        # transport tests, but they are well known, and we can improve on this
1066
 
        # step.
1067
 
        bzrdir.BzrDir.hooks.install_named_hook("pre_open",
1068
 
            self._preopen_isolate_transport, "Check bzr directories are safe.")
1069
 
 
1070
931
    def _ndiff_strings(self, a, b):
1071
932
        """Return ndiff between two strings containing lines.
1072
933
 
1109
970
            return
1110
971
        if message is None:
1111
972
            message = "texts not equal:\n"
 
973
        if a == b + '\n':
 
974
            message = 'first string is missing a final newline.\n'
1112
975
        if a + '\n' == b:
1113
 
            message = 'first string is missing a final newline.\n'
1114
 
        if a == b + '\n':
1115
976
            message = 'second string is missing a final newline.\n'
1116
977
        raise AssertionError(message +
1117
978
                             self._ndiff_strings(a, b))
1128
989
        :raises AssertionError: If the expected and actual stat values differ
1129
990
            other than by atime.
1130
991
        """
1131
 
        self.assertEqual(expected.st_size, actual.st_size,
1132
 
                         'st_size did not match')
1133
 
        self.assertEqual(expected.st_mtime, actual.st_mtime,
1134
 
                         'st_mtime did not match')
1135
 
        self.assertEqual(expected.st_ctime, actual.st_ctime,
1136
 
                         'st_ctime did not match')
1137
 
        if sys.platform != 'win32':
1138
 
            # On Win32 both 'dev' and 'ino' cannot be trusted. In python2.4 it
1139
 
            # is 'dev' that varies, in python 2.5 (6?) it is st_ino that is
1140
 
            # odd. Regardless we shouldn't actually try to assert anything
1141
 
            # about their values
1142
 
            self.assertEqual(expected.st_dev, actual.st_dev,
1143
 
                             'st_dev did not match')
1144
 
            self.assertEqual(expected.st_ino, actual.st_ino,
1145
 
                             'st_ino did not match')
1146
 
        self.assertEqual(expected.st_mode, actual.st_mode,
1147
 
                         'st_mode did not match')
 
992
        self.assertEqual(expected.st_size, actual.st_size)
 
993
        self.assertEqual(expected.st_mtime, actual.st_mtime)
 
994
        self.assertEqual(expected.st_ctime, actual.st_ctime)
 
995
        self.assertEqual(expected.st_dev, actual.st_dev)
 
996
        self.assertEqual(expected.st_ino, actual.st_ino)
 
997
        self.assertEqual(expected.st_mode, actual.st_mode)
1148
998
 
1149
999
    def assertLength(self, length, obj_with_len):
1150
1000
        """Assert that obj_with_len is of length length."""
1152
1002
            self.fail("Incorrect length: wanted %d, got %d for %r" % (
1153
1003
                length, len(obj_with_len), obj_with_len))
1154
1004
 
1155
 
    def assertLogsError(self, exception_class, func, *args, **kwargs):
1156
 
        """Assert that func(*args, **kwargs) quietly logs a specific exception.
1157
 
        """
1158
 
        from bzrlib import trace
1159
 
        captured = []
1160
 
        orig_log_exception_quietly = trace.log_exception_quietly
1161
 
        try:
1162
 
            def capture():
1163
 
                orig_log_exception_quietly()
1164
 
                captured.append(sys.exc_info())
1165
 
            trace.log_exception_quietly = capture
1166
 
            func(*args, **kwargs)
1167
 
        finally:
1168
 
            trace.log_exception_quietly = orig_log_exception_quietly
1169
 
        self.assertLength(1, captured)
1170
 
        err = captured[0][1]
1171
 
        self.assertIsInstance(err, exception_class)
1172
 
        return err
1173
 
 
1174
1005
    def assertPositive(self, val):
1175
1006
        """Assert that val is greater than 0."""
1176
1007
        self.assertTrue(val > 0, 'expected a positive value, but got %s' % val)
1206
1037
            raise AssertionError('pattern "%s" found in "%s"'
1207
1038
                    % (needle_re, haystack))
1208
1039
 
1209
 
    def assertContainsString(self, haystack, needle):
1210
 
        if haystack.find(needle) == -1:
1211
 
            self.fail("string %r not found in '''%s'''" % (needle, haystack))
1212
 
 
1213
1040
    def assertSubset(self, sublist, superlist):
1214
1041
        """Assert that every entry in sublist is present in superlist."""
1215
1042
        missing = set(sublist) - set(superlist)
1302
1129
                m += ": " + msg
1303
1130
            self.fail(m)
1304
1131
 
 
1132
    def expectFailure(self, reason, assertion, *args, **kwargs):
 
1133
        """Invoke a test, expecting it to fail for the given reason.
 
1134
 
 
1135
        This is for assertions that ought to succeed, but currently fail.
 
1136
        (The failure is *expected* but not *wanted*.)  Please be very precise
 
1137
        about the failure you're expecting.  If a new bug is introduced,
 
1138
        AssertionError should be raised, not KnownFailure.
 
1139
 
 
1140
        Frequently, expectFailure should be followed by an opposite assertion.
 
1141
        See example below.
 
1142
 
 
1143
        Intended to be used with a callable that raises AssertionError as the
 
1144
        'assertion' parameter.  args and kwargs are passed to the 'assertion'.
 
1145
 
 
1146
        Raises KnownFailure if the test fails.  Raises AssertionError if the
 
1147
        test succeeds.
 
1148
 
 
1149
        example usage::
 
1150
 
 
1151
          self.expectFailure('Math is broken', self.assertNotEqual, 54,
 
1152
                             dynamic_val)
 
1153
          self.assertEqual(42, dynamic_val)
 
1154
 
 
1155
          This means that a dynamic_val of 54 will cause the test to raise
 
1156
          a KnownFailure.  Once math is fixed and the expectFailure is removed,
 
1157
          only a dynamic_val of 42 will allow the test to pass.  Anything other
 
1158
          than 54 or 42 will cause an AssertionError.
 
1159
        """
 
1160
        try:
 
1161
            assertion(*args, **kwargs)
 
1162
        except AssertionError:
 
1163
            raise KnownFailure(reason)
 
1164
        else:
 
1165
            self.fail('Unexpected success.  Should have failed: %s' % reason)
 
1166
 
1305
1167
    def assertFileEqual(self, content, path):
1306
1168
        """Fail if path does not contain 'content'."""
1307
1169
        self.failUnlessExists(path)
1457
1319
 
1458
1320
        Close the file and delete it, unless setKeepLogfile was called.
1459
1321
        """
1460
 
        if bzrlib.trace._trace_file:
1461
 
            # flush the log file, to get all content
1462
 
            bzrlib.trace._trace_file.flush()
 
1322
        if self._log_file is None:
 
1323
            return
1463
1324
        bzrlib.trace.pop_log_file(self._log_memento)
1464
 
        # Cache the log result and delete the file on disk
1465
 
        self._get_log(False)
 
1325
        self._log_file.close()
 
1326
        self._log_file = None
 
1327
        if not self._keep_log_file:
 
1328
            os.remove(self._log_file_name)
 
1329
            self._log_file_name = None
 
1330
 
 
1331
    def setKeepLogfile(self):
 
1332
        """Make the logfile not be deleted when _finishLogFile is called."""
 
1333
        self._keep_log_file = True
1466
1334
 
1467
1335
    def thisFailsStrictLockCheck(self):
1468
1336
        """It is known that this test would fail with -Dstrict_locks.
1485
1353
        """
1486
1354
        self._cleanups.append((callable, args, kwargs))
1487
1355
 
1488
 
    def overrideAttr(self, obj, attr_name, new=_unitialized_attr):
1489
 
        """Overrides an object attribute restoring it after the test.
1490
 
 
1491
 
        :param obj: The object that will be mutated.
1492
 
 
1493
 
        :param attr_name: The attribute name we want to preserve/override in
1494
 
            the object.
1495
 
 
1496
 
        :param new: The optional value we want to set the attribute to.
1497
 
 
1498
 
        :returns: The actual attr value.
1499
 
        """
1500
 
        value = getattr(obj, attr_name)
1501
 
        # The actual value is captured by the call below
1502
 
        self.addCleanup(setattr, obj, attr_name, value)
1503
 
        if new is not _unitialized_attr:
1504
 
            setattr(obj, attr_name, new)
1505
 
        return value
1506
 
 
1507
1356
    def _cleanEnvironment(self):
1508
1357
        new_env = {
1509
1358
            'BZR_HOME': None, # Don't inherit BZR_HOME to all the tests.
1519
1368
            'BZR_PROGRESS_BAR': None,
1520
1369
            'BZR_LOG': None,
1521
1370
            'BZR_PLUGIN_PATH': None,
1522
 
            'BZR_CONCURRENCY': None,
1523
1371
            # Make sure that any text ui tests are consistent regardless of
1524
1372
            # the environment the test case is run in; you may want tests that
1525
1373
            # test other combinations.  'dumb' is a reasonable guess for tests
1527
1375
            'TERM': 'dumb',
1528
1376
            'LINES': '25',
1529
1377
            'COLUMNS': '80',
1530
 
            'BZR_COLUMNS': '80',
1531
1378
            # SSH Agent
1532
1379
            'SSH_AUTH_SOCK': None,
1533
1380
            # Proxies
1545
1392
            'ftp_proxy': None,
1546
1393
            'FTP_PROXY': None,
1547
1394
            'BZR_REMOTE_PATH': None,
1548
 
            # Generally speaking, we don't want apport reporting on crashes in
1549
 
            # the test envirnoment unless we're specifically testing apport,
1550
 
            # so that it doesn't leak into the real system environment.  We
1551
 
            # use an env var so it propagates to subprocesses.
1552
 
            'APPORT_DISABLE': '1',
1553
1395
        }
1554
 
        self._old_env = {}
 
1396
        self.__old_env = {}
1555
1397
        self.addCleanup(self._restoreEnvironment)
1556
1398
        for name, value in new_env.iteritems():
1557
1399
            self._captureVar(name, value)
1558
1400
 
1559
1401
    def _captureVar(self, name, newvalue):
1560
1402
        """Set an environment variable, and reset it when finished."""
1561
 
        self._old_env[name] = osutils.set_or_unset_env(name, newvalue)
 
1403
        self.__old_env[name] = osutils.set_or_unset_env(name, newvalue)
 
1404
 
 
1405
    def _restore_debug_flags(self):
 
1406
        debug.debug_flags.clear()
 
1407
        debug.debug_flags.update(self._preserved_debug_flags)
1562
1408
 
1563
1409
    def _restoreEnvironment(self):
1564
 
        for name, value in self._old_env.iteritems():
 
1410
        for name, value in self.__old_env.iteritems():
1565
1411
            osutils.set_or_unset_env(name, value)
1566
1412
 
1567
1413
    def _restoreHooks(self):
1575
1421
    def _do_skip(self, result, reason):
1576
1422
        addSkip = getattr(result, 'addSkip', None)
1577
1423
        if not callable(addSkip):
1578
 
            result.addSuccess(result)
 
1424
            result.addError(self, sys.exc_info())
1579
1425
        else:
1580
1426
            addSkip(self, reason)
1581
1427
 
1582
 
    @staticmethod
1583
 
    def _do_known_failure(self, result, e):
1584
 
        err = sys.exc_info()
1585
 
        addExpectedFailure = getattr(result, 'addExpectedFailure', None)
1586
 
        if addExpectedFailure is not None:
1587
 
            addExpectedFailure(self, err)
1588
 
        else:
1589
 
            result.addSuccess(self)
1590
 
 
1591
 
    @staticmethod
1592
 
    def _do_not_applicable(self, result, e):
1593
 
        if not e.args:
1594
 
            reason = 'No reason given'
1595
 
        else:
1596
 
            reason = e.args[0]
1597
 
        addNotApplicable = getattr(result, 'addNotApplicable', None)
1598
 
        if addNotApplicable is not None:
1599
 
            result.addNotApplicable(self, reason)
1600
 
        else:
1601
 
            self._do_skip(result, reason)
1602
 
 
1603
 
    @staticmethod
1604
 
    def _do_unsupported_or_skip(self, result, e):
1605
 
        reason = e.args[0]
1606
 
        addNotSupported = getattr(result, 'addNotSupported', None)
1607
 
        if addNotSupported is not None:
1608
 
            result.addNotSupported(self, reason)
1609
 
        else:
1610
 
            self._do_skip(result, reason)
 
1428
    def run(self, result=None):
 
1429
        if result is None: result = self.defaultTestResult()
 
1430
        for feature in getattr(self, '_test_needs_features', []):
 
1431
            if not feature.available():
 
1432
                result.startTest(self)
 
1433
                if getattr(result, 'addNotSupported', None):
 
1434
                    result.addNotSupported(self, feature)
 
1435
                else:
 
1436
                    result.addSuccess(self)
 
1437
                result.stopTest(self)
 
1438
                return result
 
1439
        try:
 
1440
            try:
 
1441
                result.startTest(self)
 
1442
                absent_attr = object()
 
1443
                # Python 2.5
 
1444
                method_name = getattr(self, '_testMethodName', absent_attr)
 
1445
                if method_name is absent_attr:
 
1446
                    # Python 2.4
 
1447
                    method_name = getattr(self, '_TestCase__testMethodName')
 
1448
                testMethod = getattr(self, method_name)
 
1449
                try:
 
1450
                    try:
 
1451
                        self.setUp()
 
1452
                        if not self._bzr_test_setUp_run:
 
1453
                            self.fail(
 
1454
                                "test setUp did not invoke "
 
1455
                                "bzrlib.tests.TestCase's setUp")
 
1456
                    except KeyboardInterrupt:
 
1457
                        self._runCleanups()
 
1458
                        raise
 
1459
                    except TestSkipped, e:
 
1460
                        self._do_skip(result, e.args[0])
 
1461
                        self.tearDown()
 
1462
                        return result
 
1463
                    except:
 
1464
                        result.addError(self, sys.exc_info())
 
1465
                        self._runCleanups()
 
1466
                        return result
 
1467
 
 
1468
                    ok = False
 
1469
                    try:
 
1470
                        testMethod()
 
1471
                        ok = True
 
1472
                    except self.failureException:
 
1473
                        result.addFailure(self, sys.exc_info())
 
1474
                    except TestSkipped, e:
 
1475
                        if not e.args:
 
1476
                            reason = "No reason given."
 
1477
                        else:
 
1478
                            reason = e.args[0]
 
1479
                        self._do_skip(result, reason)
 
1480
                    except KeyboardInterrupt:
 
1481
                        self._runCleanups()
 
1482
                        raise
 
1483
                    except:
 
1484
                        result.addError(self, sys.exc_info())
 
1485
 
 
1486
                    try:
 
1487
                        self.tearDown()
 
1488
                        if not self._bzr_test_tearDown_run:
 
1489
                            self.fail(
 
1490
                                "test tearDown did not invoke "
 
1491
                                "bzrlib.tests.TestCase's tearDown")
 
1492
                    except KeyboardInterrupt:
 
1493
                        self._runCleanups()
 
1494
                        raise
 
1495
                    except:
 
1496
                        result.addError(self, sys.exc_info())
 
1497
                        self._runCleanups()
 
1498
                        ok = False
 
1499
                    if ok: result.addSuccess(self)
 
1500
                finally:
 
1501
                    result.stopTest(self)
 
1502
                return result
 
1503
            except TestNotApplicable:
 
1504
                # Not moved from the result [yet].
 
1505
                self._runCleanups()
 
1506
                raise
 
1507
            except KeyboardInterrupt:
 
1508
                self._runCleanups()
 
1509
                raise
 
1510
        finally:
 
1511
            saved_attrs = {}
 
1512
            for attr_name in self.attrs_to_keep:
 
1513
                if attr_name in self.__dict__:
 
1514
                    saved_attrs[attr_name] = self.__dict__[attr_name]
 
1515
            self.__dict__ = saved_attrs
 
1516
 
 
1517
    def tearDown(self):
 
1518
        self._runCleanups()
 
1519
        self._log_contents = ''
 
1520
        self._bzr_test_tearDown_run = True
 
1521
        unittest.TestCase.tearDown(self)
1611
1522
 
1612
1523
    def time(self, callable, *args, **kwargs):
1613
1524
        """Run callable and accrue the time it takes to the benchmark time.
1617
1528
        self._benchcalls.
1618
1529
        """
1619
1530
        if self._benchtime is None:
1620
 
            self.addDetail('benchtime', content.Content(content.ContentType(
1621
 
                "text", "plain"), lambda:[str(self._benchtime)]))
1622
1531
            self._benchtime = 0
1623
1532
        start = time.time()
1624
1533
        try:
1633
1542
        finally:
1634
1543
            self._benchtime += time.time() - start
1635
1544
 
 
1545
    def _runCleanups(self):
 
1546
        """Run registered cleanup functions.
 
1547
 
 
1548
        This should only be called from TestCase.tearDown.
 
1549
        """
 
1550
        # TODO: Perhaps this should keep running cleanups even if
 
1551
        # one of them fails?
 
1552
 
 
1553
        # Actually pop the cleanups from the list so tearDown running
 
1554
        # twice is safe (this happens for skipped tests).
 
1555
        while self._cleanups:
 
1556
            cleanup, args, kwargs = self._cleanups.pop()
 
1557
            cleanup(*args, **kwargs)
 
1558
 
1636
1559
    def log(self, *args):
1637
1560
        mutter(*args)
1638
1561
 
1639
1562
    def _get_log(self, keep_log_file=False):
1640
 
        """Internal helper to get the log from bzrlib.trace for this test.
1641
 
 
1642
 
        Please use self.getDetails, or self.get_log to access this in test case
1643
 
        code.
 
1563
        """Get the log from bzrlib.trace calls from this test.
1644
1564
 
1645
1565
        :param keep_log_file: When True, if the log is still a file on disk
1646
1566
            leave it as a file on disk. When False, if the log is still a file
1648
1568
            self._log_contents.
1649
1569
        :return: A string containing the log.
1650
1570
        """
1651
 
        if self._log_contents is not None:
1652
 
            try:
1653
 
                self._log_contents.decode('utf8')
1654
 
            except UnicodeDecodeError:
1655
 
                unicodestr = self._log_contents.decode('utf8', 'replace')
1656
 
                self._log_contents = unicodestr.encode('utf8')
 
1571
        # flush the log file, to get all content
 
1572
        import bzrlib.trace
 
1573
        if bzrlib.trace._trace_file:
 
1574
            bzrlib.trace._trace_file.flush()
 
1575
        if self._log_contents:
 
1576
            # XXX: this can hardly contain the content flushed above --vila
 
1577
            # 20080128
1657
1578
            return self._log_contents
1658
 
        import bzrlib.trace
1659
 
        if bzrlib.trace._trace_file:
1660
 
            # flush the log file, to get all content
1661
 
            bzrlib.trace._trace_file.flush()
1662
1579
        if self._log_file_name is not None:
1663
1580
            logfile = open(self._log_file_name)
1664
1581
            try:
1665
1582
                log_contents = logfile.read()
1666
1583
            finally:
1667
1584
                logfile.close()
1668
 
            try:
1669
 
                log_contents.decode('utf8')
1670
 
            except UnicodeDecodeError:
1671
 
                unicodestr = log_contents.decode('utf8', 'replace')
1672
 
                log_contents = unicodestr.encode('utf8')
1673
1585
            if not keep_log_file:
1674
 
                self._log_file.close()
1675
 
                self._log_file = None
1676
 
                # Permit multiple calls to get_log until we clean it up in
1677
 
                # finishLogFile
1678
1586
                self._log_contents = log_contents
1679
1587
                try:
1680
1588
                    os.remove(self._log_file_name)
1684
1592
                                             ' %r\n' % self._log_file_name))
1685
1593
                    else:
1686
1594
                        raise
1687
 
                self._log_file_name = None
1688
1595
            return log_contents
1689
1596
        else:
1690
 
            return "No log file content and no log file name."
1691
 
 
1692
 
    def get_log(self):
1693
 
        """Get a unicode string containing the log from bzrlib.trace.
1694
 
 
1695
 
        Undecodable characters are replaced.
1696
 
        """
1697
 
        return u"".join(self.getDetails()['log'].iter_text())
 
1597
            return "DELETED log file to reduce memory footprint"
1698
1598
 
1699
1599
    def requireFeature(self, feature):
1700
1600
        """This test requires a specific feature is available.
1717
1617
 
1718
1618
    def _run_bzr_core(self, args, retcode, encoding, stdin,
1719
1619
            working_dir):
1720
 
        # Clear chk_map page cache, because the contents are likely to mask
1721
 
        # locking errors.
1722
 
        chk_map.clear_cache()
1723
1620
        if encoding is None:
1724
1621
            encoding = osutils.get_user_encoding()
1725
1622
        stdout = StringIOWrapper()
1742
1639
            os.chdir(working_dir)
1743
1640
 
1744
1641
        try:
1745
 
            try:
1746
 
                result = self.apply_redirected(ui.ui_factory.stdin,
1747
 
                    stdout, stderr,
1748
 
                    bzrlib.commands.run_bzr_catch_user_errors,
1749
 
                    args)
1750
 
            except KeyboardInterrupt:
1751
 
                # Reraise KeyboardInterrupt with contents of redirected stdout
1752
 
                # and stderr as arguments, for tests which are interested in
1753
 
                # stdout and stderr and are expecting the exception.
1754
 
                out = stdout.getvalue()
1755
 
                err = stderr.getvalue()
1756
 
                if out:
1757
 
                    self.log('output:\n%r', out)
1758
 
                if err:
1759
 
                    self.log('errors:\n%r', err)
1760
 
                raise KeyboardInterrupt(out, err)
 
1642
            result = self.apply_redirected(ui.ui_factory.stdin,
 
1643
                stdout, stderr,
 
1644
                bzrlib.commands.run_bzr_catch_user_errors,
 
1645
                args)
1761
1646
        finally:
1762
1647
            logger.removeHandler(handler)
1763
1648
            ui.ui_factory = old_ui_factory
1773
1658
        if retcode is not None:
1774
1659
            self.assertEquals(retcode, result,
1775
1660
                              message='Unexpected return code')
1776
 
        return result, out, err
 
1661
        return out, err
1777
1662
 
1778
1663
    def run_bzr(self, args, retcode=0, encoding=None, stdin=None,
1779
1664
                working_dir=None, error_regexes=[], output_encoding=None):
1808
1693
        :keyword error_regexes: A list of expected error messages.  If
1809
1694
            specified they must be seen in the error output of the command.
1810
1695
        """
1811
 
        retcode, out, err = self._run_bzr_autosplit(
 
1696
        out, err = self._run_bzr_autosplit(
1812
1697
            args=args,
1813
1698
            retcode=retcode,
1814
1699
            encoding=encoding,
1965
1850
        """
1966
1851
        return Popen(*args, **kwargs)
1967
1852
 
1968
 
    def get_source_path(self):
1969
 
        """Return the path of the directory containing bzrlib."""
1970
 
        return os.path.dirname(os.path.dirname(bzrlib.__file__))
1971
 
 
1972
1853
    def get_bzr_path(self):
1973
1854
        """Return the path of the 'bzr' executable for this test suite."""
1974
 
        bzr_path = self.get_source_path()+'/bzr'
 
1855
        bzr_path = os.path.dirname(os.path.dirname(bzrlib.__file__))+'/bzr'
1975
1856
        if not os.path.isfile(bzr_path):
1976
1857
            # We are probably installed. Assume sys.argv is the right file
1977
1858
            bzr_path = sys.argv[0]
2063
1944
 
2064
1945
        Tests that expect to provoke LockContention errors should call this.
2065
1946
        """
2066
 
        self.overrideAttr(bzrlib.lockdir, '_DEFAULT_TIMEOUT_SECONDS', 0)
 
1947
        orig_timeout = bzrlib.lockdir._DEFAULT_TIMEOUT_SECONDS
 
1948
        def resetTimeout():
 
1949
            bzrlib.lockdir._DEFAULT_TIMEOUT_SECONDS = orig_timeout
 
1950
        self.addCleanup(resetTimeout)
 
1951
        bzrlib.lockdir._DEFAULT_TIMEOUT_SECONDS = 0
2067
1952
 
2068
1953
    def make_utf8_encoded_stringio(self, encoding_type=None):
2069
1954
        """Return a StringIOWrapper instance, that will encode Unicode
2083
1968
        request_handlers = request.request_handlers
2084
1969
        orig_method = request_handlers.get(verb)
2085
1970
        request_handlers.remove(verb)
2086
 
        self.addCleanup(request_handlers.register, verb, orig_method)
 
1971
        def restoreVerb():
 
1972
            request_handlers.register(verb, orig_method)
 
1973
        self.addCleanup(restoreVerb)
2087
1974
 
2088
1975
 
2089
1976
class CapturedCall(object):
2180
2067
        if self.__readonly_server is None:
2181
2068
            if self.transport_readonly_server is None:
2182
2069
                # readonly decorator requested
2183
 
                self.__readonly_server = test_server.ReadonlyServer()
 
2070
                # bring up the server
 
2071
                self.__readonly_server = ReadonlyServer()
 
2072
                self.__readonly_server.setUp(self.get_vfs_only_server())
2184
2073
            else:
2185
 
                # explicit readonly transport.
2186
2074
                self.__readonly_server = self.create_transport_readonly_server()
2187
 
            self.start_server(self.__readonly_server,
2188
 
                self.get_vfs_only_server())
 
2075
                self.__readonly_server.setUp(self.get_vfs_only_server())
 
2076
            self.addCleanup(self.__readonly_server.tearDown)
2189
2077
        return self.__readonly_server
2190
2078
 
2191
2079
    def get_readonly_url(self, relpath=None):
2209
2097
        is no means to override it.
2210
2098
        """
2211
2099
        if self.__vfs_server is None:
2212
 
            self.__vfs_server = memory.MemoryServer()
2213
 
            self.start_server(self.__vfs_server)
 
2100
            self.__vfs_server = MemoryServer()
 
2101
            self.__vfs_server.setUp()
 
2102
            self.addCleanup(self.__vfs_server.tearDown)
2214
2103
        return self.__vfs_server
2215
2104
 
2216
2105
    def get_server(self):
2223
2112
        then the self.get_vfs_server is returned.
2224
2113
        """
2225
2114
        if self.__server is None:
2226
 
            if (self.transport_server is None or self.transport_server is
2227
 
                self.vfs_transport_factory):
2228
 
                self.__server = self.get_vfs_only_server()
 
2115
            if self.transport_server is None or self.transport_server is self.vfs_transport_factory:
 
2116
                return self.get_vfs_only_server()
2229
2117
            else:
2230
2118
                # bring up a decorated means of access to the vfs only server.
2231
2119
                self.__server = self.transport_server()
2232
 
                self.start_server(self.__server, self.get_vfs_only_server())
 
2120
                try:
 
2121
                    self.__server.setUp(self.get_vfs_only_server())
 
2122
                except TypeError, e:
 
2123
                    # This should never happen; the try:Except here is to assist
 
2124
                    # developers having to update code rather than seeing an
 
2125
                    # uninformative TypeError.
 
2126
                    raise Exception, "Old server API in use: %s, %s" % (self.__server, e)
 
2127
            self.addCleanup(self.__server.tearDown)
2233
2128
        return self.__server
2234
2129
 
2235
2130
    def _adjust_url(self, base, relpath):
2297
2192
        propagating. This method ensures than a test did not leaked.
2298
2193
        """
2299
2194
        root = TestCaseWithMemoryTransport.TEST_ROOT
2300
 
        self.permit_url(get_transport(root).base)
2301
2195
        wt = workingtree.WorkingTree.open(root)
2302
2196
        last_rev = wt.last_revision()
2303
2197
        if last_rev != 'null:':
2305
2199
            # recreate a new one or all the followng tests will fail.
2306
2200
            # If you need to inspect its content uncomment the following line
2307
2201
            # import pdb; pdb.set_trace()
2308
 
            _rmtree_temp_dir(root + '/.bzr', test_id=self.id())
 
2202
            _rmtree_temp_dir(root + '/.bzr')
2309
2203
            self._create_safety_net()
2310
2204
            raise AssertionError('%s/.bzr should not be modified' % root)
2311
2205
 
2312
2206
    def _make_test_root(self):
2313
2207
        if TestCaseWithMemoryTransport.TEST_ROOT is None:
2314
 
            # Watch out for tricky test dir (on OSX /tmp -> /private/tmp)
2315
 
            root = osutils.realpath(osutils.mkdtemp(prefix='testbzr-',
2316
 
                                                    suffix='.tmp'))
 
2208
            root = osutils.mkdtemp(prefix='testbzr-', suffix='.tmp')
2317
2209
            TestCaseWithMemoryTransport.TEST_ROOT = root
2318
2210
 
2319
2211
            self._create_safety_net()
2322
2214
            # specifically told when all tests are finished.  This will do.
2323
2215
            atexit.register(_rmtree_temp_dir, root)
2324
2216
 
2325
 
        self.permit_dir(TestCaseWithMemoryTransport.TEST_ROOT)
2326
2217
        self.addCleanup(self._check_safety_net)
2327
2218
 
2328
2219
    def makeAndChdirToTestDir(self):
2336
2227
        os.chdir(TestCaseWithMemoryTransport.TEST_ROOT)
2337
2228
        self.test_dir = TestCaseWithMemoryTransport.TEST_ROOT
2338
2229
        self.test_home_dir = self.test_dir + "/MemoryTransportMissingHomeDir"
2339
 
        self.permit_dir(self.test_dir)
2340
2230
 
2341
2231
    def make_branch(self, relpath, format=None):
2342
2232
        """Create a branch on the transport at relpath."""
2372
2262
        return made_control.create_repository(shared=shared)
2373
2263
 
2374
2264
    def make_smart_server(self, path):
2375
 
        smart_server = test_server.SmartTCPServer_for_testing()
2376
 
        self.start_server(smart_server, self.get_server())
 
2265
        smart_server = server.SmartTCPServer_for_testing()
 
2266
        smart_server.setUp(self.get_server())
2377
2267
        remote_transport = get_transport(smart_server.get_url()).clone(path)
 
2268
        self.addCleanup(smart_server.tearDown)
2378
2269
        return remote_transport
2379
2270
 
2380
2271
    def make_branch_and_memory_tree(self, relpath, format=None):
2387
2278
        return branchbuilder.BranchBuilder(branch=branch)
2388
2279
 
2389
2280
    def overrideEnvironmentForTesting(self):
2390
 
        test_home_dir = self.test_home_dir
2391
 
        if isinstance(test_home_dir, unicode):
2392
 
            test_home_dir = test_home_dir.encode(sys.getfilesystemencoding())
2393
 
        os.environ['HOME'] = test_home_dir
2394
 
        os.environ['BZR_HOME'] = test_home_dir
 
2281
        os.environ['HOME'] = self.test_home_dir
 
2282
        os.environ['BZR_HOME'] = self.test_home_dir
2395
2283
 
2396
2284
    def setUp(self):
2397
2285
        super(TestCaseWithMemoryTransport, self).setUp()
2398
2286
        self._make_test_root()
2399
 
        self.addCleanup(os.chdir, os.getcwdu())
 
2287
        _currentdir = os.getcwdu()
 
2288
        def _leaveDirectory():
 
2289
            os.chdir(_currentdir)
 
2290
        self.addCleanup(_leaveDirectory)
2400
2291
        self.makeAndChdirToTestDir()
2401
2292
        self.overrideEnvironmentForTesting()
2402
2293
        self.__readonly_server = None
2405
2296
 
2406
2297
    def setup_smart_server_with_call_log(self):
2407
2298
        """Sets up a smart server as the transport server with a call log."""
2408
 
        self.transport_server = test_server.SmartTCPServer_for_testing
 
2299
        self.transport_server = server.SmartTCPServer_for_testing
2409
2300
        self.hpss_calls = []
2410
2301
        import traceback
2411
2302
        # Skip the current stack down to the caller of
2474
2365
            if os.path.exists(name):
2475
2366
                name = name_prefix + '_' + str(i)
2476
2367
            else:
2477
 
                # now create test and home directories within this dir
2478
 
                self.test_base_dir = name
2479
 
                self.addCleanup(self.deleteTestDir)
2480
 
                os.mkdir(self.test_base_dir)
 
2368
                os.mkdir(name)
2481
2369
                break
2482
 
        self.permit_dir(self.test_base_dir)
2483
 
        # 'sprouting' and 'init' of a branch both walk up the tree to find
2484
 
        # stacking policy to honour; create a bzr dir with an unshared
2485
 
        # repository (but not a branch - our code would be trying to escape
2486
 
        # then!) to stop them, and permit it to be read.
2487
 
        # control = bzrdir.BzrDir.create(self.test_base_dir)
2488
 
        # control.create_repository()
 
2370
        # now create test and home directories within this dir
 
2371
        self.test_base_dir = name
2489
2372
        self.test_home_dir = self.test_base_dir + '/home'
2490
2373
        os.mkdir(self.test_home_dir)
2491
2374
        self.test_dir = self.test_base_dir + '/work'
2497
2380
            f.write(self.id())
2498
2381
        finally:
2499
2382
            f.close()
 
2383
        self.addCleanup(self.deleteTestDir)
2500
2384
 
2501
2385
    def deleteTestDir(self):
2502
2386
        os.chdir(TestCaseWithMemoryTransport.TEST_ROOT)
2503
 
        _rmtree_temp_dir(self.test_base_dir, test_id=self.id())
 
2387
        _rmtree_temp_dir(self.test_base_dir)
2504
2388
 
2505
2389
    def build_tree(self, shape, line_endings='binary', transport=None):
2506
2390
        """Build a test tree according to a pattern.
2588
2472
        """
2589
2473
        if self.__vfs_server is None:
2590
2474
            self.__vfs_server = self.vfs_transport_factory()
2591
 
            self.start_server(self.__vfs_server)
 
2475
            self.__vfs_server.setUp()
 
2476
            self.addCleanup(self.__vfs_server.tearDown)
2592
2477
        return self.__vfs_server
2593
2478
 
2594
2479
    def make_branch_and_tree(self, relpath, format=None):
2601
2486
        repository will also be accessed locally. Otherwise a lightweight
2602
2487
        checkout is created and returned.
2603
2488
 
2604
 
        We do this because we can't physically create a tree in the local
2605
 
        path, with a branch reference to the transport_factory url, and
2606
 
        a branch + repository in the vfs_transport, unless the vfs_transport
2607
 
        namespace is distinct from the local disk - the two branch objects
2608
 
        would collide. While we could construct a tree with its branch object
2609
 
        pointing at the transport_factory transport in memory, reopening it
2610
 
        would behaving unexpectedly, and has in the past caused testing bugs
2611
 
        when we tried to do it that way.
2612
 
 
2613
2489
        :param format: The BzrDirFormat.
2614
2490
        :returns: the WorkingTree.
2615
2491
        """
2624
2500
            # We can only make working trees locally at the moment.  If the
2625
2501
            # transport can't support them, then we keep the non-disk-backed
2626
2502
            # branch and create a local checkout.
2627
 
            if self.vfs_transport_factory is test_server.LocalURLServer:
 
2503
            if self.vfs_transport_factory is LocalURLServer:
2628
2504
                # the branch is colocated on disk, we cannot create a checkout.
2629
2505
                # hopefully callers will expect this.
2630
2506
                local_controldir= bzrdir.BzrDir.open(self.get_vfs_only_url(relpath))
2667
2543
        super(TestCaseWithTransport, self).setUp()
2668
2544
        self.__vfs_server = None
2669
2545
 
2670
 
    def disable_missing_extensions_warning(self):
2671
 
        """Some tests expect a precise stderr content.
2672
 
 
2673
 
        There is no point in forcing them to duplicate the extension related
2674
 
        warning.
2675
 
        """
2676
 
        config.GlobalConfig().set_user_option('ignore_missing_extensions', True)
2677
 
 
2678
2546
 
2679
2547
class ChrootedTestCase(TestCaseWithTransport):
2680
2548
    """A support class that provides readonly urls outside the local namespace.
2690
2558
 
2691
2559
    def setUp(self):
2692
2560
        super(ChrootedTestCase, self).setUp()
2693
 
        if not self.vfs_transport_factory == memory.MemoryServer:
 
2561
        if not self.vfs_transport_factory == MemoryServer:
2694
2562
            self.transport_readonly_server = HttpServer
2695
2563
 
2696
2564
 
2894
2762
              strict=False,
2895
2763
              runner_class=None,
2896
2764
              suite_decorators=None,
2897
 
              stream=None,
2898
 
              result_decorators=None,
2899
 
              ):
 
2765
              stream=None):
2900
2766
    """Run a test suite for bzr selftest.
2901
2767
 
2902
2768
    :param runner_class: The class of runner to use. Must support the
2917
2783
                            descriptions=0,
2918
2784
                            verbosity=verbosity,
2919
2785
                            bench_history=bench_history,
 
2786
                            list_only=list_only,
2920
2787
                            strict=strict,
2921
 
                            result_decorators=result_decorators,
2922
2788
                            )
2923
2789
    runner.stop_on_failure=stop_on_failure
2924
2790
    # built in decorator factories:
2939
2805
        decorators.append(CountingDecorator)
2940
2806
    for decorator in decorators:
2941
2807
        suite = decorator(suite)
 
2808
    result = runner.run(suite)
2942
2809
    if list_only:
2943
 
        # Done after test suite decoration to allow randomisation etc
2944
 
        # to take effect, though that is of marginal benefit.
2945
 
        if verbosity >= 2:
2946
 
            stream.write("Listing tests only ...\n")
2947
 
        for t in iter_suite_tests(suite):
2948
 
            stream.write("%s\n" % (t.id()))
2949
2810
        return True
2950
 
    result = runner.run(suite)
 
2811
    result.done()
2951
2812
    if strict:
2952
2813
        return result.wasStrictlySuccessful()
2953
2814
    else:
3110
2971
        if self.randomised:
3111
2972
            return iter(self._tests)
3112
2973
        self.randomised = True
3113
 
        self.stream.write("Randomizing test order using seed %s\n\n" %
 
2974
        self.stream.writeln("Randomizing test order using seed %s\n" %
3114
2975
            (self.actual_seed()))
3115
2976
        # Initialise the random number generator.
3116
2977
        random.seed(self.actual_seed())
3173
3034
    concurrency = osutils.local_concurrency()
3174
3035
    result = []
3175
3036
    from subunit import TestProtocolClient, ProtocolTestCase
3176
 
    from subunit.test_results import AutoTimingTestResultDecorator
 
3037
    try:
 
3038
        from subunit.test_results import AutoTimingTestResultDecorator
 
3039
    except ImportError:
 
3040
        AutoTimingTestResultDecorator = lambda x:x
3177
3041
    class TestInOtherProcess(ProtocolTestCase):
3178
3042
        # Should be in subunit, I think. RBC.
3179
3043
        def __init__(self, stream, pid):
3245
3109
        if not os.path.isfile(bzr_path):
3246
3110
            # We are probably installed. Assume sys.argv is the right file
3247
3111
            bzr_path = sys.argv[0]
3248
 
        bzr_path = [bzr_path]
3249
 
        if sys.platform == "win32":
3250
 
            # if we're on windows, we can't execute the bzr script directly
3251
 
            bzr_path = [sys.executable] + bzr_path
3252
3112
        fd, test_list_file_name = tempfile.mkstemp()
3253
3113
        test_list_file = os.fdopen(fd, 'wb', 1)
3254
3114
        for test in process_tests:
3255
3115
            test_list_file.write(test.id() + '\n')
3256
3116
        test_list_file.close()
3257
3117
        try:
3258
 
            argv = bzr_path + ['selftest', '--load-list', test_list_file_name,
 
3118
            argv = [bzr_path, 'selftest', '--load-list', test_list_file_name,
3259
3119
                '--subunit']
3260
3120
            if '--no-plugins' in sys.argv:
3261
3121
                argv.append('--no-plugins')
3271
3131
    return result
3272
3132
 
3273
3133
 
3274
 
class ForwardingResult(unittest.TestResult):
 
3134
class BZRTransformingResult(unittest.TestResult):
3275
3135
 
3276
3136
    def __init__(self, target):
3277
3137
        unittest.TestResult.__init__(self)
3283
3143
    def stopTest(self, test):
3284
3144
        self.result.stopTest(test)
3285
3145
 
3286
 
    def startTestRun(self):
3287
 
        self.result.startTestRun()
 
3146
    def addError(self, test, err):
 
3147
        feature = self._error_looks_like('UnavailableFeature: ', err)
 
3148
        if feature is not None:
 
3149
            self.result.addNotSupported(test, feature)
 
3150
        else:
 
3151
            self.result.addError(test, err)
3288
3152
 
3289
 
    def stopTestRun(self):
3290
 
        self.result.stopTestRun()
 
3153
    def addFailure(self, test, err):
 
3154
        known = self._error_looks_like('KnownFailure: ', err)
 
3155
        if known is not None:
 
3156
            self.result._addKnownFailure(test, [KnownFailure,
 
3157
                                                KnownFailure(known), None])
 
3158
        else:
 
3159
            self.result.addFailure(test, err)
3291
3160
 
3292
3161
    def addSkip(self, test, reason):
3293
3162
        self.result.addSkip(test, reason)
3295
3164
    def addSuccess(self, test):
3296
3165
        self.result.addSuccess(test)
3297
3166
 
3298
 
    def addError(self, test, err):
3299
 
        self.result.addError(test, err)
3300
 
 
3301
 
    def addFailure(self, test, err):
3302
 
        self.result.addFailure(test, err)
3303
 
ForwardingResult = testtools.ExtendedToOriginalDecorator
3304
 
 
3305
 
 
3306
 
class ProfileResult(ForwardingResult):
3307
 
    """Generate profiling data for all activity between start and success.
3308
 
    
3309
 
    The profile data is appended to the test's _benchcalls attribute and can
3310
 
    be accessed by the forwarded-to TestResult.
3311
 
 
3312
 
    While it might be cleaner do accumulate this in stopTest, addSuccess is
3313
 
    where our existing output support for lsprof is, and this class aims to
3314
 
    fit in with that: while it could be moved it's not necessary to accomplish
3315
 
    test profiling, nor would it be dramatically cleaner.
3316
 
    """
3317
 
 
3318
 
    def startTest(self, test):
3319
 
        self.profiler = bzrlib.lsprof.BzrProfiler()
3320
 
        self.profiler.start()
3321
 
        ForwardingResult.startTest(self, test)
3322
 
 
3323
 
    def addSuccess(self, test):
3324
 
        stats = self.profiler.stop()
3325
 
        try:
3326
 
            calls = test._benchcalls
3327
 
        except AttributeError:
3328
 
            test._benchcalls = []
3329
 
            calls = test._benchcalls
3330
 
        calls.append(((test.id(), "", ""), stats))
3331
 
        ForwardingResult.addSuccess(self, test)
3332
 
 
3333
 
    def stopTest(self, test):
3334
 
        ForwardingResult.stopTest(self, test)
3335
 
        self.profiler = None
 
3167
    def _error_looks_like(self, prefix, err):
 
3168
        """Deserialize exception and returns the stringify value."""
 
3169
        import subunit
 
3170
        value = None
 
3171
        typ, exc, _ = err
 
3172
        if isinstance(exc, subunit.RemoteException):
 
3173
            # stringify the exception gives access to the remote traceback
 
3174
            # We search the last line for 'prefix'
 
3175
            lines = str(exc).split('\n')
 
3176
            while lines and not lines[-1]:
 
3177
                lines.pop(-1)
 
3178
            if lines:
 
3179
                if lines[-1].startswith(prefix):
 
3180
                    value = lines[-1][len(prefix):]
 
3181
        return value
3336
3182
 
3337
3183
 
3338
3184
# Controlled by "bzr selftest -E=..." option
3362
3208
             runner_class=None,
3363
3209
             suite_decorators=None,
3364
3210
             stream=None,
3365
 
             lsprof_tests=False,
3366
3211
             ):
3367
3212
    """Run the whole test suite under the enhanced runner"""
3368
3213
    # XXX: Very ugly way to do this...
3397
3242
        if starting_with:
3398
3243
            # But always filter as requested.
3399
3244
            suite = filter_suite_by_id_startswith(suite, starting_with)
3400
 
        result_decorators = []
3401
 
        if lsprof_tests:
3402
 
            result_decorators.append(ProfileResult)
3403
3245
        return run_suite(suite, 'testbzr', verbose=verbose, pattern=pattern,
3404
3246
                     stop_on_failure=stop_on_failure,
3405
3247
                     transport=transport,
3413
3255
                     runner_class=runner_class,
3414
3256
                     suite_decorators=suite_decorators,
3415
3257
                     stream=stream,
3416
 
                     result_decorators=result_decorators,
3417
3258
                     )
3418
3259
    finally:
3419
3260
        default_transport = old_transport
3567
3408
# appear prefixed ('bzrlib.' is "replaced" by 'bzrlib.').
3568
3409
test_prefix_alias_registry.register('bzrlib', 'bzrlib')
3569
3410
 
3570
 
# Obvious highest levels prefixes, feel free to add your own via a plugin
 
3411
# Obvious higest levels prefixes, feel free to add your own via a plugin
3571
3412
test_prefix_alias_registry.register('bd', 'bzrlib.doc')
3572
3413
test_prefix_alias_registry.register('bu', 'bzrlib.utils')
3573
3414
test_prefix_alias_registry.register('bt', 'bzrlib.tests')
3575
3416
test_prefix_alias_registry.register('bp', 'bzrlib.plugins')
3576
3417
 
3577
3418
 
3578
 
def _test_suite_testmod_names():
3579
 
    """Return the standard list of test module names to test."""
3580
 
    return [
3581
 
        'bzrlib.doc',
3582
 
        'bzrlib.tests.blackbox',
3583
 
        'bzrlib.tests.commands',
3584
 
        'bzrlib.tests.per_branch',
3585
 
        'bzrlib.tests.per_bzrdir',
3586
 
        'bzrlib.tests.per_foreign_vcs',
3587
 
        'bzrlib.tests.per_interrepository',
3588
 
        'bzrlib.tests.per_intertree',
3589
 
        'bzrlib.tests.per_inventory',
3590
 
        'bzrlib.tests.per_interbranch',
3591
 
        'bzrlib.tests.per_lock',
3592
 
        'bzrlib.tests.per_merger',
3593
 
        'bzrlib.tests.per_transport',
3594
 
        'bzrlib.tests.per_tree',
3595
 
        'bzrlib.tests.per_pack_repository',
3596
 
        'bzrlib.tests.per_repository',
3597
 
        'bzrlib.tests.per_repository_chk',
3598
 
        'bzrlib.tests.per_repository_reference',
3599
 
        'bzrlib.tests.per_uifactory',
3600
 
        'bzrlib.tests.per_versionedfile',
3601
 
        'bzrlib.tests.per_workingtree',
3602
 
        'bzrlib.tests.test__annotator',
3603
 
        'bzrlib.tests.test__bencode',
3604
 
        'bzrlib.tests.test__chk_map',
3605
 
        'bzrlib.tests.test__dirstate_helpers',
3606
 
        'bzrlib.tests.test__groupcompress',
3607
 
        'bzrlib.tests.test__known_graph',
3608
 
        'bzrlib.tests.test__rio',
3609
 
        'bzrlib.tests.test__simple_set',
3610
 
        'bzrlib.tests.test__static_tuple',
3611
 
        'bzrlib.tests.test__walkdirs_win32',
3612
 
        'bzrlib.tests.test_ancestry',
3613
 
        'bzrlib.tests.test_annotate',
3614
 
        'bzrlib.tests.test_api',
3615
 
        'bzrlib.tests.test_atomicfile',
3616
 
        'bzrlib.tests.test_bad_files',
3617
 
        'bzrlib.tests.test_bisect_multi',
3618
 
        'bzrlib.tests.test_branch',
3619
 
        'bzrlib.tests.test_branchbuilder',
3620
 
        'bzrlib.tests.test_btree_index',
3621
 
        'bzrlib.tests.test_bugtracker',
3622
 
        'bzrlib.tests.test_bundle',
3623
 
        'bzrlib.tests.test_bzrdir',
3624
 
        'bzrlib.tests.test__chunks_to_lines',
3625
 
        'bzrlib.tests.test_cache_utf8',
3626
 
        'bzrlib.tests.test_chk_map',
3627
 
        'bzrlib.tests.test_chk_serializer',
3628
 
        'bzrlib.tests.test_chunk_writer',
3629
 
        'bzrlib.tests.test_clean_tree',
3630
 
        'bzrlib.tests.test_cleanup',
3631
 
        'bzrlib.tests.test_cmdline',
3632
 
        'bzrlib.tests.test_commands',
3633
 
        'bzrlib.tests.test_commit',
3634
 
        'bzrlib.tests.test_commit_merge',
3635
 
        'bzrlib.tests.test_config',
3636
 
        'bzrlib.tests.test_conflicts',
3637
 
        'bzrlib.tests.test_counted_lock',
3638
 
        'bzrlib.tests.test_crash',
3639
 
        'bzrlib.tests.test_decorators',
3640
 
        'bzrlib.tests.test_delta',
3641
 
        'bzrlib.tests.test_debug',
3642
 
        'bzrlib.tests.test_deprecated_graph',
3643
 
        'bzrlib.tests.test_diff',
3644
 
        'bzrlib.tests.test_directory_service',
3645
 
        'bzrlib.tests.test_dirstate',
3646
 
        'bzrlib.tests.test_email_message',
3647
 
        'bzrlib.tests.test_eol_filters',
3648
 
        'bzrlib.tests.test_errors',
3649
 
        'bzrlib.tests.test_export',
3650
 
        'bzrlib.tests.test_extract',
3651
 
        'bzrlib.tests.test_fetch',
3652
 
        'bzrlib.tests.test_fifo_cache',
3653
 
        'bzrlib.tests.test_filters',
3654
 
        'bzrlib.tests.test_ftp_transport',
3655
 
        'bzrlib.tests.test_foreign',
3656
 
        'bzrlib.tests.test_generate_docs',
3657
 
        'bzrlib.tests.test_generate_ids',
3658
 
        'bzrlib.tests.test_globbing',
3659
 
        'bzrlib.tests.test_gpg',
3660
 
        'bzrlib.tests.test_graph',
3661
 
        'bzrlib.tests.test_groupcompress',
3662
 
        'bzrlib.tests.test_hashcache',
3663
 
        'bzrlib.tests.test_help',
3664
 
        'bzrlib.tests.test_hooks',
3665
 
        'bzrlib.tests.test_http',
3666
 
        'bzrlib.tests.test_http_response',
3667
 
        'bzrlib.tests.test_https_ca_bundle',
3668
 
        'bzrlib.tests.test_identitymap',
3669
 
        'bzrlib.tests.test_ignores',
3670
 
        'bzrlib.tests.test_index',
3671
 
        'bzrlib.tests.test_import_tariff',
3672
 
        'bzrlib.tests.test_info',
3673
 
        'bzrlib.tests.test_inv',
3674
 
        'bzrlib.tests.test_inventory_delta',
3675
 
        'bzrlib.tests.test_knit',
3676
 
        'bzrlib.tests.test_lazy_import',
3677
 
        'bzrlib.tests.test_lazy_regex',
3678
 
        'bzrlib.tests.test_lock',
3679
 
        'bzrlib.tests.test_lockable_files',
3680
 
        'bzrlib.tests.test_lockdir',
3681
 
        'bzrlib.tests.test_log',
3682
 
        'bzrlib.tests.test_lru_cache',
3683
 
        'bzrlib.tests.test_lsprof',
3684
 
        'bzrlib.tests.test_mail_client',
3685
 
        'bzrlib.tests.test_memorytree',
3686
 
        'bzrlib.tests.test_merge',
3687
 
        'bzrlib.tests.test_merge3',
3688
 
        'bzrlib.tests.test_merge_core',
3689
 
        'bzrlib.tests.test_merge_directive',
3690
 
        'bzrlib.tests.test_missing',
3691
 
        'bzrlib.tests.test_msgeditor',
3692
 
        'bzrlib.tests.test_multiparent',
3693
 
        'bzrlib.tests.test_mutabletree',
3694
 
        'bzrlib.tests.test_nonascii',
3695
 
        'bzrlib.tests.test_options',
3696
 
        'bzrlib.tests.test_osutils',
3697
 
        'bzrlib.tests.test_osutils_encodings',
3698
 
        'bzrlib.tests.test_pack',
3699
 
        'bzrlib.tests.test_patch',
3700
 
        'bzrlib.tests.test_patches',
3701
 
        'bzrlib.tests.test_permissions',
3702
 
        'bzrlib.tests.test_plugins',
3703
 
        'bzrlib.tests.test_progress',
3704
 
        'bzrlib.tests.test_read_bundle',
3705
 
        'bzrlib.tests.test_reconcile',
3706
 
        'bzrlib.tests.test_reconfigure',
3707
 
        'bzrlib.tests.test_registry',
3708
 
        'bzrlib.tests.test_remote',
3709
 
        'bzrlib.tests.test_rename_map',
3710
 
        'bzrlib.tests.test_repository',
3711
 
        'bzrlib.tests.test_revert',
3712
 
        'bzrlib.tests.test_revision',
3713
 
        'bzrlib.tests.test_revisionspec',
3714
 
        'bzrlib.tests.test_revisiontree',
3715
 
        'bzrlib.tests.test_rio',
3716
 
        'bzrlib.tests.test_rules',
3717
 
        'bzrlib.tests.test_sampler',
3718
 
        'bzrlib.tests.test_script',
3719
 
        'bzrlib.tests.test_selftest',
3720
 
        'bzrlib.tests.test_serializer',
3721
 
        'bzrlib.tests.test_setup',
3722
 
        'bzrlib.tests.test_sftp_transport',
3723
 
        'bzrlib.tests.test_shelf',
3724
 
        'bzrlib.tests.test_shelf_ui',
3725
 
        'bzrlib.tests.test_smart',
3726
 
        'bzrlib.tests.test_smart_add',
3727
 
        'bzrlib.tests.test_smart_request',
3728
 
        'bzrlib.tests.test_smart_transport',
3729
 
        'bzrlib.tests.test_smtp_connection',
3730
 
        'bzrlib.tests.test_source',
3731
 
        'bzrlib.tests.test_ssh_transport',
3732
 
        'bzrlib.tests.test_status',
3733
 
        'bzrlib.tests.test_store',
3734
 
        'bzrlib.tests.test_strace',
3735
 
        'bzrlib.tests.test_subsume',
3736
 
        'bzrlib.tests.test_switch',
3737
 
        'bzrlib.tests.test_symbol_versioning',
3738
 
        'bzrlib.tests.test_tag',
3739
 
        'bzrlib.tests.test_testament',
3740
 
        'bzrlib.tests.test_textfile',
3741
 
        'bzrlib.tests.test_textmerge',
3742
 
        'bzrlib.tests.test_timestamp',
3743
 
        'bzrlib.tests.test_trace',
3744
 
        'bzrlib.tests.test_transactions',
3745
 
        'bzrlib.tests.test_transform',
3746
 
        'bzrlib.tests.test_transport',
3747
 
        'bzrlib.tests.test_transport_log',
3748
 
        'bzrlib.tests.test_tree',
3749
 
        'bzrlib.tests.test_treebuilder',
3750
 
        'bzrlib.tests.test_tsort',
3751
 
        'bzrlib.tests.test_tuned_gzip',
3752
 
        'bzrlib.tests.test_ui',
3753
 
        'bzrlib.tests.test_uncommit',
3754
 
        'bzrlib.tests.test_upgrade',
3755
 
        'bzrlib.tests.test_upgrade_stacked',
3756
 
        'bzrlib.tests.test_urlutils',
3757
 
        'bzrlib.tests.test_version',
3758
 
        'bzrlib.tests.test_version_info',
3759
 
        'bzrlib.tests.test_weave',
3760
 
        'bzrlib.tests.test_whitebox',
3761
 
        'bzrlib.tests.test_win32utils',
3762
 
        'bzrlib.tests.test_workingtree',
3763
 
        'bzrlib.tests.test_workingtree_4',
3764
 
        'bzrlib.tests.test_wsgi',
3765
 
        'bzrlib.tests.test_xml',
3766
 
        ]
3767
 
 
3768
 
 
3769
 
def _test_suite_modules_to_doctest():
3770
 
    """Return the list of modules to doctest."""   
3771
 
    return [
3772
 
        'bzrlib',
3773
 
        'bzrlib.branchbuilder',
3774
 
        'bzrlib.decorators',
3775
 
        'bzrlib.export',
3776
 
        'bzrlib.inventory',
3777
 
        'bzrlib.iterablefile',
3778
 
        'bzrlib.lockdir',
3779
 
        'bzrlib.merge3',
3780
 
        'bzrlib.option',
3781
 
        'bzrlib.symbol_versioning',
3782
 
        'bzrlib.tests',
3783
 
        'bzrlib.timestamp',
3784
 
        'bzrlib.version_info_formats.format_custom',
3785
 
        ]
3786
 
 
3787
 
 
3788
3419
def test_suite(keep_only=None, starting_with=None):
3789
3420
    """Build and return TestSuite for the whole of bzrlib.
3790
3421
 
3796
3427
    This function can be replaced if you need to change the default test
3797
3428
    suite on a global basis, but it is not encouraged.
3798
3429
    """
 
3430
    testmod_names = [
 
3431
                   'bzrlib.doc',
 
3432
                   'bzrlib.tests.blackbox',
 
3433
                   'bzrlib.tests.commands',
 
3434
                   'bzrlib.tests.per_branch',
 
3435
                   'bzrlib.tests.per_bzrdir',
 
3436
                   'bzrlib.tests.per_interrepository',
 
3437
                   'bzrlib.tests.per_intertree',
 
3438
                   'bzrlib.tests.per_inventory',
 
3439
                   'bzrlib.tests.per_interbranch',
 
3440
                   'bzrlib.tests.per_lock',
 
3441
                   'bzrlib.tests.per_transport',
 
3442
                   'bzrlib.tests.per_tree',
 
3443
                   'bzrlib.tests.per_pack_repository',
 
3444
                   'bzrlib.tests.per_repository',
 
3445
                   'bzrlib.tests.per_repository_chk',
 
3446
                   'bzrlib.tests.per_repository_reference',
 
3447
                   'bzrlib.tests.per_versionedfile',
 
3448
                   'bzrlib.tests.per_workingtree',
 
3449
                   'bzrlib.tests.test__annotator',
 
3450
                   'bzrlib.tests.test__chk_map',
 
3451
                   'bzrlib.tests.test__dirstate_helpers',
 
3452
                   'bzrlib.tests.test__groupcompress',
 
3453
                   'bzrlib.tests.test__known_graph',
 
3454
                   'bzrlib.tests.test__rio',
 
3455
                   'bzrlib.tests.test__walkdirs_win32',
 
3456
                   'bzrlib.tests.test_ancestry',
 
3457
                   'bzrlib.tests.test_annotate',
 
3458
                   'bzrlib.tests.test_api',
 
3459
                   'bzrlib.tests.test_atomicfile',
 
3460
                   'bzrlib.tests.test_bad_files',
 
3461
                   'bzrlib.tests.test_bencode',
 
3462
                   'bzrlib.tests.test_bisect_multi',
 
3463
                   'bzrlib.tests.test_branch',
 
3464
                   'bzrlib.tests.test_branchbuilder',
 
3465
                   'bzrlib.tests.test_btree_index',
 
3466
                   'bzrlib.tests.test_bugtracker',
 
3467
                   'bzrlib.tests.test_bundle',
 
3468
                   'bzrlib.tests.test_bzrdir',
 
3469
                   'bzrlib.tests.test__chunks_to_lines',
 
3470
                   'bzrlib.tests.test_cache_utf8',
 
3471
                   'bzrlib.tests.test_chk_map',
 
3472
                   'bzrlib.tests.test_chk_serializer',
 
3473
                   'bzrlib.tests.test_chunk_writer',
 
3474
                   'bzrlib.tests.test_clean_tree',
 
3475
                   'bzrlib.tests.test_commands',
 
3476
                   'bzrlib.tests.test_commit',
 
3477
                   'bzrlib.tests.test_commit_merge',
 
3478
                   'bzrlib.tests.test_config',
 
3479
                   'bzrlib.tests.test_conflicts',
 
3480
                   'bzrlib.tests.test_counted_lock',
 
3481
                   'bzrlib.tests.test_crash',
 
3482
                   'bzrlib.tests.test_decorators',
 
3483
                   'bzrlib.tests.test_delta',
 
3484
                   'bzrlib.tests.test_debug',
 
3485
                   'bzrlib.tests.test_deprecated_graph',
 
3486
                   'bzrlib.tests.test_diff',
 
3487
                   'bzrlib.tests.test_directory_service',
 
3488
                   'bzrlib.tests.test_dirstate',
 
3489
                   'bzrlib.tests.test_email_message',
 
3490
                   'bzrlib.tests.test_eol_filters',
 
3491
                   'bzrlib.tests.test_errors',
 
3492
                   'bzrlib.tests.test_export',
 
3493
                   'bzrlib.tests.test_extract',
 
3494
                   'bzrlib.tests.test_fetch',
 
3495
                   'bzrlib.tests.test_fifo_cache',
 
3496
                   'bzrlib.tests.test_filters',
 
3497
                   'bzrlib.tests.test_ftp_transport',
 
3498
                   'bzrlib.tests.test_foreign',
 
3499
                   'bzrlib.tests.test_generate_docs',
 
3500
                   'bzrlib.tests.test_generate_ids',
 
3501
                   'bzrlib.tests.test_globbing',
 
3502
                   'bzrlib.tests.test_gpg',
 
3503
                   'bzrlib.tests.test_graph',
 
3504
                   'bzrlib.tests.test_groupcompress',
 
3505
                   'bzrlib.tests.test_hashcache',
 
3506
                   'bzrlib.tests.test_help',
 
3507
                   'bzrlib.tests.test_hooks',
 
3508
                   'bzrlib.tests.test_http',
 
3509
                   'bzrlib.tests.test_http_response',
 
3510
                   'bzrlib.tests.test_https_ca_bundle',
 
3511
                   'bzrlib.tests.test_identitymap',
 
3512
                   'bzrlib.tests.test_ignores',
 
3513
                   'bzrlib.tests.test_index',
 
3514
                   'bzrlib.tests.test_info',
 
3515
                   'bzrlib.tests.test_inv',
 
3516
                   'bzrlib.tests.test_inventory_delta',
 
3517
                   'bzrlib.tests.test_knit',
 
3518
                   'bzrlib.tests.test_lazy_import',
 
3519
                   'bzrlib.tests.test_lazy_regex',
 
3520
                   'bzrlib.tests.test_lock',
 
3521
                   'bzrlib.tests.test_lockable_files',
 
3522
                   'bzrlib.tests.test_lockdir',
 
3523
                   'bzrlib.tests.test_log',
 
3524
                   'bzrlib.tests.test_lru_cache',
 
3525
                   'bzrlib.tests.test_lsprof',
 
3526
                   'bzrlib.tests.test_mail_client',
 
3527
                   'bzrlib.tests.test_memorytree',
 
3528
                   'bzrlib.tests.test_merge',
 
3529
                   'bzrlib.tests.test_merge3',
 
3530
                   'bzrlib.tests.test_merge_core',
 
3531
                   'bzrlib.tests.test_merge_directive',
 
3532
                   'bzrlib.tests.test_missing',
 
3533
                   'bzrlib.tests.test_msgeditor',
 
3534
                   'bzrlib.tests.test_multiparent',
 
3535
                   'bzrlib.tests.test_mutabletree',
 
3536
                   'bzrlib.tests.test_nonascii',
 
3537
                   'bzrlib.tests.test_options',
 
3538
                   'bzrlib.tests.test_osutils',
 
3539
                   'bzrlib.tests.test_osutils_encodings',
 
3540
                   'bzrlib.tests.test_pack',
 
3541
                   'bzrlib.tests.test_patch',
 
3542
                   'bzrlib.tests.test_patches',
 
3543
                   'bzrlib.tests.test_permissions',
 
3544
                   'bzrlib.tests.test_plugins',
 
3545
                   'bzrlib.tests.test_progress',
 
3546
                   'bzrlib.tests.test_read_bundle',
 
3547
                   'bzrlib.tests.test_reconcile',
 
3548
                   'bzrlib.tests.test_reconfigure',
 
3549
                   'bzrlib.tests.test_registry',
 
3550
                   'bzrlib.tests.test_remote',
 
3551
                   'bzrlib.tests.test_rename_map',
 
3552
                   'bzrlib.tests.test_repository',
 
3553
                   'bzrlib.tests.test_revert',
 
3554
                   'bzrlib.tests.test_revision',
 
3555
                   'bzrlib.tests.test_revisionspec',
 
3556
                   'bzrlib.tests.test_revisiontree',
 
3557
                   'bzrlib.tests.test_rio',
 
3558
                   'bzrlib.tests.test_rules',
 
3559
                   'bzrlib.tests.test_sampler',
 
3560
                   'bzrlib.tests.test_selftest',
 
3561
                   'bzrlib.tests.test_serializer',
 
3562
                   'bzrlib.tests.test_setup',
 
3563
                   'bzrlib.tests.test_sftp_transport',
 
3564
                   'bzrlib.tests.test_shelf',
 
3565
                   'bzrlib.tests.test_shelf_ui',
 
3566
                   'bzrlib.tests.test_smart',
 
3567
                   'bzrlib.tests.test_smart_add',
 
3568
                   'bzrlib.tests.test_smart_request',
 
3569
                   'bzrlib.tests.test_smart_transport',
 
3570
                   'bzrlib.tests.test_smtp_connection',
 
3571
                   'bzrlib.tests.test_source',
 
3572
                   'bzrlib.tests.test_ssh_transport',
 
3573
                   'bzrlib.tests.test_status',
 
3574
                   'bzrlib.tests.test_store',
 
3575
                   'bzrlib.tests.test_strace',
 
3576
                   'bzrlib.tests.test_subsume',
 
3577
                   'bzrlib.tests.test_switch',
 
3578
                   'bzrlib.tests.test_symbol_versioning',
 
3579
                   'bzrlib.tests.test_tag',
 
3580
                   'bzrlib.tests.test_testament',
 
3581
                   'bzrlib.tests.test_textfile',
 
3582
                   'bzrlib.tests.test_textmerge',
 
3583
                   'bzrlib.tests.test_timestamp',
 
3584
                   'bzrlib.tests.test_trace',
 
3585
                   'bzrlib.tests.test_transactions',
 
3586
                   'bzrlib.tests.test_transform',
 
3587
                   'bzrlib.tests.test_transport',
 
3588
                   'bzrlib.tests.test_transport_log',
 
3589
                   'bzrlib.tests.test_tree',
 
3590
                   'bzrlib.tests.test_treebuilder',
 
3591
                   'bzrlib.tests.test_tsort',
 
3592
                   'bzrlib.tests.test_tuned_gzip',
 
3593
                   'bzrlib.tests.test_ui',
 
3594
                   'bzrlib.tests.test_uncommit',
 
3595
                   'bzrlib.tests.test_upgrade',
 
3596
                   'bzrlib.tests.test_upgrade_stacked',
 
3597
                   'bzrlib.tests.test_urlutils',
 
3598
                   'bzrlib.tests.test_version',
 
3599
                   'bzrlib.tests.test_version_info',
 
3600
                   'bzrlib.tests.test_weave',
 
3601
                   'bzrlib.tests.test_whitebox',
 
3602
                   'bzrlib.tests.test_win32utils',
 
3603
                   'bzrlib.tests.test_workingtree',
 
3604
                   'bzrlib.tests.test_workingtree_4',
 
3605
                   'bzrlib.tests.test_wsgi',
 
3606
                   'bzrlib.tests.test_xml',
 
3607
                   ]
3799
3608
 
3800
3609
    loader = TestUtil.TestLoader()
3801
3610
 
3830
3639
    suite = loader.suiteClass()
3831
3640
 
3832
3641
    # modules building their suite with loadTestsFromModuleNames
3833
 
    suite.addTest(loader.loadTestsFromModuleNames(_test_suite_testmod_names()))
3834
 
 
3835
 
    for mod in _test_suite_modules_to_doctest():
 
3642
    suite.addTest(loader.loadTestsFromModuleNames(testmod_names))
 
3643
 
 
3644
    modules_to_doctest = [
 
3645
        'bzrlib',
 
3646
        'bzrlib.branchbuilder',
 
3647
        'bzrlib.export',
 
3648
        'bzrlib.inventory',
 
3649
        'bzrlib.iterablefile',
 
3650
        'bzrlib.lockdir',
 
3651
        'bzrlib.merge3',
 
3652
        'bzrlib.option',
 
3653
        'bzrlib.symbol_versioning',
 
3654
        'bzrlib.tests',
 
3655
        'bzrlib.timestamp',
 
3656
        'bzrlib.version_info_formats.format_custom',
 
3657
        ]
 
3658
 
 
3659
    for mod in modules_to_doctest:
3836
3660
        if not interesting_module(mod):
3837
3661
            # No tests to keep here, move along
3838
3662
            continue
3979
3803
    :param new_id: The id to assign to it.
3980
3804
    :return: The new test.
3981
3805
    """
3982
 
    new_test = copy(test)
 
3806
    from copy import deepcopy
 
3807
    new_test = deepcopy(test)
3983
3808
    new_test.id = lambda: new_id
3984
3809
    return new_test
3985
3810
 
3986
3811
 
3987
 
def permute_tests_for_extension(standard_tests, loader, py_module_name,
3988
 
                                ext_module_name):
3989
 
    """Helper for permutating tests against an extension module.
3990
 
 
3991
 
    This is meant to be used inside a modules 'load_tests()' function. It will
3992
 
    create 2 scenarios, and cause all tests in the 'standard_tests' to be run
3993
 
    against both implementations. Setting 'test.module' to the appropriate
3994
 
    module. See bzrlib.tests.test__chk_map.load_tests as an example.
3995
 
 
3996
 
    :param standard_tests: A test suite to permute
3997
 
    :param loader: A TestLoader
3998
 
    :param py_module_name: The python path to a python module that can always
3999
 
        be loaded, and will be considered the 'python' implementation. (eg
4000
 
        'bzrlib._chk_map_py')
4001
 
    :param ext_module_name: The python path to an extension module. If the
4002
 
        module cannot be loaded, a single test will be added, which notes that
4003
 
        the module is not available. If it can be loaded, all standard_tests
4004
 
        will be run against that module.
4005
 
    :return: (suite, feature) suite is a test-suite that has all the permuted
4006
 
        tests. feature is the Feature object that can be used to determine if
4007
 
        the module is available.
4008
 
    """
4009
 
 
4010
 
    py_module = __import__(py_module_name, {}, {}, ['NO_SUCH_ATTRIB'])
4011
 
    scenarios = [
4012
 
        ('python', {'module': py_module}),
4013
 
    ]
4014
 
    suite = loader.suiteClass()
4015
 
    feature = ModuleAvailableFeature(ext_module_name)
4016
 
    if feature.available():
4017
 
        scenarios.append(('C', {'module': feature.module}))
4018
 
    else:
4019
 
        # the compiled module isn't available, so we add a failing test
4020
 
        class FailWithoutFeature(TestCase):
4021
 
            def test_fail(self):
4022
 
                self.requireFeature(feature)
4023
 
        suite.addTest(loader.loadTestsFromTestCase(FailWithoutFeature))
4024
 
    result = multiply_tests(standard_tests, scenarios, suite)
4025
 
    return result, feature
4026
 
 
4027
 
 
4028
 
def _rmtree_temp_dir(dirname, test_id=None):
 
3812
def _rmtree_temp_dir(dirname):
4029
3813
    # If LANG=C we probably have created some bogus paths
4030
3814
    # which rmtree(unicode) will fail to delete
4031
3815
    # so make sure we are using rmtree(str) to delete everything
4043
3827
        # We don't want to fail here because some useful display will be lost
4044
3828
        # otherwise. Polluting the tmp dir is bad, but not giving all the
4045
3829
        # possible info to the test runner is even worse.
4046
 
        if test_id != None:
4047
 
            ui.ui_factory.clear_term()
4048
 
            sys.stderr.write('\nWhile running: %s\n' % (test_id,))
4049
3830
        sys.stderr.write('Unable to remove testing dir %s\n%s'
4050
3831
                         % (os.path.basename(dirname), e))
4051
3832
 
4135
3916
UnicodeFilenameFeature = _UnicodeFilenameFeature()
4136
3917
 
4137
3918
 
4138
 
class _CompatabilityThunkFeature(Feature):
4139
 
    """This feature is just a thunk to another feature.
4140
 
 
4141
 
    It issues a deprecation warning if it is accessed, to let you know that you
4142
 
    should really use a different feature.
4143
 
    """
4144
 
 
4145
 
    def __init__(self, dep_version, module, name,
4146
 
                 replacement_name, replacement_module=None):
4147
 
        super(_CompatabilityThunkFeature, self).__init__()
4148
 
        self._module = module
4149
 
        if replacement_module is None:
4150
 
            replacement_module = module
4151
 
        self._replacement_module = replacement_module
4152
 
        self._name = name
4153
 
        self._replacement_name = replacement_name
4154
 
        self._dep_version = dep_version
4155
 
        self._feature = None
4156
 
 
4157
 
    def _ensure(self):
4158
 
        if self._feature is None:
4159
 
            depr_msg = self._dep_version % ('%s.%s'
4160
 
                                            % (self._module, self._name))
4161
 
            use_msg = ' Use %s.%s instead.' % (self._replacement_module,
4162
 
                                               self._replacement_name)
4163
 
            symbol_versioning.warn(depr_msg + use_msg, DeprecationWarning)
4164
 
            # Import the new feature and use it as a replacement for the
4165
 
            # deprecated one.
4166
 
            mod = __import__(self._replacement_module, {}, {},
4167
 
                             [self._replacement_name])
4168
 
            self._feature = getattr(mod, self._replacement_name)
4169
 
 
4170
 
    def _probe(self):
4171
 
        self._ensure()
4172
 
        return self._feature._probe()
4173
 
 
4174
 
 
4175
 
class ModuleAvailableFeature(Feature):
4176
 
    """This is a feature than describes a module we want to be available.
4177
 
 
4178
 
    Declare the name of the module in __init__(), and then after probing, the
4179
 
    module will be available as 'self.module'.
4180
 
 
4181
 
    :ivar module: The module if it is available, else None.
4182
 
    """
4183
 
 
4184
 
    def __init__(self, module_name):
4185
 
        super(ModuleAvailableFeature, self).__init__()
4186
 
        self.module_name = module_name
4187
 
 
4188
 
    def _probe(self):
4189
 
        try:
4190
 
            self._module = __import__(self.module_name, {}, {}, [''])
4191
 
            return True
4192
 
        except ImportError:
4193
 
            return False
4194
 
 
4195
 
    @property
4196
 
    def module(self):
4197
 
        if self.available(): # Make sure the probe has been done
4198
 
            return self._module
4199
 
        return None
4200
 
 
4201
 
    def feature_name(self):
4202
 
        return self.module_name
4203
 
 
4204
 
 
4205
 
# This is kept here for compatibility, it is recommended to use
4206
 
# 'bzrlib.tests.feature.paramiko' instead
4207
 
ParamikoFeature = _CompatabilityThunkFeature(
4208
 
    deprecated_in((2,1,0)),
4209
 
    'bzrlib.tests.features', 'ParamikoFeature', 'paramiko')
4210
 
 
4211
 
 
4212
3919
def probe_unicode_in_user_encoding():
4213
3920
    """Try to encode several unicode strings to use in unicode-aware tests.
4214
3921
    Return first successfull match.
4294
4001
UTF8Filesystem = _UTF8Filesystem()
4295
4002
 
4296
4003
 
4297
 
class _BreakinFeature(Feature):
4298
 
    """Does this platform support the breakin feature?"""
4299
 
 
4300
 
    def _probe(self):
4301
 
        from bzrlib import breakin
4302
 
        if breakin.determine_signal() is None:
4303
 
            return False
4304
 
        if sys.platform == 'win32':
4305
 
            # Windows doesn't have os.kill, and we catch the SIGBREAK signal.
4306
 
            # We trigger SIGBREAK via a Console api so we need ctypes to
4307
 
            # access the function
4308
 
            try:
4309
 
                import ctypes
4310
 
            except OSError:
4311
 
                return False
4312
 
        return True
4313
 
 
4314
 
    def feature_name(self):
4315
 
        return "SIGQUIT or SIGBREAK w/ctypes on win32"
4316
 
 
4317
 
 
4318
 
BreakinFeature = _BreakinFeature()
4319
 
 
4320
 
 
4321
4004
class _CaseInsCasePresFilenameFeature(Feature):
4322
4005
    """Is the file-system case insensitive, but case-preserving?"""
4323
4006
 
4373
4056
CaseInsensitiveFilesystemFeature = _CaseInsensitiveFilesystemFeature()
4374
4057
 
4375
4058
 
4376
 
class _CaseSensitiveFilesystemFeature(Feature):
 
4059
class _SubUnitFeature(Feature):
 
4060
    """Check if subunit is available."""
4377
4061
 
4378
4062
    def _probe(self):
4379
 
        if CaseInsCasePresFilenameFeature.available():
4380
 
            return False
4381
 
        elif CaseInsensitiveFilesystemFeature.available():
4382
 
            return False
4383
 
        else:
 
4063
        try:
 
4064
            import subunit
4384
4065
            return True
 
4066
        except ImportError:
 
4067
            return False
4385
4068
 
4386
4069
    def feature_name(self):
4387
 
        return 'case-sensitive filesystem'
4388
 
 
4389
 
# new coding style is for feature instances to be lowercase
4390
 
case_sensitive_filesystem_feature = _CaseSensitiveFilesystemFeature()
4391
 
 
4392
 
 
4393
 
# Kept for compatibility, use bzrlib.tests.features.subunit instead
4394
 
SubUnitFeature = _CompatabilityThunkFeature(
4395
 
    deprecated_in((2,1,0)),
4396
 
    'bzrlib.tests.features', 'SubUnitFeature', 'subunit')
 
4070
        return 'subunit'
 
4071
 
 
4072
SubUnitFeature = _SubUnitFeature()
4397
4073
# Only define SubUnitBzrRunner if subunit is available.
4398
4074
try:
4399
4075
    from subunit import TestProtocolClient
4400
 
    from subunit.test_results import AutoTimingTestResultDecorator
 
4076
    try:
 
4077
        from subunit.test_results import AutoTimingTestResultDecorator
 
4078
    except ImportError:
 
4079
        AutoTimingTestResultDecorator = lambda x:x
4401
4080
    class SubUnitBzrRunner(TextTestRunner):
4402
4081
        def run(self, test):
4403
4082
            result = AutoTimingTestResultDecorator(