← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/__init__.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2010-09-01 08:02:42 UTC
  • mfrom: (5390.3.3 faster-revert-593560)
  • Revision ID: pqm@pqm.ubuntu.com-20100901080242-esg62ody4frwmy66
(spiv) Avoid repeatedly calling self.target.all_file_ids() in
 InterTree.iter_changes. (Andrew Bennetts)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/__init__.py
1
 
# Copyright (C) 2005, 2006, 2007, 2008, 2009 Canonical Ltd
 
1
# Copyright (C) 2005-2010 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
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
 
17
"""Testing framework extensions"""
17
18
 
18
19
# TODO: Perhaps there should be an API to find out if bzr running under the
19
20
# test suite -- some plugins might want to avoid making intrusive changes if
28
29
 
29
30
import atexit
30
31
import codecs
 
32
import copy
31
33
from cStringIO import StringIO
32
34
import difflib
33
35
import doctest
34
36
import errno
 
37
import itertools
35
38
import logging
 
39
import math
36
40
import os
37
 
from pprint import pformat
 
41
import pprint
38
42
import random
39
43
import re
40
44
import shlex
41
45
import stat
42
 
from subprocess import Popen, PIPE
 
46
import subprocess
43
47
import sys
44
48
import tempfile
45
49
import threading
46
50
import time
 
51
import traceback
47
52
import unittest
48
53
import warnings
49
54
 
 
55
import testtools
 
56
# nb: check this before importing anything else from within it
 
57
_testtools_version = getattr(testtools, '__version__', ())
 
58
if _testtools_version < (0, 9, 2):
 
59
    raise ImportError("need at least testtools 0.9.2: %s is %r"
 
60
        % (testtools.__file__, _testtools_version))
 
61
from testtools import content
50
62
 
51
63
from bzrlib import (
52
64
    branchbuilder,
53
65
    bzrdir,
 
66
    chk_map,
 
67
    config,
54
68
    debug,
55
69
    errors,
56
70
    hooks,
 
71
    lock as _mod_lock,
57
72
    memorytree,
58
73
    osutils,
59
74
    progress,
60
75
    ui,
61
76
    urlutils,
62
77
    registry,
 
78
    transport as _mod_transport,
63
79
    workingtree,
64
80
    )
65
81
import bzrlib.branch
83
99
from bzrlib.symbol_versioning import (
84
100
    DEPRECATED_PARAMETER,
85
101
    deprecated_function,
 
102
    deprecated_in,
86
103
    deprecated_method,
87
104
    deprecated_passed,
88
105
    )
89
106
import bzrlib.trace
90
 
from bzrlib.transport import get_transport
91
 
import bzrlib.transport
92
 
from bzrlib.transport.local import LocalURLServer
93
 
from bzrlib.transport.memory import MemoryServer
94
 
from bzrlib.transport.readonly import ReadonlyServer
 
107
from bzrlib.transport import (
 
108
    memory,
 
109
    pathfilter,
 
110
    )
95
111
from bzrlib.trace import mutter, note
96
 
from bzrlib.tests import TestUtil
97
 
from bzrlib.tests.http_server import HttpServer
98
 
from bzrlib.tests.TestUtil import (
99
 
                          TestSuite,
100
 
                          TestLoader,
101
 
                          )
102
 
from bzrlib.tests.treeshape import build_tree_contents
 
112
from bzrlib.tests import (
 
113
    test_server,
 
114
    TestUtil,
 
115
    treeshape,
 
116
    )
 
117
from bzrlib.ui import NullProgressView
 
118
from bzrlib.ui.text import TextUIFactory
103
119
import bzrlib.version_info_formats.format_custom
104
120
from bzrlib.workingtree import WorkingTree, WorkingTreeFormat2
105
121
 
108
124
# shown frame is the test code, not our assertXYZ.
109
125
__unittest = 1
110
126
 
111
 
default_transport = LocalURLServer
112
 
 
113
 
 
114
 
class ExtendedTestResult(unittest._TextTestResult):
 
127
default_transport = test_server.LocalURLServer
 
128
 
 
129
 
 
130
_unitialized_attr = object()
 
131
"""A sentinel needed to act as a default value in a method signature."""
 
132
 
 
133
 
 
134
# Subunit result codes, defined here to prevent a hard dependency on subunit.
 
135
SUBUNIT_SEEK_SET = 0
 
136
SUBUNIT_SEEK_CUR = 1
 
137
 
 
138
 
 
139
class ExtendedTestResult(testtools.TextTestResult):
115
140
    """Accepts, reports and accumulates the results of running tests.
116
141
 
117
142
    Compared to the unittest version this class adds support for
131
156
 
132
157
    def __init__(self, stream, descriptions, verbosity,
133
158
                 bench_history=None,
134
 
                 num_tests=None,
 
159
                 strict=False,
135
160
                 ):
136
161
        """Construct new TestResult.
137
162
 
138
163
        :param bench_history: Optionally, a writable file object to accumulate
139
164
            benchmark results.
140
165
        """
141
 
        unittest._TextTestResult.__init__(self, stream, descriptions, verbosity)
 
166
        testtools.TextTestResult.__init__(self, stream)
142
167
        if bench_history is not None:
143
168
            from bzrlib.version import _get_bzr_source_tree
144
169
            src_tree = _get_bzr_source_tree()
155
180
            bench_history.write("--date %s %s\n" % (time.time(), revision_id))
156
181
        self._bench_history = bench_history
157
182
        self.ui = ui.ui_factory
158
 
        self.num_tests = num_tests
 
183
        self.num_tests = 0
159
184
        self.error_count = 0
160
185
        self.failure_count = 0
161
186
        self.known_failure_count = 0
164
189
        self.unsupported = {}
165
190
        self.count = 0
166
191
        self._overall_start_time = time.time()
167
 
 
168
 
    def _extractBenchmarkTime(self, testCase):
 
192
        self._strict = strict
 
193
 
 
194
    def stopTestRun(self):
 
195
        run = self.testsRun
 
196
        actionTaken = "Ran"
 
197
        stopTime = time.time()
 
198
        timeTaken = stopTime - self.startTime
 
199
        # GZ 2010-07-19: Seems testtools has no printErrors method, and though
 
200
        #                the parent class method is similar have to duplicate
 
201
        self._show_list('ERROR', self.errors)
 
202
        self._show_list('FAIL', self.failures)
 
203
        self.stream.write(self.sep2)
 
204
        self.stream.write("%s %d test%s in %.3fs\n\n" % (actionTaken,
 
205
                            run, run != 1 and "s" or "", timeTaken))
 
206
        if not self.wasSuccessful():
 
207
            self.stream.write("FAILED (")
 
208
            failed, errored = map(len, (self.failures, self.errors))
 
209
            if failed:
 
210
                self.stream.write("failures=%d" % failed)
 
211
            if errored:
 
212
                if failed: self.stream.write(", ")
 
213
                self.stream.write("errors=%d" % errored)
 
214
            if self.known_failure_count:
 
215
                if failed or errored: self.stream.write(", ")
 
216
                self.stream.write("known_failure_count=%d" %
 
217
                    self.known_failure_count)
 
218
            self.stream.write(")\n")
 
219
        else:
 
220
            if self.known_failure_count:
 
221
                self.stream.write("OK (known_failures=%d)\n" %
 
222
                    self.known_failure_count)
 
223
            else:
 
224
                self.stream.write("OK\n")
 
225
        if self.skip_count > 0:
 
226
            skipped = self.skip_count
 
227
            self.stream.write('%d test%s skipped\n' %
 
228
                                (skipped, skipped != 1 and "s" or ""))
 
229
        if self.unsupported:
 
230
            for feature, count in sorted(self.unsupported.items()):
 
231
                self.stream.write("Missing feature '%s' skipped %d tests.\n" %
 
232
                    (feature, count))
 
233
        if self._strict:
 
234
            ok = self.wasStrictlySuccessful()
 
235
        else:
 
236
            ok = self.wasSuccessful()
 
237
        if TestCase._first_thread_leaker_id:
 
238
            self.stream.write(
 
239
                '%s is leaking threads among %d leaking tests.\n' % (
 
240
                TestCase._first_thread_leaker_id,
 
241
                TestCase._leaking_threads_tests))
 
242
            # We don't report the main thread as an active one.
 
243
            self.stream.write(
 
244
                '%d non-main threads were left active in the end.\n'
 
245
                % (TestCase._active_threads - 1))
 
246
 
 
247
    def getDescription(self, test):
 
248
        return test.id()
 
249
 
 
250
    def _extractBenchmarkTime(self, testCase, details=None):
169
251
        """Add a benchmark time for the current test case."""
 
252
        if details and 'benchtime' in details:
 
253
            return float(''.join(details['benchtime'].iter_bytes()))
170
254
        return getattr(testCase, "_benchtime", None)
171
255
 
172
256
    def _elapsedTestTimeString(self):
176
260
    def _testTimeString(self, testCase):
177
261
        benchmark_time = self._extractBenchmarkTime(testCase)
178
262
        if benchmark_time is not None:
179
 
            return "%s/%s" % (
180
 
                self._formatTime(benchmark_time),
181
 
                self._elapsedTestTimeString())
 
263
            return self._formatTime(benchmark_time) + "*"
182
264
        else:
183
 
            return "           %s" % self._elapsedTestTimeString()
 
265
            return self._elapsedTestTimeString()
184
266
 
185
267
    def _formatTime(self, seconds):
186
268
        """Format seconds as milliseconds with leading spaces."""
190
272
 
191
273
    def _shortened_test_description(self, test):
192
274
        what = test.id()
193
 
        what = re.sub(r'^bzrlib\.(tests|benchmarks)\.', '', what)
 
275
        what = re.sub(r'^bzrlib\.tests\.', '', what)
194
276
        return what
195
277
 
196
278
    def startTest(self, test):
197
 
        unittest.TestResult.startTest(self, test)
 
279
        super(ExtendedTestResult, self).startTest(test)
 
280
        if self.count == 0:
 
281
            self.startTests()
198
282
        self.report_test_start(test)
199
283
        test.number = self.count
200
284
        self._recordTestStartTime()
201
285
 
 
286
    def startTests(self):
 
287
        import platform
 
288
        if getattr(sys, 'frozen', None) is None:
 
289
            bzr_path = osutils.realpath(sys.argv[0])
 
290
        else:
 
291
            bzr_path = sys.executable
 
292
        self.stream.write(
 
293
            'bzr selftest: %s\n' % (bzr_path,))
 
294
        self.stream.write(
 
295
            '   %s\n' % (
 
296
                    bzrlib.__path__[0],))
 
297
        self.stream.write(
 
298
            '   bzr-%s python-%s %s\n' % (
 
299
                    bzrlib.version_string,
 
300
                    bzrlib._format_version_tuple(sys.version_info),
 
301
                    platform.platform(aliased=1),
 
302
                    ))
 
303
        self.stream.write('\n')
 
304
 
202
305
    def _recordTestStartTime(self):
203
306
        """Record that a test has started."""
204
307
        self._start_time = time.time()
216
319
        Called from the TestCase run() method when the test
217
320
        fails with an unexpected error.
218
321
        """
219
 
        self._testConcluded(test)
220
 
        if isinstance(err[1], TestNotApplicable):
221
 
            return self._addNotApplicable(test, err)
222
 
        elif isinstance(err[1], UnavailableFeature):
223
 
            return self.addNotSupported(test, err[1].args[0])
224
 
        else:
225
 
            unittest.TestResult.addError(self, test, err)
226
 
            self.error_count += 1
227
 
            self.report_error(test, err)
228
 
            if self.stop_early:
229
 
                self.stop()
230
 
            self._cleanupLogFile(test)
 
322
        self._post_mortem()
 
323
        super(ExtendedTestResult, self).addError(test, err)
 
324
        self.error_count += 1
 
325
        self.report_error(test, err)
 
326
        if self.stop_early:
 
327
            self.stop()
 
328
        self._cleanupLogFile(test)
231
329
 
232
330
    def addFailure(self, test, err):
233
331
        """Tell result that test failed.
235
333
        Called from the TestCase run() method when the test
236
334
        fails because e.g. an assert() method failed.
237
335
        """
238
 
        self._testConcluded(test)
239
 
        if isinstance(err[1], KnownFailure):
240
 
            return self._addKnownFailure(test, err)
241
 
        else:
242
 
            unittest.TestResult.addFailure(self, test, err)
243
 
            self.failure_count += 1
244
 
            self.report_failure(test, err)
245
 
            if self.stop_early:
246
 
                self.stop()
247
 
            self._cleanupLogFile(test)
 
336
        self._post_mortem()
 
337
        super(ExtendedTestResult, self).addFailure(test, err)
 
338
        self.failure_count += 1
 
339
        self.report_failure(test, err)
 
340
        if self.stop_early:
 
341
            self.stop()
 
342
        self._cleanupLogFile(test)
248
343
 
249
 
    def addSuccess(self, test):
 
344
    def addSuccess(self, test, details=None):
250
345
        """Tell result that test completed successfully.
251
346
 
252
347
        Called from the TestCase run()
253
348
        """
254
 
        self._testConcluded(test)
255
349
        if self._bench_history is not None:
256
 
            benchmark_time = self._extractBenchmarkTime(test)
 
350
            benchmark_time = self._extractBenchmarkTime(test, details)
257
351
            if benchmark_time is not None:
258
352
                self._bench_history.write("%s %s\n" % (
259
353
                    self._formatTime(benchmark_time),
260
354
                    test.id()))
261
355
        self.report_success(test)
262
356
        self._cleanupLogFile(test)
263
 
        unittest.TestResult.addSuccess(self, test)
 
357
        super(ExtendedTestResult, self).addSuccess(test)
264
358
        test._log_contents = ''
265
359
 
266
 
    def _testConcluded(self, test):
267
 
        """Common code when a test has finished.
268
 
 
269
 
        Called regardless of whether it succeded, failed, etc.
270
 
        """
271
 
        pass
272
 
 
273
 
    def _addKnownFailure(self, test, err):
 
360
    def addExpectedFailure(self, test, err):
274
361
        self.known_failure_count += 1
275
362
        self.report_known_failure(test, err)
276
363
 
278
365
        """The test will not be run because of a missing feature.
279
366
        """
280
367
        # this can be called in two different ways: it may be that the
281
 
        # test started running, and then raised (through addError)
 
368
        # test started running, and then raised (through requireFeature)
282
369
        # UnavailableFeature.  Alternatively this method can be called
283
 
        # while probing for features before running the tests; in that
284
 
        # case we will see startTest and stopTest, but the test will never
285
 
        # actually run.
 
370
        # while probing for features before running the test code proper; in
 
371
        # that case we will see startTest and stopTest, but the test will
 
372
        # never actually run.
286
373
        self.unsupported.setdefault(str(feature), 0)
287
374
        self.unsupported[str(feature)] += 1
288
375
        self.report_unsupported(test, feature)
292
379
        self.skip_count += 1
293
380
        self.report_skip(test, reason)
294
381
 
295
 
    def _addNotApplicable(self, test, skip_excinfo):
296
 
        if isinstance(skip_excinfo[1], TestNotApplicable):
297
 
            self.not_applicable_count += 1
298
 
            self.report_not_applicable(test, skip_excinfo)
299
 
        try:
300
 
            test.tearDown()
301
 
        except KeyboardInterrupt:
302
 
            raise
303
 
        except:
304
 
            self.addError(test, test.exc_info())
 
382
    def addNotApplicable(self, test, reason):
 
383
        self.not_applicable_count += 1
 
384
        self.report_not_applicable(test, reason)
 
385
 
 
386
    def _post_mortem(self):
 
387
        """Start a PDB post mortem session."""
 
388
        if os.environ.get('BZR_TEST_PDB', None):
 
389
            import pdb;pdb.post_mortem()
 
390
 
 
391
    def progress(self, offset, whence):
 
392
        """The test is adjusting the count of tests to run."""
 
393
        if whence == SUBUNIT_SEEK_SET:
 
394
            self.num_tests = offset
 
395
        elif whence == SUBUNIT_SEEK_CUR:
 
396
            self.num_tests += offset
305
397
        else:
306
 
            # seems best to treat this as success from point-of-view of unittest
307
 
            # -- it actually does nothing so it barely matters :)
308
 
            unittest.TestResult.addSuccess(self, test)
309
 
            test._log_contents = ''
310
 
 
311
 
    def printErrorList(self, flavour, errors):
312
 
        for test, err in errors:
313
 
            self.stream.writeln(self.separator1)
314
 
            self.stream.write("%s: " % flavour)
315
 
            self.stream.writeln(self.getDescription(test))
316
 
            if getattr(test, '_get_log', None) is not None:
317
 
                self.stream.write('\n')
318
 
                self.stream.write(
319
 
                        ('vvvv[log from %s]' % test.id()).ljust(78,'-'))
320
 
                self.stream.write('\n')
321
 
                self.stream.write(test._get_log())
322
 
                self.stream.write('\n')
323
 
                self.stream.write(
324
 
                        ('^^^^[log from %s]' % test.id()).ljust(78,'-'))
325
 
                self.stream.write('\n')
326
 
            self.stream.writeln(self.separator2)
327
 
            self.stream.writeln("%s" % err)
328
 
 
329
 
    def finished(self):
330
 
        pass
 
398
            raise errors.BzrError("Unknown whence %r" % whence)
331
399
 
332
400
    def report_cleaning_up(self):
333
401
        pass
334
402
 
 
403
    def startTestRun(self):
 
404
        self.startTime = time.time()
 
405
 
335
406
    def report_success(self, test):
336
407
        pass
337
408
 
346
417
 
347
418
    def __init__(self, stream, descriptions, verbosity,
348
419
                 bench_history=None,
349
 
                 num_tests=None,
350
420
                 pb=None,
 
421
                 strict=None,
351
422
                 ):
352
423
        ExtendedTestResult.__init__(self, stream, descriptions, verbosity,
353
 
            bench_history, num_tests)
354
 
        if pb is None:
355
 
            self.pb = self.ui.nested_progress_bar()
356
 
            self._supplied_pb = False
357
 
        else:
358
 
            self.pb = pb
359
 
            self._supplied_pb = True
 
424
            bench_history, strict)
 
425
        # We no longer pass them around, but just rely on the UIFactory stack
 
426
        # for state
 
427
        if pb is not None:
 
428
            warnings.warn("Passing pb to TextTestResult is deprecated")
 
429
        self.pb = self.ui.nested_progress_bar()
360
430
        self.pb.show_pct = False
361
431
        self.pb.show_spinner = False
362
432
        self.pb.show_eta = False,
363
433
        self.pb.show_count = False
364
434
        self.pb.show_bar = False
365
 
 
366
 
    def report_starting(self):
 
435
        self.pb.update_latency = 0
 
436
        self.pb.show_transport_activity = False
 
437
 
 
438
    def stopTestRun(self):
 
439
        # called when the tests that are going to run have run
 
440
        self.pb.clear()
 
441
        self.pb.finished()
 
442
        super(TextTestResult, self).stopTestRun()
 
443
 
 
444
    def startTestRun(self):
 
445
        super(TextTestResult, self).startTestRun()
367
446
        self.pb.update('[test 0/%d] Starting' % (self.num_tests))
368
447
 
 
448
    def printErrors(self):
 
449
        # clear the pb to make room for the error listing
 
450
        self.pb.clear()
 
451
        super(TextTestResult, self).printErrors()
 
452
 
369
453
    def _progress_prefix_text(self):
370
454
        # the longer this text, the less space we have to show the test
371
455
        # name...
376
460
        ##     a += ', %d skip' % self.skip_count
377
461
        ## if self.known_failure_count:
378
462
        ##     a += '+%dX' % self.known_failure_count
379
 
        if self.num_tests is not None:
 
463
        if self.num_tests:
380
464
            a +='/%d' % self.num_tests
381
465
        a += ' in '
382
466
        runtime = time.time() - self._overall_start_time
384
468
            a += '%dm%ds' % (runtime / 60, runtime % 60)
385
469
        else:
386
470
            a += '%ds' % runtime
387
 
        if self.error_count:
388
 
            a += ', %d err' % self.error_count
389
 
        if self.failure_count:
390
 
            a += ', %d fail' % self.failure_count
391
 
        if self.unsupported:
392
 
            a += ', %d missing' % len(self.unsupported)
 
471
        total_fail_count = self.error_count + self.failure_count
 
472
        if total_fail_count:
 
473
            a += ', %d failed' % total_fail_count
 
474
        # if self.unsupported:
 
475
        #     a += ', %d missing' % len(self.unsupported)
393
476
        a += ']'
394
477
        return a
395
478
 
404
487
        return self._shortened_test_description(test)
405
488
 
406
489
    def report_error(self, test, err):
407
 
        self.pb.note('ERROR: %s\n    %s\n',
 
490
        self.stream.write('ERROR: %s\n    %s\n' % (
408
491
            self._test_description(test),
409
492
            err[1],
410
 
            )
 
493
            ))
411
494
 
412
495
    def report_failure(self, test, err):
413
 
        self.pb.note('FAIL: %s\n    %s\n',
 
496
        self.stream.write('FAIL: %s\n    %s\n' % (
414
497
            self._test_description(test),
415
498
            err[1],
416
 
            )
 
499
            ))
417
500
 
418
501
    def report_known_failure(self, test, err):
419
 
        self.pb.note('XFAIL: %s\n%s\n',
420
 
            self._test_description(test), err[1])
 
502
        pass
421
503
 
422
504
    def report_skip(self, test, reason):
423
505
        pass
424
506
 
425
 
    def report_not_applicable(self, test, skip_excinfo):
 
507
    def report_not_applicable(self, test, reason):
426
508
        pass
427
509
 
428
510
    def report_unsupported(self, test, feature):
431
513
    def report_cleaning_up(self):
432
514
        self.pb.update('Cleaning up')
433
515
 
434
 
    def finished(self):
435
 
        if not self._supplied_pb:
436
 
            self.pb.finished()
437
 
 
438
516
 
439
517
class VerboseTestResult(ExtendedTestResult):
440
518
    """Produce long output, with one line per test run plus times"""
447
525
            result = a_string
448
526
        return result.ljust(final_width)
449
527
 
450
 
    def report_starting(self):
 
528
    def startTestRun(self):
 
529
        super(VerboseTestResult, self).startTestRun()
451
530
        self.stream.write('running %d tests...\n' % self.num_tests)
452
531
 
453
532
    def report_test_start(self, test):
454
533
        self.count += 1
455
534
        name = self._shortened_test_description(test)
456
 
        # width needs space for 6 char status, plus 1 for slash, plus 2 10-char
457
 
        # numbers, plus a trailing blank
458
 
        # when NUMBERED_DIRS: plus 5 chars on test number, plus 1 char on space
459
 
        self.stream.write(self._ellipsize_to_right(name,
460
 
                          osutils.terminal_width()-30))
 
535
        width = osutils.terminal_width()
 
536
        if width is not None:
 
537
            # width needs space for 6 char status, plus 1 for slash, plus an
 
538
            # 11-char time string, plus a trailing blank
 
539
            # when NUMBERED_DIRS: plus 5 chars on test number, plus 1 char on
 
540
            # space
 
541
            self.stream.write(self._ellipsize_to_right(name, width-18))
 
542
        else:
 
543
            self.stream.write(name)
461
544
        self.stream.flush()
462
545
 
463
546
    def _error_summary(self, err):
465
548
        return '%s%s' % (indent, err[1])
466
549
 
467
550
    def report_error(self, test, err):
468
 
        self.stream.writeln('ERROR %s\n%s'
 
551
        self.stream.write('ERROR %s\n%s\n'
469
552
                % (self._testTimeString(test),
470
553
                   self._error_summary(err)))
471
554
 
472
555
    def report_failure(self, test, err):
473
 
        self.stream.writeln(' FAIL %s\n%s'
 
556
        self.stream.write(' FAIL %s\n%s\n'
474
557
                % (self._testTimeString(test),
475
558
                   self._error_summary(err)))
476
559
 
477
560
    def report_known_failure(self, test, err):
478
 
        self.stream.writeln('XFAIL %s\n%s'
 
561
        self.stream.write('XFAIL %s\n%s\n'
479
562
                % (self._testTimeString(test),
480
563
                   self._error_summary(err)))
481
564
 
482
565
    def report_success(self, test):
483
 
        self.stream.writeln('   OK %s' % self._testTimeString(test))
 
566
        self.stream.write('   OK %s\n' % self._testTimeString(test))
484
567
        for bench_called, stats in getattr(test, '_benchcalls', []):
485
 
            self.stream.writeln('LSProf output for %s(%s, %s)' % bench_called)
 
568
            self.stream.write('LSProf output for %s(%s, %s)\n' % bench_called)
486
569
            stats.pprint(file=self.stream)
487
570
        # flush the stream so that we get smooth output. This verbose mode is
488
571
        # used to show the output in PQM.
489
572
        self.stream.flush()
490
573
 
491
574
    def report_skip(self, test, reason):
492
 
        self.stream.writeln(' SKIP %s\n%s'
 
575
        self.stream.write(' SKIP %s\n%s\n'
493
576
                % (self._testTimeString(test), reason))
494
577
 
495
 
    def report_not_applicable(self, test, skip_excinfo):
496
 
        self.stream.writeln('  N/A %s\n%s'
497
 
                % (self._testTimeString(test),
498
 
                   self._error_summary(skip_excinfo)))
 
578
    def report_not_applicable(self, test, reason):
 
579
        self.stream.write('  N/A %s\n    %s\n'
 
580
                % (self._testTimeString(test), reason))
499
581
 
500
582
    def report_unsupported(self, test, feature):
501
583
        """test cannot be run because feature is missing."""
502
 
        self.stream.writeln("NODEP %s\n    The feature '%s' is not available."
 
584
        self.stream.write("NODEP %s\n    The feature '%s' is not available.\n"
503
585
                %(self._testTimeString(test), feature))
504
586
 
505
587
 
511
593
                 descriptions=0,
512
594
                 verbosity=1,
513
595
                 bench_history=None,
514
 
                 list_only=False
 
596
                 strict=False,
 
597
                 result_decorators=None,
515
598
                 ):
516
 
        self.stream = unittest._WritelnDecorator(stream)
 
599
        """Create a TextTestRunner.
 
600
 
 
601
        :param result_decorators: An optional list of decorators to apply
 
602
            to the result object being used by the runner. Decorators are
 
603
            applied left to right - the first element in the list is the 
 
604
            innermost decorator.
 
605
        """
 
606
        # stream may know claim to know to write unicode strings, but in older
 
607
        # pythons this goes sufficiently wrong that it is a bad idea. (
 
608
        # specifically a built in file with encoding 'UTF-8' will still try
 
609
        # to encode using ascii.
 
610
        new_encoding = osutils.get_terminal_encoding()
 
611
        codec = codecs.lookup(new_encoding)
 
612
        if type(codec) is tuple:
 
613
            # Python 2.4
 
614
            encode = codec[0]
 
615
        else:
 
616
            encode = codec.encode
 
617
        stream = osutils.UnicodeOrBytesToBytesWriter(encode, stream)
 
618
        stream.encoding = new_encoding
 
619
        self.stream = stream
517
620
        self.descriptions = descriptions
518
621
        self.verbosity = verbosity
519
622
        self._bench_history = bench_history
520
 
        self.list_only = list_only
 
623
        self._strict = strict
 
624
        self._result_decorators = result_decorators or []
521
625
 
522
626
    def run(self, test):
523
627
        "Run the given test case or test suite."
524
 
        startTime = time.time()
525
628
        if self.verbosity == 1:
526
629
            result_class = TextTestResult
527
630
        elif self.verbosity >= 2:
528
631
            result_class = VerboseTestResult
529
 
        result = result_class(self.stream,
 
632
        original_result = result_class(self.stream,
530
633
                              self.descriptions,
531
634
                              self.verbosity,
532
635
                              bench_history=self._bench_history,
533
 
                              num_tests=test.countTestCases(),
 
636
                              strict=self._strict,
534
637
                              )
535
 
        result.stop_early = self.stop_on_failure
536
 
        result.report_starting()
537
 
        if self.list_only:
538
 
            if self.verbosity >= 2:
539
 
                self.stream.writeln("Listing tests only ...\n")
540
 
            run = 0
541
 
            for t in iter_suite_tests(test):
542
 
                self.stream.writeln("%s" % (t.id()))
543
 
                run += 1
544
 
            actionTaken = "Listed"
545
 
        else:
 
638
        # Signal to result objects that look at stop early policy to stop,
 
639
        original_result.stop_early = self.stop_on_failure
 
640
        result = original_result
 
641
        for decorator in self._result_decorators:
 
642
            result = decorator(result)
 
643
            result.stop_early = self.stop_on_failure
 
644
        result.startTestRun()
 
645
        try:
546
646
            test.run(result)
547
 
            run = result.testsRun
548
 
            actionTaken = "Ran"
549
 
        stopTime = time.time()
550
 
        timeTaken = stopTime - startTime
551
 
        result.printErrors()
552
 
        self.stream.writeln(result.separator2)
553
 
        self.stream.writeln("%s %d test%s in %.3fs" % (actionTaken,
554
 
                            run, run != 1 and "s" or "", timeTaken))
555
 
        self.stream.writeln()
556
 
        if not result.wasSuccessful():
557
 
            self.stream.write("FAILED (")
558
 
            failed, errored = map(len, (result.failures, result.errors))
559
 
            if failed:
560
 
                self.stream.write("failures=%d" % failed)
561
 
            if errored:
562
 
                if failed: self.stream.write(", ")
563
 
                self.stream.write("errors=%d" % errored)
564
 
            if result.known_failure_count:
565
 
                if failed or errored: self.stream.write(", ")
566
 
                self.stream.write("known_failure_count=%d" %
567
 
                    result.known_failure_count)
568
 
            self.stream.writeln(")")
569
 
        else:
570
 
            if result.known_failure_count:
571
 
                self.stream.writeln("OK (known_failures=%d)" %
572
 
                    result.known_failure_count)
573
 
            else:
574
 
                self.stream.writeln("OK")
575
 
        if result.skip_count > 0:
576
 
            skipped = result.skip_count
577
 
            self.stream.writeln('%d test%s skipped' %
578
 
                                (skipped, skipped != 1 and "s" or ""))
579
 
        if result.unsupported:
580
 
            for feature, count in sorted(result.unsupported.items()):
581
 
                self.stream.writeln("Missing feature '%s' skipped %d tests." %
582
 
                    (feature, count))
583
 
        result.finished()
584
 
        return result
 
647
        finally:
 
648
            result.stopTestRun()
 
649
        # higher level code uses our extended protocol to determine
 
650
        # what exit code to give.
 
651
        return original_result
585
652
 
586
653
 
587
654
def iter_suite_tests(suite):
597
664
                        % (type(suite), suite))
598
665
 
599
666
 
600
 
class TestSkipped(Exception):
601
 
    """Indicates that a test was intentionally skipped, rather than failing."""
 
667
TestSkipped = testtools.testcase.TestSkipped
602
668
 
603
669
 
604
670
class TestNotApplicable(TestSkipped):
610
676
    """
611
677
 
612
678
 
613
 
class KnownFailure(AssertionError):
614
 
    """Indicates that a test failed in a precisely expected manner.
615
 
 
616
 
    Such failures dont block the whole test suite from passing because they are
617
 
    indicators of partially completed code or of future work. We have an
618
 
    explicit error for them so that we can ensure that they are always visible:
619
 
    KnownFailures are always shown in the output of bzr selftest.
620
 
    """
 
679
# traceback._some_str fails to format exceptions that have the default
 
680
# __str__ which does an implicit ascii conversion. However, repr() on those
 
681
# objects works, for all that its not quite what the doctor may have ordered.
 
682
def _clever_some_str(value):
 
683
    try:
 
684
        return str(value)
 
685
    except:
 
686
        try:
 
687
            return repr(value).replace('\\n', '\n')
 
688
        except:
 
689
            return '<unprintable %s object>' % type(value).__name__
 
690
 
 
691
traceback._some_str = _clever_some_str
 
692
 
 
693
 
 
694
# deprecated - use self.knownFailure(), or self.expectFailure.
 
695
KnownFailure = testtools.testcase._ExpectedFailure
621
696
 
622
697
 
623
698
class UnavailableFeature(Exception):
624
699
    """A feature required for this test was not available.
625
700
 
 
701
    This can be considered a specialised form of SkippedTest.
 
702
 
626
703
    The feature should be used to construct the exception.
627
704
    """
628
705
 
629
706
 
630
 
class CommandFailed(Exception):
631
 
    pass
632
 
 
633
 
 
634
707
class StringIOWrapper(object):
635
708
    """A wrapper around cStringIO which just adds an encoding attribute.
636
709
 
657
730
            return setattr(self._cstring, name, val)
658
731
 
659
732
 
660
 
class TestUIFactory(ui.CLIUIFactory):
 
733
class TestUIFactory(TextUIFactory):
661
734
    """A UI Factory for testing.
662
735
 
663
736
    Hide the progress bar but emit note()s.
664
737
    Redirect stdin.
665
738
    Allows get_password to be tested without real tty attached.
 
739
 
 
740
    See also CannedInputUIFactory which lets you provide programmatic input in
 
741
    a structured way.
666
742
    """
 
743
    # TODO: Capture progress events at the model level and allow them to be
 
744
    # observed by tests that care.
 
745
    #
 
746
    # XXX: Should probably unify more with CannedInputUIFactory or a
 
747
    # particular configuration of TextUIFactory, or otherwise have a clearer
 
748
    # idea of how they're supposed to be different.
 
749
    # See https://bugs.launchpad.net/bzr/+bug/408213
667
750
 
668
 
    def __init__(self,
669
 
                 stdout=None,
670
 
                 stderr=None,
671
 
                 stdin=None):
672
 
        super(TestUIFactory, self).__init__()
 
751
    def __init__(self, stdout=None, stderr=None, stdin=None):
673
752
        if stdin is not None:
674
753
            # We use a StringIOWrapper to be able to test various
675
754
            # encodings, but the user is still responsible to
676
755
            # encode the string and to set the encoding attribute
677
756
            # of StringIOWrapper.
678
 
            self.stdin = StringIOWrapper(stdin)
679
 
        if stdout is None:
680
 
            self.stdout = sys.stdout
681
 
        else:
682
 
            self.stdout = stdout
683
 
        if stderr is None:
684
 
            self.stderr = sys.stderr
685
 
        else:
686
 
            self.stderr = stderr
687
 
 
688
 
    def clear(self):
689
 
        """See progress.ProgressBar.clear()."""
690
 
 
691
 
    def clear_term(self):
692
 
        """See progress.ProgressBar.clear_term()."""
693
 
 
694
 
    def clear_term(self):
695
 
        """See progress.ProgressBar.clear_term()."""
696
 
 
697
 
    def finished(self):
698
 
        """See progress.ProgressBar.finished()."""
699
 
 
700
 
    def note(self, fmt_string, *args, **kwargs):
701
 
        """See progress.ProgressBar.note()."""
702
 
        self.stdout.write((fmt_string + "\n") % args)
703
 
 
704
 
    def progress_bar(self):
705
 
        return self
706
 
 
707
 
    def nested_progress_bar(self):
708
 
        return self
709
 
 
710
 
    def update(self, message, count=None, total=None):
711
 
        """See progress.ProgressBar.update()."""
712
 
 
713
 
    def get_non_echoed_password(self, prompt):
 
757
            stdin = StringIOWrapper(stdin)
 
758
        super(TestUIFactory, self).__init__(stdin, stdout, stderr)
 
759
 
 
760
    def get_non_echoed_password(self):
714
761
        """Get password from stdin without trying to handle the echo mode"""
715
 
        if prompt:
716
 
            self.stdout.write(prompt.encode(self.stdout.encoding, 'replace'))
717
762
        password = self.stdin.readline()
718
763
        if not password:
719
764
            raise EOFError
721
766
            password = password[:-1]
722
767
        return password
723
768
 
724
 
 
725
 
def _report_leaked_threads():
726
 
    bzrlib.trace.warning('%s is leaking threads among %d leaking tests',
727
 
                         TestCase._first_thread_leaker_id,
728
 
                         TestCase._leaking_threads_tests)
729
 
 
730
 
 
731
 
class TestCase(unittest.TestCase):
 
769
    def make_progress_view(self):
 
770
        return NullProgressView()
 
771
 
 
772
 
 
773
class TestCase(testtools.TestCase):
732
774
    """Base class for bzr unit tests.
733
775
 
734
776
    Tests that need access to disk resources should subclass
753
795
    _leaking_threads_tests = 0
754
796
    _first_thread_leaker_id = None
755
797
    _log_file_name = None
756
 
    _log_contents = ''
757
 
    _keep_log_file = False
758
798
    # record lsprof data when performing benchmark calls.
759
799
    _gather_lsprof_in_benchmarks = False
760
 
    attrs_to_keep = ('id', '_testMethodName', '_testMethodDoc',
761
 
                     '_log_contents', '_log_file_name', '_benchtime',
762
 
                     '_TestCase__testMethodName')
763
800
 
764
801
    def __init__(self, methodName='testMethod'):
765
802
        super(TestCase, self).__init__(methodName)
766
803
        self._cleanups = []
767
 
        self._bzr_test_setUp_run = False
768
 
        self._bzr_test_tearDown_run = False
 
804
        self._directory_isolation = True
 
805
        self.exception_handlers.insert(0,
 
806
            (UnavailableFeature, self._do_unsupported_or_skip))
 
807
        self.exception_handlers.insert(0,
 
808
            (TestNotApplicable, self._do_not_applicable))
769
809
 
770
810
    def setUp(self):
771
 
        unittest.TestCase.setUp(self)
772
 
        self._bzr_test_setUp_run = True
 
811
        super(TestCase, self).setUp()
 
812
        for feature in getattr(self, '_test_needs_features', []):
 
813
            self.requireFeature(feature)
 
814
        self._log_contents = None
 
815
        self.addDetail("log", content.Content(content.ContentType("text",
 
816
            "plain", {"charset": "utf8"}),
 
817
            lambda:[self._get_log(keep_log_file=True)]))
773
818
        self._cleanEnvironment()
774
819
        self._silenceUI()
775
820
        self._startLogFile()
776
821
        self._benchcalls = []
777
822
        self._benchtime = None
778
823
        self._clear_hooks()
 
824
        self._track_transports()
 
825
        self._track_locks()
779
826
        self._clear_debug_flags()
780
827
        TestCase._active_threads = threading.activeCount()
781
828
        self.addCleanup(self._check_leaked_threads)
785
832
        import pdb
786
833
        pdb.Pdb().set_trace(sys._getframe().f_back)
787
834
 
788
 
    def exc_info(self):
789
 
        absent_attr = object()
790
 
        exc_info = getattr(self, '_exc_info', absent_attr)
791
 
        if exc_info is absent_attr:
792
 
            exc_info = getattr(self, '_TestCase__exc_info')
793
 
        return exc_info()
794
 
 
795
835
    def _check_leaked_threads(self):
796
836
        active = threading.activeCount()
797
837
        leaked_threads = active - TestCase._active_threads
798
838
        TestCase._active_threads = active
799
 
        if leaked_threads:
 
839
        # If some tests make the number of threads *decrease*, we'll consider
 
840
        # that they are just observing old threads dieing, not agressively kill
 
841
        # random threads. So we don't report these tests as leaking. The risk
 
842
        # is that we have false positives that way (the test see 2 threads
 
843
        # going away but leak one) but it seems less likely than the actual
 
844
        # false positives (the test see threads going away and does not leak).
 
845
        if leaked_threads > 0:
 
846
            if 'threads' in selftest_debug_flags:
 
847
                print '%s is leaking, active is now %d' % (self.id(), active)
800
848
            TestCase._leaking_threads_tests += 1
801
849
            if TestCase._first_thread_leaker_id is None:
802
850
                TestCase._first_thread_leaker_id = self.id()
803
 
                # we're not specifically told when all tests are finished.
804
 
                # This will do. We use a function to avoid keeping a reference
805
 
                # to a TestCase object.
806
 
                atexit.register(_report_leaked_threads)
807
851
 
808
852
    def _clear_debug_flags(self):
809
853
        """Prevent externally set debug flags affecting tests.
811
855
        Tests that want to use debug flags can just set them in the
812
856
        debug_flags set during setup/teardown.
813
857
        """
814
 
        self._preserved_debug_flags = set(debug.debug_flags)
 
858
        # Start with a copy of the current debug flags we can safely modify.
 
859
        self.overrideAttr(debug, 'debug_flags', set(debug.debug_flags))
815
860
        if 'allow_debug' not in selftest_debug_flags:
816
861
            debug.debug_flags.clear()
817
 
        self.addCleanup(self._restore_debug_flags)
 
862
        if 'disable_lock_checks' not in selftest_debug_flags:
 
863
            debug.debug_flags.add('strict_locks')
818
864
 
819
865
    def _clear_hooks(self):
820
866
        # prevent hooks affecting tests
830
876
        # this hook should always be installed
831
877
        request._install_hook()
832
878
 
 
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
 
833
887
    def _silenceUI(self):
834
888
        """Turn off UI for duration of test"""
835
889
        # by default the UI is off; tests can turn it on if they want it.
836
 
        saved = ui.ui_factory
837
 
        def _restore():
838
 
            ui.ui_factory = saved
839
 
        ui.ui_factory = ui.SilentUIFactory()
840
 
        self.addCleanup(_restore)
 
890
        self.overrideAttr(ui, 'ui_factory', ui.SilentUIFactory())
 
891
 
 
892
    def _check_locks(self):
 
893
        """Check that all lock take/release actions have been paired."""
 
894
        # We always check for mismatched locks. If a mismatch is found, we
 
895
        # fail unless -Edisable_lock_checks is supplied to selftest, in which
 
896
        # case we just print a warning.
 
897
        # unhook:
 
898
        acquired_locks = [lock for action, lock in self._lock_actions
 
899
                          if action == 'acquired']
 
900
        released_locks = [lock for action, lock in self._lock_actions
 
901
                          if action == 'released']
 
902
        broken_locks = [lock for action, lock in self._lock_actions
 
903
                        if action == 'broken']
 
904
        # trivially, given the tests for lock acquistion and release, if we
 
905
        # have as many in each list, it should be ok. Some lock tests also
 
906
        # break some locks on purpose and should be taken into account by
 
907
        # considering that breaking a lock is just a dirty way of releasing it.
 
908
        if len(acquired_locks) != (len(released_locks) + len(broken_locks)):
 
909
            message = ('Different number of acquired and '
 
910
                       'released or broken locks. (%s, %s + %s)' %
 
911
                       (acquired_locks, released_locks, broken_locks))
 
912
            if not self._lock_check_thorough:
 
913
                # Rather than fail, just warn
 
914
                print "Broken test %s: %s" % (self, message)
 
915
                return
 
916
            self.fail(message)
 
917
 
 
918
    def _track_locks(self):
 
919
        """Track lock activity during tests."""
 
920
        self._lock_actions = []
 
921
        if 'disable_lock_checks' in selftest_debug_flags:
 
922
            self._lock_check_thorough = False
 
923
        else:
 
924
            self._lock_check_thorough = True
 
925
 
 
926
        self.addCleanup(self._check_locks)
 
927
        _mod_lock.Lock.hooks.install_named_hook('lock_acquired',
 
928
                                                self._lock_acquired, None)
 
929
        _mod_lock.Lock.hooks.install_named_hook('lock_released',
 
930
                                                self._lock_released, None)
 
931
        _mod_lock.Lock.hooks.install_named_hook('lock_broken',
 
932
                                                self._lock_broken, None)
 
933
 
 
934
    def _lock_acquired(self, result):
 
935
        self._lock_actions.append(('acquired', result))
 
936
 
 
937
    def _lock_released(self, result):
 
938
        self._lock_actions.append(('released', result))
 
939
 
 
940
    def _lock_broken(self, result):
 
941
        self._lock_actions.append(('broken', result))
 
942
 
 
943
    def permit_dir(self, name):
 
944
        """Permit a directory to be used by this test. See permit_url."""
 
945
        name_transport = _mod_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 = _mod_transport.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.")
841
1069
 
842
1070
    def _ndiff_strings(self, a, b):
843
1071
        """Return ndiff between two strings containing lines.
866
1094
            message += '\n'
867
1095
        raise AssertionError("%snot equal:\na = %s\nb = %s\n"
868
1096
            % (message,
869
 
               pformat(a), pformat(b)))
 
1097
               pprint.pformat(a), pprint.pformat(b)))
870
1098
 
871
1099
    assertEquals = assertEqual
872
1100
 
881
1109
            return
882
1110
        if message is None:
883
1111
            message = "texts not equal:\n"
 
1112
        if a + '\n' == b:
 
1113
            message = 'first string is missing a final newline.\n'
884
1114
        if a == b + '\n':
885
 
            message = 'first string is missing a final newline.\n'
886
 
        if a + '\n' == b:
887
1115
            message = 'second string is missing a final newline.\n'
888
1116
        raise AssertionError(message +
889
1117
                             self._ndiff_strings(a, b))
900
1128
        :raises AssertionError: If the expected and actual stat values differ
901
1129
            other than by atime.
902
1130
        """
903
 
        self.assertEqual(expected.st_size, actual.st_size)
904
 
        self.assertEqual(expected.st_mtime, actual.st_mtime)
905
 
        self.assertEqual(expected.st_ctime, actual.st_ctime)
906
 
        self.assertEqual(expected.st_dev, actual.st_dev)
907
 
        self.assertEqual(expected.st_ino, actual.st_ino)
908
 
        self.assertEqual(expected.st_mode, actual.st_mode)
 
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')
909
1148
 
910
1149
    def assertLength(self, length, obj_with_len):
911
1150
        """Assert that obj_with_len is of length length."""
913
1152
            self.fail("Incorrect length: wanted %d, got %d for %r" % (
914
1153
                length, len(obj_with_len), obj_with_len))
915
1154
 
 
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
 
916
1174
    def assertPositive(self, val):
917
1175
        """Assert that val is greater than 0."""
918
1176
        self.assertTrue(val > 0, 'expected a positive value, but got %s' % val)
948
1206
            raise AssertionError('pattern "%s" found in "%s"'
949
1207
                    % (needle_re, haystack))
950
1208
 
 
1209
    def assertContainsString(self, haystack, needle):
 
1210
        if haystack.find(needle) == -1:
 
1211
            self.fail("string %r not found in '''%s'''" % (needle, haystack))
 
1212
 
951
1213
    def assertSubset(self, sublist, superlist):
952
1214
        """Assert that every entry in sublist is present in superlist."""
953
1215
        missing = set(sublist) - set(superlist)
1010
1272
                raise AssertionError("%r is %r." % (left, right))
1011
1273
 
1012
1274
    def assertTransportMode(self, transport, path, mode):
1013
 
        """Fail if a path does not have mode mode.
 
1275
        """Fail if a path does not have mode "mode".
1014
1276
 
1015
1277
        If modes are not supported on this transport, the assertion is ignored.
1016
1278
        """
1028
1290
                         osutils.realpath(path2),
1029
1291
                         "apparent paths:\na = %s\nb = %s\n," % (path1, path2))
1030
1292
 
1031
 
    def assertIsInstance(self, obj, kls):
1032
 
        """Fail if obj is not an instance of kls"""
 
1293
    def assertIsInstance(self, obj, kls, msg=None):
 
1294
        """Fail if obj is not an instance of kls
 
1295
        
 
1296
        :param msg: Supplementary message to show if the assertion fails.
 
1297
        """
1033
1298
        if not isinstance(obj, kls):
1034
 
            self.fail("%r is an instance of %s rather than %s" % (
1035
 
                obj, obj.__class__, kls))
1036
 
 
1037
 
    def expectFailure(self, reason, assertion, *args, **kwargs):
1038
 
        """Invoke a test, expecting it to fail for the given reason.
1039
 
 
1040
 
        This is for assertions that ought to succeed, but currently fail.
1041
 
        (The failure is *expected* but not *wanted*.)  Please be very precise
1042
 
        about the failure you're expecting.  If a new bug is introduced,
1043
 
        AssertionError should be raised, not KnownFailure.
1044
 
 
1045
 
        Frequently, expectFailure should be followed by an opposite assertion.
1046
 
        See example below.
1047
 
 
1048
 
        Intended to be used with a callable that raises AssertionError as the
1049
 
        'assertion' parameter.  args and kwargs are passed to the 'assertion'.
1050
 
 
1051
 
        Raises KnownFailure if the test fails.  Raises AssertionError if the
1052
 
        test succeeds.
1053
 
 
1054
 
        example usage::
1055
 
 
1056
 
          self.expectFailure('Math is broken', self.assertNotEqual, 54,
1057
 
                             dynamic_val)
1058
 
          self.assertEqual(42, dynamic_val)
1059
 
 
1060
 
          This means that a dynamic_val of 54 will cause the test to raise
1061
 
          a KnownFailure.  Once math is fixed and the expectFailure is removed,
1062
 
          only a dynamic_val of 42 will allow the test to pass.  Anything other
1063
 
          than 54 or 42 will cause an AssertionError.
1064
 
        """
1065
 
        try:
1066
 
            assertion(*args, **kwargs)
1067
 
        except AssertionError:
1068
 
            raise KnownFailure(reason)
1069
 
        else:
1070
 
            self.fail('Unexpected success.  Should have failed: %s' % reason)
 
1299
            m = "%r is an instance of %s rather than %s" % (
 
1300
                obj, obj.__class__, kls)
 
1301
            if msg:
 
1302
                m += ": " + msg
 
1303
            self.fail(m)
1071
1304
 
1072
1305
    def assertFileEqual(self, content, path):
1073
1306
        """Fail if path does not contain 'content'."""
1079
1312
            f.close()
1080
1313
        self.assertEqualDiff(content, s)
1081
1314
 
 
1315
    def assertDocstring(self, expected_docstring, obj):
 
1316
        """Fail if obj does not have expected_docstring"""
 
1317
        if __doc__ is None:
 
1318
            # With -OO the docstring should be None instead
 
1319
            self.assertIs(obj.__doc__, None)
 
1320
        else:
 
1321
            self.assertEqual(expected_docstring, obj.__doc__)
 
1322
 
1082
1323
    def failUnlessExists(self, path):
1083
1324
        """Fail unless path or paths, which may be abs or relative, exist."""
1084
1325
        if not isinstance(path, basestring):
1224
1465
 
1225
1466
        Close the file and delete it, unless setKeepLogfile was called.
1226
1467
        """
1227
 
        if self._log_file is None:
1228
 
            return
 
1468
        if bzrlib.trace._trace_file:
 
1469
            # flush the log file, to get all content
 
1470
            bzrlib.trace._trace_file.flush()
1229
1471
        bzrlib.trace.pop_log_file(self._log_memento)
1230
 
        self._log_file.close()
1231
 
        self._log_file = None
1232
 
        if not self._keep_log_file:
1233
 
            os.remove(self._log_file_name)
1234
 
            self._log_file_name = None
1235
 
 
1236
 
    def setKeepLogfile(self):
1237
 
        """Make the logfile not be deleted when _finishLogFile is called."""
1238
 
        self._keep_log_file = True
 
1472
        # Cache the log result and delete the file on disk
 
1473
        self._get_log(False)
 
1474
 
 
1475
    def thisFailsStrictLockCheck(self):
 
1476
        """It is known that this test would fail with -Dstrict_locks.
 
1477
 
 
1478
        By default, all tests are run with strict lock checking unless
 
1479
        -Edisable_lock_checks is supplied. However there are some tests which
 
1480
        we know fail strict locks at this point that have not been fixed.
 
1481
        They should call this function to disable the strict checking.
 
1482
 
 
1483
        This should be used sparingly, it is much better to fix the locking
 
1484
        issues rather than papering over the problem by calling this function.
 
1485
        """
 
1486
        debug.debug_flags.discard('strict_locks')
1239
1487
 
1240
1488
    def addCleanup(self, callable, *args, **kwargs):
1241
1489
        """Arrange to run a callable when this case is torn down.
1245
1493
        """
1246
1494
        self._cleanups.append((callable, args, kwargs))
1247
1495
 
 
1496
    def overrideAttr(self, obj, attr_name, new=_unitialized_attr):
 
1497
        """Overrides an object attribute restoring it after the test.
 
1498
 
 
1499
        :param obj: The object that will be mutated.
 
1500
 
 
1501
        :param attr_name: The attribute name we want to preserve/override in
 
1502
            the object.
 
1503
 
 
1504
        :param new: The optional value we want to set the attribute to.
 
1505
 
 
1506
        :returns: The actual attr value.
 
1507
        """
 
1508
        value = getattr(obj, attr_name)
 
1509
        # The actual value is captured by the call below
 
1510
        self.addCleanup(setattr, obj, attr_name, value)
 
1511
        if new is not _unitialized_attr:
 
1512
            setattr(obj, attr_name, new)
 
1513
        return value
 
1514
 
1248
1515
    def _cleanEnvironment(self):
1249
1516
        new_env = {
1250
1517
            'BZR_HOME': None, # Don't inherit BZR_HOME to all the tests.
1256
1523
            'EDITOR': None,
1257
1524
            'BZR_EMAIL': None,
1258
1525
            'BZREMAIL': None, # may still be present in the environment
1259
 
            'EMAIL': None,
 
1526
            'EMAIL': 'jrandom@example.com', # set EMAIL as bzr does not guess
1260
1527
            'BZR_PROGRESS_BAR': None,
1261
1528
            'BZR_LOG': None,
1262
1529
            'BZR_PLUGIN_PATH': None,
 
1530
            'BZR_DISABLE_PLUGINS': None,
 
1531
            'BZR_PLUGINS_AT': None,
 
1532
            'BZR_CONCURRENCY': None,
 
1533
            # Make sure that any text ui tests are consistent regardless of
 
1534
            # the environment the test case is run in; you may want tests that
 
1535
            # test other combinations.  'dumb' is a reasonable guess for tests
 
1536
            # going to a pipe or a StringIO.
 
1537
            'TERM': 'dumb',
 
1538
            'LINES': '25',
 
1539
            'COLUMNS': '80',
 
1540
            'BZR_COLUMNS': '80',
1263
1541
            # SSH Agent
1264
1542
            'SSH_AUTH_SOCK': None,
1265
1543
            # Proxies
1271
1549
            'NO_PROXY': None,
1272
1550
            'all_proxy': None,
1273
1551
            'ALL_PROXY': None,
1274
 
            # Nobody cares about these ones AFAIK. So far at
 
1552
            # Nobody cares about ftp_proxy, FTP_PROXY AFAIK. So far at
1275
1553
            # least. If you do (care), please update this comment
1276
 
            # -- vila 20061212
 
1554
            # -- vila 20080401
1277
1555
            'ftp_proxy': None,
1278
1556
            'FTP_PROXY': None,
1279
1557
            'BZR_REMOTE_PATH': None,
 
1558
            # Generally speaking, we don't want apport reporting on crashes in
 
1559
            # the test envirnoment unless we're specifically testing apport,
 
1560
            # so that it doesn't leak into the real system environment.  We
 
1561
            # use an env var so it propagates to subprocesses.
 
1562
            'APPORT_DISABLE': '1',
1280
1563
        }
1281
 
        self.__old_env = {}
 
1564
        self._old_env = {}
1282
1565
        self.addCleanup(self._restoreEnvironment)
1283
1566
        for name, value in new_env.iteritems():
1284
1567
            self._captureVar(name, value)
1285
1568
 
1286
1569
    def _captureVar(self, name, newvalue):
1287
1570
        """Set an environment variable, and reset it when finished."""
1288
 
        self.__old_env[name] = osutils.set_or_unset_env(name, newvalue)
1289
 
 
1290
 
    def _restore_debug_flags(self):
1291
 
        debug.debug_flags.clear()
1292
 
        debug.debug_flags.update(self._preserved_debug_flags)
 
1571
        self._old_env[name] = osutils.set_or_unset_env(name, newvalue)
1293
1572
 
1294
1573
    def _restoreEnvironment(self):
1295
 
        for name, value in self.__old_env.iteritems():
 
1574
        for name, value in self._old_env.iteritems():
1296
1575
            osutils.set_or_unset_env(name, value)
1297
1576
 
1298
1577
    def _restoreHooks(self):
1306
1585
    def _do_skip(self, result, reason):
1307
1586
        addSkip = getattr(result, 'addSkip', None)
1308
1587
        if not callable(addSkip):
1309
 
            result.addError(self, self.exc_info())
 
1588
            result.addSuccess(result)
1310
1589
        else:
1311
1590
            addSkip(self, reason)
1312
1591
 
1313
 
    def run(self, result=None):
1314
 
        if result is None: result = self.defaultTestResult()
1315
 
        for feature in getattr(self, '_test_needs_features', []):
1316
 
            if not feature.available():
1317
 
                result.startTest(self)
1318
 
                if getattr(result, 'addNotSupported', None):
1319
 
                    result.addNotSupported(self, feature)
1320
 
                else:
1321
 
                    result.addSuccess(self)
1322
 
                result.stopTest(self)
1323
 
                return
1324
 
        try:
1325
 
            try:
1326
 
                result.startTest(self)
1327
 
                absent_attr = object()
1328
 
                # Python 2.5
1329
 
                method_name = getattr(self, '_testMethodName', absent_attr)
1330
 
                if method_name is absent_attr:
1331
 
                    # Python 2.4
1332
 
                    method_name = getattr(self, '_TestCase__testMethodName')
1333
 
                testMethod = getattr(self, method_name)
1334
 
                try:
1335
 
                    try:
1336
 
                        self.setUp()
1337
 
                        if not self._bzr_test_setUp_run:
1338
 
                            self.fail(
1339
 
                                "test setUp did not invoke "
1340
 
                                "bzrlib.tests.TestCase's setUp")
1341
 
                    except KeyboardInterrupt:
1342
 
                        raise
1343
 
                    except TestSkipped, e:
1344
 
                        self._do_skip(result, e.args[0])
1345
 
                        self.tearDown()
1346
 
                        return
1347
 
                    except:
1348
 
                        result.addError(self, self.exc_info())
1349
 
                        return
1350
 
 
1351
 
                    ok = False
1352
 
                    try:
1353
 
                        testMethod()
1354
 
                        ok = True
1355
 
                    except self.failureException:
1356
 
                        result.addFailure(self, self.exc_info())
1357
 
                    except TestSkipped, e:
1358
 
                        if not e.args:
1359
 
                            reason = "No reason given."
1360
 
                        else:
1361
 
                            reason = e.args[0]
1362
 
                        self._do_skip(result, reason)
1363
 
                    except KeyboardInterrupt:
1364
 
                        raise
1365
 
                    except:
1366
 
                        result.addError(self, self.exc_info())
1367
 
 
1368
 
                    try:
1369
 
                        self.tearDown()
1370
 
                        if not self._bzr_test_tearDown_run:
1371
 
                            self.fail(
1372
 
                                "test tearDown did not invoke "
1373
 
                                "bzrlib.tests.TestCase's tearDown")
1374
 
                    except KeyboardInterrupt:
1375
 
                        raise
1376
 
                    except:
1377
 
                        result.addError(self, self.exc_info())
1378
 
                        ok = False
1379
 
                    if ok: result.addSuccess(self)
1380
 
                finally:
1381
 
                    result.stopTest(self)
1382
 
                return
1383
 
            except TestNotApplicable:
1384
 
                # Not moved from the result [yet].
1385
 
                raise
1386
 
            except KeyboardInterrupt:
1387
 
                raise
1388
 
        finally:
1389
 
            saved_attrs = {}
1390
 
            absent_attr = object()
1391
 
            for attr_name in self.attrs_to_keep:
1392
 
                attr = getattr(self, attr_name, absent_attr)
1393
 
                if attr is not absent_attr:
1394
 
                    saved_attrs[attr_name] = attr
1395
 
            self.__dict__ = saved_attrs
1396
 
 
1397
 
    def tearDown(self):
1398
 
        self._bzr_test_tearDown_run = True
1399
 
        self._runCleanups()
1400
 
        self._log_contents = ''
1401
 
        unittest.TestCase.tearDown(self)
 
1592
    @staticmethod
 
1593
    def _do_known_failure(self, result, e):
 
1594
        err = sys.exc_info()
 
1595
        addExpectedFailure = getattr(result, 'addExpectedFailure', None)
 
1596
        if addExpectedFailure is not None:
 
1597
            addExpectedFailure(self, err)
 
1598
        else:
 
1599
            result.addSuccess(self)
 
1600
 
 
1601
    @staticmethod
 
1602
    def _do_not_applicable(self, result, e):
 
1603
        if not e.args:
 
1604
            reason = 'No reason given'
 
1605
        else:
 
1606
            reason = e.args[0]
 
1607
        addNotApplicable = getattr(result, 'addNotApplicable', None)
 
1608
        if addNotApplicable is not None:
 
1609
            result.addNotApplicable(self, reason)
 
1610
        else:
 
1611
            self._do_skip(result, reason)
 
1612
 
 
1613
    @staticmethod
 
1614
    def _do_unsupported_or_skip(self, result, e):
 
1615
        reason = e.args[0]
 
1616
        addNotSupported = getattr(result, 'addNotSupported', None)
 
1617
        if addNotSupported is not None:
 
1618
            result.addNotSupported(self, reason)
 
1619
        else:
 
1620
            self._do_skip(result, reason)
1402
1621
 
1403
1622
    def time(self, callable, *args, **kwargs):
1404
1623
        """Run callable and accrue the time it takes to the benchmark time.
1408
1627
        self._benchcalls.
1409
1628
        """
1410
1629
        if self._benchtime is None:
 
1630
            self.addDetail('benchtime', content.Content(content.ContentType(
 
1631
                "text", "plain"), lambda:[str(self._benchtime)]))
1411
1632
            self._benchtime = 0
1412
1633
        start = time.time()
1413
1634
        try:
1422
1643
        finally:
1423
1644
            self._benchtime += time.time() - start
1424
1645
 
1425
 
    def _runCleanups(self):
1426
 
        """Run registered cleanup functions.
1427
 
 
1428
 
        This should only be called from TestCase.tearDown.
1429
 
        """
1430
 
        # TODO: Perhaps this should keep running cleanups even if
1431
 
        # one of them fails?
1432
 
 
1433
 
        # Actually pop the cleanups from the list so tearDown running
1434
 
        # twice is safe (this happens for skipped tests).
1435
 
        while self._cleanups:
1436
 
            cleanup, args, kwargs = self._cleanups.pop()
1437
 
            cleanup(*args, **kwargs)
1438
 
 
1439
1646
    def log(self, *args):
1440
1647
        mutter(*args)
1441
1648
 
1442
1649
    def _get_log(self, keep_log_file=False):
1443
 
        """Get the log from bzrlib.trace calls from this test.
 
1650
        """Internal helper to get the log from bzrlib.trace for this test.
 
1651
 
 
1652
        Please use self.getDetails, or self.get_log to access this in test case
 
1653
        code.
1444
1654
 
1445
1655
        :param keep_log_file: When True, if the log is still a file on disk
1446
1656
            leave it as a file on disk. When False, if the log is still a file
1448
1658
            self._log_contents.
1449
1659
        :return: A string containing the log.
1450
1660
        """
1451
 
        # flush the log file, to get all content
 
1661
        if self._log_contents is not None:
 
1662
            try:
 
1663
                self._log_contents.decode('utf8')
 
1664
            except UnicodeDecodeError:
 
1665
                unicodestr = self._log_contents.decode('utf8', 'replace')
 
1666
                self._log_contents = unicodestr.encode('utf8')
 
1667
            return self._log_contents
1452
1668
        import bzrlib.trace
1453
1669
        if bzrlib.trace._trace_file:
 
1670
            # flush the log file, to get all content
1454
1671
            bzrlib.trace._trace_file.flush()
1455
 
        if self._log_contents:
1456
 
            # XXX: this can hardly contain the content flushed above --vila
1457
 
            # 20080128
1458
 
            return self._log_contents
1459
1672
        if self._log_file_name is not None:
1460
1673
            logfile = open(self._log_file_name)
1461
1674
            try:
1462
1675
                log_contents = logfile.read()
1463
1676
            finally:
1464
1677
                logfile.close()
 
1678
            try:
 
1679
                log_contents.decode('utf8')
 
1680
            except UnicodeDecodeError:
 
1681
                unicodestr = log_contents.decode('utf8', 'replace')
 
1682
                log_contents = unicodestr.encode('utf8')
1465
1683
            if not keep_log_file:
 
1684
                close_attempts = 0
 
1685
                max_close_attempts = 100
 
1686
                first_close_error = None
 
1687
                while close_attempts < max_close_attempts:
 
1688
                    close_attempts += 1
 
1689
                    try:
 
1690
                        self._log_file.close()
 
1691
                    except IOError, ioe:
 
1692
                        if ioe.errno is None:
 
1693
                            # No errno implies 'close() called during
 
1694
                            # concurrent operation on the same file object', so
 
1695
                            # retry.  Probably a thread is trying to write to
 
1696
                            # the log file.
 
1697
                            if first_close_error is None:
 
1698
                                first_close_error = ioe
 
1699
                            continue
 
1700
                        raise
 
1701
                    else:
 
1702
                        break
 
1703
                if close_attempts > 1:
 
1704
                    sys.stderr.write(
 
1705
                        'Unable to close log file on first attempt, '
 
1706
                        'will retry: %s\n' % (first_close_error,))
 
1707
                    if close_attempts == max_close_attempts:
 
1708
                        sys.stderr.write(
 
1709
                            'Unable to close log file after %d attempts.\n'
 
1710
                            % (max_close_attempts,))
 
1711
                self._log_file = None
 
1712
                # Permit multiple calls to get_log until we clean it up in
 
1713
                # finishLogFile
1466
1714
                self._log_contents = log_contents
1467
1715
                try:
1468
1716
                    os.remove(self._log_file_name)
1472
1720
                                             ' %r\n' % self._log_file_name))
1473
1721
                    else:
1474
1722
                        raise
 
1723
                self._log_file_name = None
1475
1724
            return log_contents
1476
1725
        else:
1477
 
            return "DELETED log file to reduce memory footprint"
 
1726
            return "No log file content and no log file name."
 
1727
 
 
1728
    def get_log(self):
 
1729
        """Get a unicode string containing the log from bzrlib.trace.
 
1730
 
 
1731
        Undecodable characters are replaced.
 
1732
        """
 
1733
        return u"".join(self.getDetails()['log'].iter_text())
1478
1734
 
1479
1735
    def requireFeature(self, feature):
1480
1736
        """This test requires a specific feature is available.
1497
1753
 
1498
1754
    def _run_bzr_core(self, args, retcode, encoding, stdin,
1499
1755
            working_dir):
 
1756
        # Clear chk_map page cache, because the contents are likely to mask
 
1757
        # locking errors.
 
1758
        chk_map.clear_cache()
1500
1759
        if encoding is None:
1501
1760
            encoding = osutils.get_user_encoding()
1502
1761
        stdout = StringIOWrapper()
1519
1778
            os.chdir(working_dir)
1520
1779
 
1521
1780
        try:
1522
 
            result = self.apply_redirected(ui.ui_factory.stdin,
1523
 
                stdout, stderr,
1524
 
                bzrlib.commands.run_bzr_catch_user_errors,
1525
 
                args)
 
1781
            try:
 
1782
                result = self.apply_redirected(ui.ui_factory.stdin,
 
1783
                    stdout, stderr,
 
1784
                    bzrlib.commands.run_bzr_catch_user_errors,
 
1785
                    args)
 
1786
            except KeyboardInterrupt:
 
1787
                # Reraise KeyboardInterrupt with contents of redirected stdout
 
1788
                # and stderr as arguments, for tests which are interested in
 
1789
                # stdout and stderr and are expecting the exception.
 
1790
                out = stdout.getvalue()
 
1791
                err = stderr.getvalue()
 
1792
                if out:
 
1793
                    self.log('output:\n%r', out)
 
1794
                if err:
 
1795
                    self.log('errors:\n%r', err)
 
1796
                raise KeyboardInterrupt(out, err)
1526
1797
        finally:
1527
1798
            logger.removeHandler(handler)
1528
1799
            ui.ui_factory = old_ui_factory
1538
1809
        if retcode is not None:
1539
1810
            self.assertEquals(retcode, result,
1540
1811
                              message='Unexpected return code')
1541
 
        return out, err
 
1812
        return result, out, err
1542
1813
 
1543
1814
    def run_bzr(self, args, retcode=0, encoding=None, stdin=None,
1544
1815
                working_dir=None, error_regexes=[], output_encoding=None):
1573
1844
        :keyword error_regexes: A list of expected error messages.  If
1574
1845
            specified they must be seen in the error output of the command.
1575
1846
        """
1576
 
        out, err = self._run_bzr_autosplit(
 
1847
        retcode, out, err = self._run_bzr_autosplit(
1577
1848
            args=args,
1578
1849
            retcode=retcode,
1579
1850
            encoding=encoding,
1580
1851
            stdin=stdin,
1581
1852
            working_dir=working_dir,
1582
1853
            )
 
1854
        self.assertIsInstance(error_regexes, (list, tuple))
1583
1855
        for regex in error_regexes:
1584
1856
            self.assertContainsRe(err, regex)
1585
1857
        return out, err
1713
1985
            if not allow_plugins:
1714
1986
                command.append('--no-plugins')
1715
1987
            command.extend(process_args)
1716
 
            process = self._popen(command, stdin=PIPE, stdout=PIPE, stderr=PIPE)
 
1988
            process = self._popen(command, stdin=subprocess.PIPE,
 
1989
                                  stdout=subprocess.PIPE,
 
1990
                                  stderr=subprocess.PIPE)
1717
1991
        finally:
1718
1992
            restore_environment()
1719
1993
            if cwd is not None:
1727
2001
        Allows tests to override this method to intercept the calls made to
1728
2002
        Popen for introspection.
1729
2003
        """
1730
 
        return Popen(*args, **kwargs)
 
2004
        return subprocess.Popen(*args, **kwargs)
 
2005
 
 
2006
    def get_source_path(self):
 
2007
        """Return the path of the directory containing bzrlib."""
 
2008
        return os.path.dirname(os.path.dirname(bzrlib.__file__))
1731
2009
 
1732
2010
    def get_bzr_path(self):
1733
2011
        """Return the path of the 'bzr' executable for this test suite."""
1734
 
        bzr_path = os.path.dirname(os.path.dirname(bzrlib.__file__))+'/bzr'
 
2012
        bzr_path = os.path.join(self.get_source_path(), "bzr")
1735
2013
        if not os.path.isfile(bzr_path):
1736
2014
            # We are probably installed. Assume sys.argv is the right file
1737
2015
            bzr_path = sys.argv[0]
1823
2101
 
1824
2102
        Tests that expect to provoke LockContention errors should call this.
1825
2103
        """
1826
 
        orig_timeout = bzrlib.lockdir._DEFAULT_TIMEOUT_SECONDS
1827
 
        def resetTimeout():
1828
 
            bzrlib.lockdir._DEFAULT_TIMEOUT_SECONDS = orig_timeout
1829
 
        self.addCleanup(resetTimeout)
1830
 
        bzrlib.lockdir._DEFAULT_TIMEOUT_SECONDS = 0
 
2104
        self.overrideAttr(bzrlib.lockdir, '_DEFAULT_TIMEOUT_SECONDS', 0)
1831
2105
 
1832
2106
    def make_utf8_encoded_stringio(self, encoding_type=None):
1833
2107
        """Return a StringIOWrapper instance, that will encode Unicode
1841
2115
        sio.encoding = output_encoding
1842
2116
        return sio
1843
2117
 
 
2118
    def disable_verb(self, verb):
 
2119
        """Disable a smart server verb for one test."""
 
2120
        from bzrlib.smart import request
 
2121
        request_handlers = request.request_handlers
 
2122
        orig_method = request_handlers.get(verb)
 
2123
        request_handlers.remove(verb)
 
2124
        self.addCleanup(request_handlers.register, verb, orig_method)
 
2125
 
1844
2126
 
1845
2127
class CapturedCall(object):
1846
2128
    """A helper for capturing smart server calls for easy debug analysis."""
1905
2187
 
1906
2188
        :param relpath: a path relative to the base url.
1907
2189
        """
1908
 
        t = get_transport(self.get_url(relpath))
 
2190
        t = _mod_transport.get_transport(self.get_url(relpath))
1909
2191
        self.assertFalse(t.is_readonly())
1910
2192
        return t
1911
2193
 
1917
2199
 
1918
2200
        :param relpath: a path relative to the base url.
1919
2201
        """
1920
 
        t = get_transport(self.get_readonly_url(relpath))
 
2202
        t = _mod_transport.get_transport(self.get_readonly_url(relpath))
1921
2203
        self.assertTrue(t.is_readonly())
1922
2204
        return t
1923
2205
 
1936
2218
        if self.__readonly_server is None:
1937
2219
            if self.transport_readonly_server is None:
1938
2220
                # readonly decorator requested
1939
 
                # bring up the server
1940
 
                self.__readonly_server = ReadonlyServer()
1941
 
                self.__readonly_server.setUp(self.get_vfs_only_server())
 
2221
                self.__readonly_server = test_server.ReadonlyServer()
1942
2222
            else:
 
2223
                # explicit readonly transport.
1943
2224
                self.__readonly_server = self.create_transport_readonly_server()
1944
 
                self.__readonly_server.setUp(self.get_vfs_only_server())
1945
 
            self.addCleanup(self.__readonly_server.tearDown)
 
2225
            self.start_server(self.__readonly_server,
 
2226
                self.get_vfs_only_server())
1946
2227
        return self.__readonly_server
1947
2228
 
1948
2229
    def get_readonly_url(self, relpath=None):
1966
2247
        is no means to override it.
1967
2248
        """
1968
2249
        if self.__vfs_server is None:
1969
 
            self.__vfs_server = MemoryServer()
1970
 
            self.__vfs_server.setUp()
1971
 
            self.addCleanup(self.__vfs_server.tearDown)
 
2250
            self.__vfs_server = memory.MemoryServer()
 
2251
            self.start_server(self.__vfs_server)
1972
2252
        return self.__vfs_server
1973
2253
 
1974
2254
    def get_server(self):
1981
2261
        then the self.get_vfs_server is returned.
1982
2262
        """
1983
2263
        if self.__server is None:
1984
 
            if self.transport_server is None or self.transport_server is self.vfs_transport_factory:
1985
 
                return self.get_vfs_only_server()
 
2264
            if (self.transport_server is None or self.transport_server is
 
2265
                self.vfs_transport_factory):
 
2266
                self.__server = self.get_vfs_only_server()
1986
2267
            else:
1987
2268
                # bring up a decorated means of access to the vfs only server.
1988
2269
                self.__server = self.transport_server()
1989
 
                try:
1990
 
                    self.__server.setUp(self.get_vfs_only_server())
1991
 
                except TypeError, e:
1992
 
                    # This should never happen; the try:Except here is to assist
1993
 
                    # developers having to update code rather than seeing an
1994
 
                    # uninformative TypeError.
1995
 
                    raise Exception, "Old server API in use: %s, %s" % (self.__server, e)
1996
 
            self.addCleanup(self.__server.tearDown)
 
2270
                self.start_server(self.__server, self.get_vfs_only_server())
1997
2271
        return self.__server
1998
2272
 
1999
2273
    def _adjust_url(self, base, relpath):
2061
2335
        propagating. This method ensures than a test did not leaked.
2062
2336
        """
2063
2337
        root = TestCaseWithMemoryTransport.TEST_ROOT
 
2338
        self.permit_url(_mod_transport.get_transport(root).base)
2064
2339
        wt = workingtree.WorkingTree.open(root)
2065
2340
        last_rev = wt.last_revision()
2066
2341
        if last_rev != 'null:':
2068
2343
            # recreate a new one or all the followng tests will fail.
2069
2344
            # If you need to inspect its content uncomment the following line
2070
2345
            # import pdb; pdb.set_trace()
2071
 
            _rmtree_temp_dir(root + '/.bzr')
 
2346
            _rmtree_temp_dir(root + '/.bzr', test_id=self.id())
2072
2347
            self._create_safety_net()
2073
2348
            raise AssertionError('%s/.bzr should not be modified' % root)
2074
2349
 
2075
2350
    def _make_test_root(self):
2076
2351
        if TestCaseWithMemoryTransport.TEST_ROOT is None:
2077
 
            root = osutils.mkdtemp(prefix='testbzr-', suffix='.tmp')
 
2352
            # Watch out for tricky test dir (on OSX /tmp -> /private/tmp)
 
2353
            root = osutils.realpath(osutils.mkdtemp(prefix='testbzr-',
 
2354
                                                    suffix='.tmp'))
2078
2355
            TestCaseWithMemoryTransport.TEST_ROOT = root
2079
2356
 
2080
2357
            self._create_safety_net()
2083
2360
            # specifically told when all tests are finished.  This will do.
2084
2361
            atexit.register(_rmtree_temp_dir, root)
2085
2362
 
 
2363
        self.permit_dir(TestCaseWithMemoryTransport.TEST_ROOT)
2086
2364
        self.addCleanup(self._check_safety_net)
2087
2365
 
2088
2366
    def makeAndChdirToTestDir(self):
2096
2374
        os.chdir(TestCaseWithMemoryTransport.TEST_ROOT)
2097
2375
        self.test_dir = TestCaseWithMemoryTransport.TEST_ROOT
2098
2376
        self.test_home_dir = self.test_dir + "/MemoryTransportMissingHomeDir"
 
2377
        self.permit_dir(self.test_dir)
2099
2378
 
2100
2379
    def make_branch(self, relpath, format=None):
2101
2380
        """Create a branch on the transport at relpath."""
2107
2386
            # might be a relative or absolute path
2108
2387
            maybe_a_url = self.get_url(relpath)
2109
2388
            segments = maybe_a_url.rsplit('/', 1)
2110
 
            t = get_transport(maybe_a_url)
 
2389
            t = _mod_transport.get_transport(maybe_a_url)
2111
2390
            if len(segments) > 1 and segments[-1] not in ('', '.'):
2112
2391
                t.ensure_base()
2113
2392
            if format is None:
2130
2409
        made_control = self.make_bzrdir(relpath, format=format)
2131
2410
        return made_control.create_repository(shared=shared)
2132
2411
 
2133
 
    def make_smart_server(self, path):
2134
 
        smart_server = server.SmartTCPServer_for_testing()
2135
 
        smart_server.setUp(self.get_server())
2136
 
        remote_transport = get_transport(smart_server.get_url()).clone(path)
2137
 
        self.addCleanup(smart_server.tearDown)
 
2412
    def make_smart_server(self, path, backing_server=None):
 
2413
        if backing_server is None:
 
2414
            backing_server = self.get_server()
 
2415
        smart_server = test_server.SmartTCPServer_for_testing()
 
2416
        self.start_server(smart_server, backing_server)
 
2417
        remote_transport = _mod_transport.get_transport(smart_server.get_url()
 
2418
                                                   ).clone(path)
2138
2419
        return remote_transport
2139
2420
 
2140
2421
    def make_branch_and_memory_tree(self, relpath, format=None):
2143
2424
        return memorytree.MemoryTree.create_on_branch(b)
2144
2425
 
2145
2426
    def make_branch_builder(self, relpath, format=None):
2146
 
        return branchbuilder.BranchBuilder(self.get_transport(relpath),
2147
 
            format=format)
 
2427
        branch = self.make_branch(relpath, format=format)
 
2428
        return branchbuilder.BranchBuilder(branch=branch)
2148
2429
 
2149
2430
    def overrideEnvironmentForTesting(self):
2150
 
        os.environ['HOME'] = self.test_home_dir
2151
 
        os.environ['BZR_HOME'] = self.test_home_dir
 
2431
        test_home_dir = self.test_home_dir
 
2432
        if isinstance(test_home_dir, unicode):
 
2433
            test_home_dir = test_home_dir.encode(sys.getfilesystemencoding())
 
2434
        os.environ['HOME'] = test_home_dir
 
2435
        os.environ['BZR_HOME'] = test_home_dir
2152
2436
 
2153
2437
    def setUp(self):
2154
2438
        super(TestCaseWithMemoryTransport, self).setUp()
 
2439
        # Ensure that ConnectedTransport doesn't leak sockets
 
2440
        def get_transport_with_cleanup(*args, **kwargs):
 
2441
            t = orig_get_transport(*args, **kwargs)
 
2442
            if isinstance(t, _mod_transport.ConnectedTransport):
 
2443
                self.addCleanup(t.disconnect)
 
2444
            return t
 
2445
 
 
2446
        orig_get_transport = self.overrideAttr(_mod_transport, 'get_transport',
 
2447
                                               get_transport_with_cleanup)
2155
2448
        self._make_test_root()
2156
 
        _currentdir = os.getcwdu()
2157
 
        def _leaveDirectory():
2158
 
            os.chdir(_currentdir)
2159
 
        self.addCleanup(_leaveDirectory)
 
2449
        self.addCleanup(os.chdir, os.getcwdu())
2160
2450
        self.makeAndChdirToTestDir()
2161
2451
        self.overrideEnvironmentForTesting()
2162
2452
        self.__readonly_server = None
2165
2455
 
2166
2456
    def setup_smart_server_with_call_log(self):
2167
2457
        """Sets up a smart server as the transport server with a call log."""
2168
 
        self.transport_server = server.SmartTCPServer_for_testing
 
2458
        self.transport_server = test_server.SmartTCPServer_for_testing
2169
2459
        self.hpss_calls = []
2170
2460
        import traceback
2171
2461
        # Skip the current stack down to the caller of
2205
2495
 
2206
2496
    def check_file_contents(self, filename, expect):
2207
2497
        self.log("check contents of file %s" % filename)
2208
 
        contents = file(filename, 'r').read()
 
2498
        f = file(filename)
 
2499
        try:
 
2500
            contents = f.read()
 
2501
        finally:
 
2502
            f.close()
2209
2503
        if contents != expect:
2210
2504
            self.log("expected: %r" % expect)
2211
2505
            self.log("actually: %r" % contents)
2213
2507
 
2214
2508
    def _getTestDirPrefix(self):
2215
2509
        # create a directory within the top level test directory
2216
 
        if sys.platform == 'win32':
 
2510
        if sys.platform in ('win32', 'cygwin'):
2217
2511
            name_prefix = re.sub('[<>*=+",:;_/\\-]', '_', self.id())
2218
2512
            # windows is likely to have path-length limits so use a short name
2219
2513
            name_prefix = name_prefix[-30:]
2227
2521
        For TestCaseInTempDir we create a temporary directory based on the test
2228
2522
        name and then create two subdirs - test and home under it.
2229
2523
        """
2230
 
        name_prefix = osutils.pathjoin(self.TEST_ROOT, self._getTestDirPrefix())
 
2524
        name_prefix = osutils.pathjoin(TestCaseWithMemoryTransport.TEST_ROOT,
 
2525
            self._getTestDirPrefix())
2231
2526
        name = name_prefix
2232
2527
        for i in range(100):
2233
2528
            if os.path.exists(name):
2234
2529
                name = name_prefix + '_' + str(i)
2235
2530
            else:
2236
 
                os.mkdir(name)
 
2531
                # now create test and home directories within this dir
 
2532
                self.test_base_dir = name
 
2533
                self.addCleanup(self.deleteTestDir)
 
2534
                os.mkdir(self.test_base_dir)
2237
2535
                break
2238
 
        # now create test and home directories within this dir
2239
 
        self.test_base_dir = name
 
2536
        self.permit_dir(self.test_base_dir)
 
2537
        # 'sprouting' and 'init' of a branch both walk up the tree to find
 
2538
        # stacking policy to honour; create a bzr dir with an unshared
 
2539
        # repository (but not a branch - our code would be trying to escape
 
2540
        # then!) to stop them, and permit it to be read.
 
2541
        # control = bzrdir.BzrDir.create(self.test_base_dir)
 
2542
        # control.create_repository()
2240
2543
        self.test_home_dir = self.test_base_dir + '/home'
2241
2544
        os.mkdir(self.test_home_dir)
2242
2545
        self.test_dir = self.test_base_dir + '/work'
2248
2551
            f.write(self.id())
2249
2552
        finally:
2250
2553
            f.close()
2251
 
        self.addCleanup(self.deleteTestDir)
2252
2554
 
2253
2555
    def deleteTestDir(self):
2254
 
        os.chdir(self.TEST_ROOT)
2255
 
        _rmtree_temp_dir(self.test_base_dir)
 
2556
        os.chdir(TestCaseWithMemoryTransport.TEST_ROOT)
 
2557
        _rmtree_temp_dir(self.test_base_dir, test_id=self.id())
2256
2558
 
2257
2559
    def build_tree(self, shape, line_endings='binary', transport=None):
2258
2560
        """Build a test tree according to a pattern.
2277
2579
                "a list or a tuple. Got %r instead" % (shape,))
2278
2580
        # It's OK to just create them using forward slashes on windows.
2279
2581
        if transport is None or transport.is_readonly():
2280
 
            transport = get_transport(".")
 
2582
            transport = _mod_transport.get_transport(".")
2281
2583
        for name in shape:
2282
2584
            self.assertIsInstance(name, basestring)
2283
2585
            if name[-1] == '/':
2293
2595
                content = "contents of %s%s" % (name.encode('utf-8'), end)
2294
2596
                transport.put_bytes_non_atomic(urlutils.escape(name), content)
2295
2597
 
2296
 
    def build_tree_contents(self, shape):
2297
 
        build_tree_contents(shape)
 
2598
    build_tree_contents = staticmethod(treeshape.build_tree_contents)
2298
2599
 
2299
2600
    def assertInWorkingTree(self, path, root_path='.', tree=None):
2300
2601
        """Assert whether path or paths are in the WorkingTree"""
2340
2641
        """
2341
2642
        if self.__vfs_server is None:
2342
2643
            self.__vfs_server = self.vfs_transport_factory()
2343
 
            self.__vfs_server.setUp()
2344
 
            self.addCleanup(self.__vfs_server.tearDown)
 
2644
            self.start_server(self.__vfs_server)
2345
2645
        return self.__vfs_server
2346
2646
 
2347
2647
    def make_branch_and_tree(self, relpath, format=None):
2354
2654
        repository will also be accessed locally. Otherwise a lightweight
2355
2655
        checkout is created and returned.
2356
2656
 
 
2657
        We do this because we can't physically create a tree in the local
 
2658
        path, with a branch reference to the transport_factory url, and
 
2659
        a branch + repository in the vfs_transport, unless the vfs_transport
 
2660
        namespace is distinct from the local disk - the two branch objects
 
2661
        would collide. While we could construct a tree with its branch object
 
2662
        pointing at the transport_factory transport in memory, reopening it
 
2663
        would behaving unexpectedly, and has in the past caused testing bugs
 
2664
        when we tried to do it that way.
 
2665
 
2357
2666
        :param format: The BzrDirFormat.
2358
2667
        :returns: the WorkingTree.
2359
2668
        """
2368
2677
            # We can only make working trees locally at the moment.  If the
2369
2678
            # transport can't support them, then we keep the non-disk-backed
2370
2679
            # branch and create a local checkout.
2371
 
            if self.vfs_transport_factory is LocalURLServer:
 
2680
            if self.vfs_transport_factory is test_server.LocalURLServer:
2372
2681
                # the branch is colocated on disk, we cannot create a checkout.
2373
2682
                # hopefully callers will expect this.
2374
2683
                local_controldir= bzrdir.BzrDir.open(self.get_vfs_only_url(relpath))
2411
2720
        super(TestCaseWithTransport, self).setUp()
2412
2721
        self.__vfs_server = None
2413
2722
 
 
2723
    def disable_missing_extensions_warning(self):
 
2724
        """Some tests expect a precise stderr content.
 
2725
 
 
2726
        There is no point in forcing them to duplicate the extension related
 
2727
        warning.
 
2728
        """
 
2729
        config.GlobalConfig().set_user_option('ignore_missing_extensions', True)
 
2730
 
2414
2731
 
2415
2732
class ChrootedTestCase(TestCaseWithTransport):
2416
2733
    """A support class that provides readonly urls outside the local namespace.
2425
2742
    """
2426
2743
 
2427
2744
    def setUp(self):
 
2745
        from bzrlib.tests import http_server
2428
2746
        super(ChrootedTestCase, self).setUp()
2429
 
        if not self.vfs_transport_factory == MemoryServer:
2430
 
            self.transport_readonly_server = HttpServer
 
2747
        if not self.vfs_transport_factory == memory.MemoryServer:
 
2748
            self.transport_readonly_server = http_server.HttpServer
2431
2749
 
2432
2750
 
2433
2751
def condition_id_re(pattern):
2436
2754
    :param pattern: A regular expression string.
2437
2755
    :return: A callable that returns True if the re matches.
2438
2756
    """
2439
 
    filter_re = osutils.re_compile_checked(pattern, 0,
2440
 
        'test filter')
 
2757
    filter_re = re.compile(pattern, 0)
2441
2758
    def condition(test):
2442
2759
        test_id = test.id()
2443
2760
        return filter_re.search(test_id)
2629
2946
              exclude_pattern=None,
2630
2947
              strict=False,
2631
2948
              runner_class=None,
2632
 
              suite_decorators=None):
 
2949
              suite_decorators=None,
 
2950
              stream=None,
 
2951
              result_decorators=None,
 
2952
              ):
2633
2953
    """Run a test suite for bzr selftest.
2634
2954
 
2635
2955
    :param runner_class: The class of runner to use. Must support the
2644
2964
        verbosity = 1
2645
2965
    if runner_class is None:
2646
2966
        runner_class = TextTestRunner
2647
 
    runner = runner_class(stream=sys.stdout,
 
2967
    if stream is None:
 
2968
        stream = sys.stdout
 
2969
    runner = runner_class(stream=stream,
2648
2970
                            descriptions=0,
2649
2971
                            verbosity=verbosity,
2650
2972
                            bench_history=bench_history,
2651
 
                            list_only=list_only,
 
2973
                            strict=strict,
 
2974
                            result_decorators=result_decorators,
2652
2975
                            )
2653
2976
    runner.stop_on_failure=stop_on_failure
2654
2977
    # built in decorator factories:
2662
2985
        decorators.append(filter_tests(pattern))
2663
2986
    if suite_decorators:
2664
2987
        decorators.extend(suite_decorators)
 
2988
    # tell the result object how many tests will be running: (except if
 
2989
    # --parallel=fork is being used. Robert said he will provide a better
 
2990
    # progress design later -- vila 20090817)
 
2991
    if fork_decorator not in decorators:
 
2992
        decorators.append(CountingDecorator)
2665
2993
    for decorator in decorators:
2666
2994
        suite = decorator(suite)
 
2995
    if list_only:
 
2996
        # Done after test suite decoration to allow randomisation etc
 
2997
        # to take effect, though that is of marginal benefit.
 
2998
        if verbosity >= 2:
 
2999
            stream.write("Listing tests only ...\n")
 
3000
        for t in iter_suite_tests(suite):
 
3001
            stream.write("%s\n" % (t.id()))
 
3002
        return True
2667
3003
    result = runner.run(suite)
2668
3004
    if strict:
2669
3005
        return result.wasStrictlySuccessful()
2671
3007
        return result.wasSuccessful()
2672
3008
 
2673
3009
 
 
3010
# A registry where get() returns a suite decorator.
 
3011
parallel_registry = registry.Registry()
 
3012
 
 
3013
 
 
3014
def fork_decorator(suite):
 
3015
    concurrency = osutils.local_concurrency()
 
3016
    if concurrency == 1:
 
3017
        return suite
 
3018
    from testtools import ConcurrentTestSuite
 
3019
    return ConcurrentTestSuite(suite, fork_for_tests)
 
3020
parallel_registry.register('fork', fork_decorator)
 
3021
 
 
3022
 
 
3023
def subprocess_decorator(suite):
 
3024
    concurrency = osutils.local_concurrency()
 
3025
    if concurrency == 1:
 
3026
        return suite
 
3027
    from testtools import ConcurrentTestSuite
 
3028
    return ConcurrentTestSuite(suite, reinvoke_for_tests)
 
3029
parallel_registry.register('subprocess', subprocess_decorator)
 
3030
 
 
3031
 
2674
3032
def exclude_tests(exclude_pattern):
2675
3033
    """Return a test suite decorator that excludes tests."""
2676
3034
    if exclude_pattern is None:
2714
3072
    return suite
2715
3073
 
2716
3074
 
2717
 
class TestDecorator(TestSuite):
 
3075
class TestDecorator(TestUtil.TestSuite):
2718
3076
    """A decorator for TestCase/TestSuite objects.
2719
3077
    
2720
3078
    Usually, subclasses should override __iter__(used when flattening test
2723
3081
    """
2724
3082
 
2725
3083
    def __init__(self, suite):
2726
 
        TestSuite.__init__(self)
 
3084
        TestUtil.TestSuite.__init__(self)
2727
3085
        self.addTest(suite)
2728
3086
 
2729
3087
    def countTestCases(self):
2746
3104
        return result
2747
3105
 
2748
3106
 
 
3107
class CountingDecorator(TestDecorator):
 
3108
    """A decorator which calls result.progress(self.countTestCases)."""
 
3109
 
 
3110
    def run(self, result):
 
3111
        progress_method = getattr(result, 'progress', None)
 
3112
        if callable(progress_method):
 
3113
            progress_method(self.countTestCases(), SUBUNIT_SEEK_SET)
 
3114
        return super(CountingDecorator, self).run(result)
 
3115
 
 
3116
 
2749
3117
class ExcludeDecorator(TestDecorator):
2750
3118
    """A decorator which excludes test matching an exclude pattern."""
2751
3119
 
2795
3163
        if self.randomised:
2796
3164
            return iter(self._tests)
2797
3165
        self.randomised = True
2798
 
        self.stream.writeln("Randomizing test order using seed %s\n" %
 
3166
        self.stream.write("Randomizing test order using seed %s\n\n" %
2799
3167
            (self.actual_seed()))
2800
3168
        # Initialise the random number generator.
2801
3169
        random.seed(self.actual_seed())
2836
3204
        return iter(self._tests)
2837
3205
 
2838
3206
 
 
3207
def partition_tests(suite, count):
 
3208
    """Partition suite into count lists of tests."""
 
3209
    # This just assigns tests in a round-robin fashion.  On one hand this
 
3210
    # splits up blocks of related tests that might run faster if they shared
 
3211
    # resources, but on the other it avoids assigning blocks of slow tests to
 
3212
    # just one partition.  So the slowest partition shouldn't be much slower
 
3213
    # than the fastest.
 
3214
    partitions = [list() for i in range(count)]
 
3215
    tests = iter_suite_tests(suite)
 
3216
    for partition, test in itertools.izip(itertools.cycle(partitions), tests):
 
3217
        partition.append(test)
 
3218
    return partitions
 
3219
 
 
3220
 
 
3221
def workaround_zealous_crypto_random():
 
3222
    """Crypto.Random want to help us being secure, but we don't care here.
 
3223
 
 
3224
    This workaround some test failure related to the sftp server. Once paramiko
 
3225
    stop using the controversial API in Crypto.Random, we may get rid of it.
 
3226
    """
 
3227
    try:
 
3228
        from Crypto.Random import atfork
 
3229
        atfork()
 
3230
    except ImportError:
 
3231
        pass
 
3232
 
 
3233
 
 
3234
def fork_for_tests(suite):
 
3235
    """Take suite and start up one runner per CPU by forking()
 
3236
 
 
3237
    :return: An iterable of TestCase-like objects which can each have
 
3238
        run(result) called on them to feed tests to result.
 
3239
    """
 
3240
    concurrency = osutils.local_concurrency()
 
3241
    result = []
 
3242
    from subunit import TestProtocolClient, ProtocolTestCase
 
3243
    from subunit.test_results import AutoTimingTestResultDecorator
 
3244
    class TestInOtherProcess(ProtocolTestCase):
 
3245
        # Should be in subunit, I think. RBC.
 
3246
        def __init__(self, stream, pid):
 
3247
            ProtocolTestCase.__init__(self, stream)
 
3248
            self.pid = pid
 
3249
 
 
3250
        def run(self, result):
 
3251
            try:
 
3252
                ProtocolTestCase.run(self, result)
 
3253
            finally:
 
3254
                os.waitpid(self.pid, 0)
 
3255
 
 
3256
    test_blocks = partition_tests(suite, concurrency)
 
3257
    for process_tests in test_blocks:
 
3258
        process_suite = TestUtil.TestSuite()
 
3259
        process_suite.addTests(process_tests)
 
3260
        c2pread, c2pwrite = os.pipe()
 
3261
        pid = os.fork()
 
3262
        if pid == 0:
 
3263
            workaround_zealous_crypto_random()
 
3264
            try:
 
3265
                os.close(c2pread)
 
3266
                # Leave stderr and stdout open so we can see test noise
 
3267
                # Close stdin so that the child goes away if it decides to
 
3268
                # read from stdin (otherwise its a roulette to see what
 
3269
                # child actually gets keystrokes for pdb etc).
 
3270
                sys.stdin.close()
 
3271
                sys.stdin = None
 
3272
                stream = os.fdopen(c2pwrite, 'wb', 1)
 
3273
                subunit_result = AutoTimingTestResultDecorator(
 
3274
                    TestProtocolClient(stream))
 
3275
                process_suite.run(subunit_result)
 
3276
            finally:
 
3277
                os._exit(0)
 
3278
        else:
 
3279
            os.close(c2pwrite)
 
3280
            stream = os.fdopen(c2pread, 'rb', 1)
 
3281
            test = TestInOtherProcess(stream, pid)
 
3282
            result.append(test)
 
3283
    return result
 
3284
 
 
3285
 
 
3286
def reinvoke_for_tests(suite):
 
3287
    """Take suite and start up one runner per CPU using subprocess().
 
3288
 
 
3289
    :return: An iterable of TestCase-like objects which can each have
 
3290
        run(result) called on them to feed tests to result.
 
3291
    """
 
3292
    concurrency = osutils.local_concurrency()
 
3293
    result = []
 
3294
    from subunit import ProtocolTestCase
 
3295
    class TestInSubprocess(ProtocolTestCase):
 
3296
        def __init__(self, process, name):
 
3297
            ProtocolTestCase.__init__(self, process.stdout)
 
3298
            self.process = process
 
3299
            self.process.stdin.close()
 
3300
            self.name = name
 
3301
 
 
3302
        def run(self, result):
 
3303
            try:
 
3304
                ProtocolTestCase.run(self, result)
 
3305
            finally:
 
3306
                self.process.wait()
 
3307
                os.unlink(self.name)
 
3308
            # print "pid %d finished" % finished_process
 
3309
    test_blocks = partition_tests(suite, concurrency)
 
3310
    for process_tests in test_blocks:
 
3311
        # ugly; currently reimplement rather than reuses TestCase methods.
 
3312
        bzr_path = os.path.dirname(os.path.dirname(bzrlib.__file__))+'/bzr'
 
3313
        if not os.path.isfile(bzr_path):
 
3314
            # We are probably installed. Assume sys.argv is the right file
 
3315
            bzr_path = sys.argv[0]
 
3316
        bzr_path = [bzr_path]
 
3317
        if sys.platform == "win32":
 
3318
            # if we're on windows, we can't execute the bzr script directly
 
3319
            bzr_path = [sys.executable] + bzr_path
 
3320
        fd, test_list_file_name = tempfile.mkstemp()
 
3321
        test_list_file = os.fdopen(fd, 'wb', 1)
 
3322
        for test in process_tests:
 
3323
            test_list_file.write(test.id() + '\n')
 
3324
        test_list_file.close()
 
3325
        try:
 
3326
            argv = bzr_path + ['selftest', '--load-list', test_list_file_name,
 
3327
                '--subunit']
 
3328
            if '--no-plugins' in sys.argv:
 
3329
                argv.append('--no-plugins')
 
3330
            # stderr=subprocess.STDOUT would be ideal, but until we prevent
 
3331
            # noise on stderr it can interrupt the subunit protocol.
 
3332
            process = subprocess.Popen(argv, stdin=subprocess.PIPE,
 
3333
                                      stdout=subprocess.PIPE,
 
3334
                                      stderr=subprocess.PIPE,
 
3335
                                      bufsize=1)
 
3336
            test = TestInSubprocess(process, test_list_file_name)
 
3337
            result.append(test)
 
3338
        except:
 
3339
            os.unlink(test_list_file_name)
 
3340
            raise
 
3341
    return result
 
3342
 
 
3343
 
 
3344
class ForwardingResult(unittest.TestResult):
 
3345
 
 
3346
    def __init__(self, target):
 
3347
        unittest.TestResult.__init__(self)
 
3348
        self.result = target
 
3349
 
 
3350
    def startTest(self, test):
 
3351
        self.result.startTest(test)
 
3352
 
 
3353
    def stopTest(self, test):
 
3354
        self.result.stopTest(test)
 
3355
 
 
3356
    def startTestRun(self):
 
3357
        self.result.startTestRun()
 
3358
 
 
3359
    def stopTestRun(self):
 
3360
        self.result.stopTestRun()
 
3361
 
 
3362
    def addSkip(self, test, reason):
 
3363
        self.result.addSkip(test, reason)
 
3364
 
 
3365
    def addSuccess(self, test):
 
3366
        self.result.addSuccess(test)
 
3367
 
 
3368
    def addError(self, test, err):
 
3369
        self.result.addError(test, err)
 
3370
 
 
3371
    def addFailure(self, test, err):
 
3372
        self.result.addFailure(test, err)
 
3373
ForwardingResult = testtools.ExtendedToOriginalDecorator
 
3374
 
 
3375
 
 
3376
class ProfileResult(ForwardingResult):
 
3377
    """Generate profiling data for all activity between start and success.
 
3378
    
 
3379
    The profile data is appended to the test's _benchcalls attribute and can
 
3380
    be accessed by the forwarded-to TestResult.
 
3381
 
 
3382
    While it might be cleaner do accumulate this in stopTest, addSuccess is
 
3383
    where our existing output support for lsprof is, and this class aims to
 
3384
    fit in with that: while it could be moved it's not necessary to accomplish
 
3385
    test profiling, nor would it be dramatically cleaner.
 
3386
    """
 
3387
 
 
3388
    def startTest(self, test):
 
3389
        self.profiler = bzrlib.lsprof.BzrProfiler()
 
3390
        # Prevent deadlocks in tests that use lsprof: those tests will
 
3391
        # unavoidably fail.
 
3392
        bzrlib.lsprof.BzrProfiler.profiler_block = 0
 
3393
        self.profiler.start()
 
3394
        ForwardingResult.startTest(self, test)
 
3395
 
 
3396
    def addSuccess(self, test):
 
3397
        stats = self.profiler.stop()
 
3398
        try:
 
3399
            calls = test._benchcalls
 
3400
        except AttributeError:
 
3401
            test._benchcalls = []
 
3402
            calls = test._benchcalls
 
3403
        calls.append(((test.id(), "", ""), stats))
 
3404
        ForwardingResult.addSuccess(self, test)
 
3405
 
 
3406
    def stopTest(self, test):
 
3407
        ForwardingResult.stopTest(self, test)
 
3408
        self.profiler = None
 
3409
 
 
3410
 
2839
3411
# Controlled by "bzr selftest -E=..." option
 
3412
# Currently supported:
 
3413
#   -Eallow_debug           Will no longer clear debug.debug_flags() so it
 
3414
#                           preserves any flags supplied at the command line.
 
3415
#   -Edisable_lock_checks   Turns errors in mismatched locks into simple prints
 
3416
#                           rather than failing tests. And no longer raise
 
3417
#                           LockContention when fctnl locks are not being used
 
3418
#                           with proper exclusion rules.
 
3419
#   -Ethreads               Will display thread ident at creation/join time to
 
3420
#                           help track thread leaks
2840
3421
selftest_debug_flags = set()
2841
3422
 
2842
3423
 
2854
3435
             debug_flags=None,
2855
3436
             starting_with=None,
2856
3437
             runner_class=None,
 
3438
             suite_decorators=None,
 
3439
             stream=None,
 
3440
             lsprof_tests=False,
2857
3441
             ):
2858
3442
    """Run the whole test suite under the enhanced runner"""
2859
3443
    # XXX: Very ugly way to do this...
2876
3460
            keep_only = None
2877
3461
        else:
2878
3462
            keep_only = load_test_id_list(load_list)
 
3463
        if starting_with:
 
3464
            starting_with = [test_prefix_alias_registry.resolve_alias(start)
 
3465
                             for start in starting_with]
2879
3466
        if test_suite_factory is None:
 
3467
            # Reduce loading time by loading modules based on the starting_with
 
3468
            # patterns.
2880
3469
            suite = test_suite(keep_only, starting_with)
2881
3470
        else:
2882
3471
            suite = test_suite_factory()
 
3472
        if starting_with:
 
3473
            # But always filter as requested.
 
3474
            suite = filter_suite_by_id_startswith(suite, starting_with)
 
3475
        result_decorators = []
 
3476
        if lsprof_tests:
 
3477
            result_decorators.append(ProfileResult)
2883
3478
        return run_suite(suite, 'testbzr', verbose=verbose, pattern=pattern,
2884
3479
                     stop_on_failure=stop_on_failure,
2885
3480
                     transport=transport,
2891
3486
                     exclude_pattern=exclude_pattern,
2892
3487
                     strict=strict,
2893
3488
                     runner_class=runner_class,
 
3489
                     suite_decorators=suite_decorators,
 
3490
                     stream=stream,
 
3491
                     result_decorators=result_decorators,
2894
3492
                     )
2895
3493
    finally:
2896
3494
        default_transport = old_transport
3044
3642
# appear prefixed ('bzrlib.' is "replaced" by 'bzrlib.').
3045
3643
test_prefix_alias_registry.register('bzrlib', 'bzrlib')
3046
3644
 
3047
 
# Obvious higest levels prefixes, feel free to add your own via a plugin
 
3645
# Obvious highest levels prefixes, feel free to add your own via a plugin
3048
3646
test_prefix_alias_registry.register('bd', 'bzrlib.doc')
3049
3647
test_prefix_alias_registry.register('bu', 'bzrlib.utils')
3050
3648
test_prefix_alias_registry.register('bt', 'bzrlib.tests')
3052
3650
test_prefix_alias_registry.register('bp', 'bzrlib.plugins')
3053
3651
 
3054
3652
 
 
3653
def _test_suite_testmod_names():
 
3654
    """Return the standard list of test module names to test."""
 
3655
    return [
 
3656
        'bzrlib.doc',
 
3657
        'bzrlib.tests.blackbox',
 
3658
        'bzrlib.tests.commands',
 
3659
        'bzrlib.tests.doc_generate',
 
3660
        'bzrlib.tests.per_branch',
 
3661
        'bzrlib.tests.per_controldir',
 
3662
        'bzrlib.tests.per_controldir_colo',
 
3663
        'bzrlib.tests.per_foreign_vcs',
 
3664
        'bzrlib.tests.per_interrepository',
 
3665
        'bzrlib.tests.per_intertree',
 
3666
        'bzrlib.tests.per_inventory',
 
3667
        'bzrlib.tests.per_interbranch',
 
3668
        'bzrlib.tests.per_lock',
 
3669
        'bzrlib.tests.per_merger',
 
3670
        'bzrlib.tests.per_transport',
 
3671
        'bzrlib.tests.per_tree',
 
3672
        'bzrlib.tests.per_pack_repository',
 
3673
        'bzrlib.tests.per_repository',
 
3674
        'bzrlib.tests.per_repository_chk',
 
3675
        'bzrlib.tests.per_repository_reference',
 
3676
        'bzrlib.tests.per_uifactory',
 
3677
        'bzrlib.tests.per_versionedfile',
 
3678
        'bzrlib.tests.per_workingtree',
 
3679
        'bzrlib.tests.test__annotator',
 
3680
        'bzrlib.tests.test__bencode',
 
3681
        'bzrlib.tests.test__btree_serializer',
 
3682
        'bzrlib.tests.test__chk_map',
 
3683
        'bzrlib.tests.test__dirstate_helpers',
 
3684
        'bzrlib.tests.test__groupcompress',
 
3685
        'bzrlib.tests.test__known_graph',
 
3686
        'bzrlib.tests.test__rio',
 
3687
        'bzrlib.tests.test__simple_set',
 
3688
        'bzrlib.tests.test__static_tuple',
 
3689
        'bzrlib.tests.test__walkdirs_win32',
 
3690
        'bzrlib.tests.test_ancestry',
 
3691
        'bzrlib.tests.test_annotate',
 
3692
        'bzrlib.tests.test_api',
 
3693
        'bzrlib.tests.test_atomicfile',
 
3694
        'bzrlib.tests.test_bad_files',
 
3695
        'bzrlib.tests.test_bisect_multi',
 
3696
        'bzrlib.tests.test_branch',
 
3697
        'bzrlib.tests.test_branchbuilder',
 
3698
        'bzrlib.tests.test_btree_index',
 
3699
        'bzrlib.tests.test_bugtracker',
 
3700
        'bzrlib.tests.test_bundle',
 
3701
        'bzrlib.tests.test_bzrdir',
 
3702
        'bzrlib.tests.test__chunks_to_lines',
 
3703
        'bzrlib.tests.test_cache_utf8',
 
3704
        'bzrlib.tests.test_chk_map',
 
3705
        'bzrlib.tests.test_chk_serializer',
 
3706
        'bzrlib.tests.test_chunk_writer',
 
3707
        'bzrlib.tests.test_clean_tree',
 
3708
        'bzrlib.tests.test_cleanup',
 
3709
        'bzrlib.tests.test_cmdline',
 
3710
        'bzrlib.tests.test_commands',
 
3711
        'bzrlib.tests.test_commit',
 
3712
        'bzrlib.tests.test_commit_merge',
 
3713
        'bzrlib.tests.test_config',
 
3714
        'bzrlib.tests.test_conflicts',
 
3715
        'bzrlib.tests.test_counted_lock',
 
3716
        'bzrlib.tests.test_crash',
 
3717
        'bzrlib.tests.test_decorators',
 
3718
        'bzrlib.tests.test_delta',
 
3719
        'bzrlib.tests.test_debug',
 
3720
        'bzrlib.tests.test_deprecated_graph',
 
3721
        'bzrlib.tests.test_diff',
 
3722
        'bzrlib.tests.test_directory_service',
 
3723
        'bzrlib.tests.test_dirstate',
 
3724
        'bzrlib.tests.test_email_message',
 
3725
        'bzrlib.tests.test_eol_filters',
 
3726
        'bzrlib.tests.test_errors',
 
3727
        'bzrlib.tests.test_export',
 
3728
        'bzrlib.tests.test_extract',
 
3729
        'bzrlib.tests.test_fetch',
 
3730
        'bzrlib.tests.test_fixtures',
 
3731
        'bzrlib.tests.test_fifo_cache',
 
3732
        'bzrlib.tests.test_filters',
 
3733
        'bzrlib.tests.test_ftp_transport',
 
3734
        'bzrlib.tests.test_foreign',
 
3735
        'bzrlib.tests.test_generate_docs',
 
3736
        'bzrlib.tests.test_generate_ids',
 
3737
        'bzrlib.tests.test_globbing',
 
3738
        'bzrlib.tests.test_gpg',
 
3739
        'bzrlib.tests.test_graph',
 
3740
        'bzrlib.tests.test_groupcompress',
 
3741
        'bzrlib.tests.test_hashcache',
 
3742
        'bzrlib.tests.test_help',
 
3743
        'bzrlib.tests.test_hooks',
 
3744
        'bzrlib.tests.test_http',
 
3745
        'bzrlib.tests.test_http_response',
 
3746
        'bzrlib.tests.test_https_ca_bundle',
 
3747
        'bzrlib.tests.test_identitymap',
 
3748
        'bzrlib.tests.test_ignores',
 
3749
        'bzrlib.tests.test_index',
 
3750
        'bzrlib.tests.test_import_tariff',
 
3751
        'bzrlib.tests.test_info',
 
3752
        'bzrlib.tests.test_inv',
 
3753
        'bzrlib.tests.test_inventory_delta',
 
3754
        'bzrlib.tests.test_knit',
 
3755
        'bzrlib.tests.test_lazy_import',
 
3756
        'bzrlib.tests.test_lazy_regex',
 
3757
        'bzrlib.tests.test_library_state',
 
3758
        'bzrlib.tests.test_lock',
 
3759
        'bzrlib.tests.test_lockable_files',
 
3760
        'bzrlib.tests.test_lockdir',
 
3761
        'bzrlib.tests.test_log',
 
3762
        'bzrlib.tests.test_lru_cache',
 
3763
        'bzrlib.tests.test_lsprof',
 
3764
        'bzrlib.tests.test_mail_client',
 
3765
        'bzrlib.tests.test_matchers',
 
3766
        'bzrlib.tests.test_memorytree',
 
3767
        'bzrlib.tests.test_merge',
 
3768
        'bzrlib.tests.test_merge3',
 
3769
        'bzrlib.tests.test_merge_core',
 
3770
        'bzrlib.tests.test_merge_directive',
 
3771
        'bzrlib.tests.test_missing',
 
3772
        'bzrlib.tests.test_msgeditor',
 
3773
        'bzrlib.tests.test_multiparent',
 
3774
        'bzrlib.tests.test_mutabletree',
 
3775
        'bzrlib.tests.test_nonascii',
 
3776
        'bzrlib.tests.test_options',
 
3777
        'bzrlib.tests.test_osutils',
 
3778
        'bzrlib.tests.test_osutils_encodings',
 
3779
        'bzrlib.tests.test_pack',
 
3780
        'bzrlib.tests.test_patch',
 
3781
        'bzrlib.tests.test_patches',
 
3782
        'bzrlib.tests.test_permissions',
 
3783
        'bzrlib.tests.test_plugins',
 
3784
        'bzrlib.tests.test_progress',
 
3785
        'bzrlib.tests.test_read_bundle',
 
3786
        'bzrlib.tests.test_reconcile',
 
3787
        'bzrlib.tests.test_reconfigure',
 
3788
        'bzrlib.tests.test_registry',
 
3789
        'bzrlib.tests.test_remote',
 
3790
        'bzrlib.tests.test_rename_map',
 
3791
        'bzrlib.tests.test_repository',
 
3792
        'bzrlib.tests.test_revert',
 
3793
        'bzrlib.tests.test_revision',
 
3794
        'bzrlib.tests.test_revisionspec',
 
3795
        'bzrlib.tests.test_revisiontree',
 
3796
        'bzrlib.tests.test_rio',
 
3797
        'bzrlib.tests.test_rules',
 
3798
        'bzrlib.tests.test_sampler',
 
3799
        'bzrlib.tests.test_script',
 
3800
        'bzrlib.tests.test_selftest',
 
3801
        'bzrlib.tests.test_serializer',
 
3802
        'bzrlib.tests.test_setup',
 
3803
        'bzrlib.tests.test_sftp_transport',
 
3804
        'bzrlib.tests.test_shelf',
 
3805
        'bzrlib.tests.test_shelf_ui',
 
3806
        'bzrlib.tests.test_smart',
 
3807
        'bzrlib.tests.test_smart_add',
 
3808
        'bzrlib.tests.test_smart_request',
 
3809
        'bzrlib.tests.test_smart_transport',
 
3810
        'bzrlib.tests.test_smtp_connection',
 
3811
        'bzrlib.tests.test_source',
 
3812
        'bzrlib.tests.test_ssh_transport',
 
3813
        'bzrlib.tests.test_status',
 
3814
        'bzrlib.tests.test_store',
 
3815
        'bzrlib.tests.test_strace',
 
3816
        'bzrlib.tests.test_subsume',
 
3817
        'bzrlib.tests.test_switch',
 
3818
        'bzrlib.tests.test_symbol_versioning',
 
3819
        'bzrlib.tests.test_tag',
 
3820
        'bzrlib.tests.test_test_server',
 
3821
        'bzrlib.tests.test_testament',
 
3822
        'bzrlib.tests.test_textfile',
 
3823
        'bzrlib.tests.test_textmerge',
 
3824
        'bzrlib.tests.test_timestamp',
 
3825
        'bzrlib.tests.test_trace',
 
3826
        'bzrlib.tests.test_transactions',
 
3827
        'bzrlib.tests.test_transform',
 
3828
        'bzrlib.tests.test_transport',
 
3829
        'bzrlib.tests.test_transport_log',
 
3830
        'bzrlib.tests.test_tree',
 
3831
        'bzrlib.tests.test_treebuilder',
 
3832
        'bzrlib.tests.test_treeshape',
 
3833
        'bzrlib.tests.test_tsort',
 
3834
        'bzrlib.tests.test_tuned_gzip',
 
3835
        'bzrlib.tests.test_ui',
 
3836
        'bzrlib.tests.test_uncommit',
 
3837
        'bzrlib.tests.test_upgrade',
 
3838
        'bzrlib.tests.test_upgrade_stacked',
 
3839
        'bzrlib.tests.test_urlutils',
 
3840
        'bzrlib.tests.test_version',
 
3841
        'bzrlib.tests.test_version_info',
 
3842
        'bzrlib.tests.test_versionedfile',
 
3843
        'bzrlib.tests.test_weave',
 
3844
        'bzrlib.tests.test_whitebox',
 
3845
        'bzrlib.tests.test_win32utils',
 
3846
        'bzrlib.tests.test_workingtree',
 
3847
        'bzrlib.tests.test_workingtree_4',
 
3848
        'bzrlib.tests.test_wsgi',
 
3849
        'bzrlib.tests.test_xml',
 
3850
        ]
 
3851
 
 
3852
 
 
3853
def _test_suite_modules_to_doctest():
 
3854
    """Return the list of modules to doctest."""
 
3855
    if __doc__ is None:
 
3856
        # GZ 2009-03-31: No docstrings with -OO so there's nothing to doctest
 
3857
        return []
 
3858
    return [
 
3859
        'bzrlib',
 
3860
        'bzrlib.branchbuilder',
 
3861
        'bzrlib.decorators',
 
3862
        'bzrlib.export',
 
3863
        'bzrlib.inventory',
 
3864
        'bzrlib.iterablefile',
 
3865
        'bzrlib.lockdir',
 
3866
        'bzrlib.merge3',
 
3867
        'bzrlib.option',
 
3868
        'bzrlib.symbol_versioning',
 
3869
        'bzrlib.tests',
 
3870
        'bzrlib.tests.fixtures',
 
3871
        'bzrlib.timestamp',
 
3872
        'bzrlib.version_info_formats.format_custom',
 
3873
        ]
 
3874
 
 
3875
 
3055
3876
def test_suite(keep_only=None, starting_with=None):
3056
3877
    """Build and return TestSuite for the whole of bzrlib.
3057
3878
 
3063
3884
    This function can be replaced if you need to change the default test
3064
3885
    suite on a global basis, but it is not encouraged.
3065
3886
    """
3066
 
    testmod_names = [
3067
 
                   'bzrlib.doc',
3068
 
                   'bzrlib.tests.blackbox',
3069
 
                   'bzrlib.tests.branch_implementations',
3070
 
                   'bzrlib.tests.bzrdir_implementations',
3071
 
                   'bzrlib.tests.commands',
3072
 
                   'bzrlib.tests.interrepository_implementations',
3073
 
                   'bzrlib.tests.intertree_implementations',
3074
 
                   'bzrlib.tests.inventory_implementations',
3075
 
                   'bzrlib.tests.per_interbranch',
3076
 
                   'bzrlib.tests.per_lock',
3077
 
                   'bzrlib.tests.per_repository',
3078
 
                   'bzrlib.tests.per_repository_chk',
3079
 
                   'bzrlib.tests.per_repository_reference',
3080
 
                   'bzrlib.tests.test__chk_map',
3081
 
                   'bzrlib.tests.test__dirstate_helpers',
3082
 
                   'bzrlib.tests.test__groupcompress',
3083
 
                   'bzrlib.tests.test__walkdirs_win32',
3084
 
                   'bzrlib.tests.test_ancestry',
3085
 
                   'bzrlib.tests.test_annotate',
3086
 
                   'bzrlib.tests.test_api',
3087
 
                   'bzrlib.tests.test_atomicfile',
3088
 
                   'bzrlib.tests.test_bad_files',
3089
 
                   'bzrlib.tests.test_bisect_multi',
3090
 
                   'bzrlib.tests.test_branch',
3091
 
                   'bzrlib.tests.test_branchbuilder',
3092
 
                   'bzrlib.tests.test_btree_index',
3093
 
                   'bzrlib.tests.test_bugtracker',
3094
 
                   'bzrlib.tests.test_bundle',
3095
 
                   'bzrlib.tests.test_bzrdir',
3096
 
                   'bzrlib.tests.test__chunks_to_lines',
3097
 
                   'bzrlib.tests.test_cache_utf8',
3098
 
                   'bzrlib.tests.test_chk_map',
3099
 
                   'bzrlib.tests.test_chunk_writer',
3100
 
                   'bzrlib.tests.test_clean_tree',
3101
 
                   'bzrlib.tests.test_commands',
3102
 
                   'bzrlib.tests.test_commit',
3103
 
                   'bzrlib.tests.test_commit_merge',
3104
 
                   'bzrlib.tests.test_config',
3105
 
                   'bzrlib.tests.test_conflicts',
3106
 
                   'bzrlib.tests.test_counted_lock',
3107
 
                   'bzrlib.tests.test_decorators',
3108
 
                   'bzrlib.tests.test_delta',
3109
 
                   'bzrlib.tests.test_debug',
3110
 
                   'bzrlib.tests.test_deprecated_graph',
3111
 
                   'bzrlib.tests.test_diff',
3112
 
                   'bzrlib.tests.test_directory_service',
3113
 
                   'bzrlib.tests.test_dirstate',
3114
 
                   'bzrlib.tests.test_email_message',
3115
 
                   'bzrlib.tests.test_errors',
3116
 
                   'bzrlib.tests.test_export',
3117
 
                   'bzrlib.tests.test_extract',
3118
 
                   'bzrlib.tests.test_fetch',
3119
 
                   'bzrlib.tests.test_fifo_cache',
3120
 
                   'bzrlib.tests.test_filters',
3121
 
                   'bzrlib.tests.test_ftp_transport',
3122
 
                   'bzrlib.tests.test_foreign',
3123
 
                   'bzrlib.tests.test_generate_docs',
3124
 
                   'bzrlib.tests.test_generate_ids',
3125
 
                   'bzrlib.tests.test_globbing',
3126
 
                   'bzrlib.tests.test_gpg',
3127
 
                   'bzrlib.tests.test_graph',
3128
 
                   'bzrlib.tests.test_groupcompress',
3129
 
                   'bzrlib.tests.test_hashcache',
3130
 
                   'bzrlib.tests.test_help',
3131
 
                   'bzrlib.tests.test_hooks',
3132
 
                   'bzrlib.tests.test_http',
3133
 
                   'bzrlib.tests.test_http_implementations',
3134
 
                   'bzrlib.tests.test_http_response',
3135
 
                   'bzrlib.tests.test_https_ca_bundle',
3136
 
                   'bzrlib.tests.test_identitymap',
3137
 
                   'bzrlib.tests.test_ignores',
3138
 
                   'bzrlib.tests.test_index',
3139
 
                   'bzrlib.tests.test_info',
3140
 
                   'bzrlib.tests.test_inv',
3141
 
                   'bzrlib.tests.test_knit',
3142
 
                   'bzrlib.tests.test_lazy_import',
3143
 
                   'bzrlib.tests.test_lazy_regex',
3144
 
                   'bzrlib.tests.test_lockable_files',
3145
 
                   'bzrlib.tests.test_lockdir',
3146
 
                   'bzrlib.tests.test_log',
3147
 
                   'bzrlib.tests.test_lru_cache',
3148
 
                   'bzrlib.tests.test_lsprof',
3149
 
                   'bzrlib.tests.test_mail_client',
3150
 
                   'bzrlib.tests.test_memorytree',
3151
 
                   'bzrlib.tests.test_merge',
3152
 
                   'bzrlib.tests.test_merge3',
3153
 
                   'bzrlib.tests.test_merge_core',
3154
 
                   'bzrlib.tests.test_merge_directive',
3155
 
                   'bzrlib.tests.test_missing',
3156
 
                   'bzrlib.tests.test_msgeditor',
3157
 
                   'bzrlib.tests.test_multiparent',
3158
 
                   'bzrlib.tests.test_mutabletree',
3159
 
                   'bzrlib.tests.test_nonascii',
3160
 
                   'bzrlib.tests.test_options',
3161
 
                   'bzrlib.tests.test_osutils',
3162
 
                   'bzrlib.tests.test_osutils_encodings',
3163
 
                   'bzrlib.tests.test_pack',
3164
 
                   'bzrlib.tests.test_pack_repository',
3165
 
                   'bzrlib.tests.test_patch',
3166
 
                   'bzrlib.tests.test_patches',
3167
 
                   'bzrlib.tests.test_permissions',
3168
 
                   'bzrlib.tests.test_plugins',
3169
 
                   'bzrlib.tests.test_progress',
3170
 
                   'bzrlib.tests.test_read_bundle',
3171
 
                   'bzrlib.tests.test_reconcile',
3172
 
                   'bzrlib.tests.test_reconfigure',
3173
 
                   'bzrlib.tests.test_registry',
3174
 
                   'bzrlib.tests.test_remote',
3175
 
                   'bzrlib.tests.test_rename_map',
3176
 
                   'bzrlib.tests.test_repository',
3177
 
                   'bzrlib.tests.test_revert',
3178
 
                   'bzrlib.tests.test_revision',
3179
 
                   'bzrlib.tests.test_revisionspec',
3180
 
                   'bzrlib.tests.test_revisiontree',
3181
 
                   'bzrlib.tests.test_rio',
3182
 
                   'bzrlib.tests.test_rules',
3183
 
                   'bzrlib.tests.test_sampler',
3184
 
                   'bzrlib.tests.test_selftest',
3185
 
                   'bzrlib.tests.test_setup',
3186
 
                   'bzrlib.tests.test_sftp_transport',
3187
 
                   'bzrlib.tests.test_shelf',
3188
 
                   'bzrlib.tests.test_shelf_ui',
3189
 
                   'bzrlib.tests.test_smart',
3190
 
                   'bzrlib.tests.test_smart_add',
3191
 
                   'bzrlib.tests.test_smart_request',
3192
 
                   'bzrlib.tests.test_smart_transport',
3193
 
                   'bzrlib.tests.test_smtp_connection',
3194
 
                   'bzrlib.tests.test_source',
3195
 
                   'bzrlib.tests.test_ssh_transport',
3196
 
                   'bzrlib.tests.test_status',
3197
 
                   'bzrlib.tests.test_store',
3198
 
                   'bzrlib.tests.test_strace',
3199
 
                   'bzrlib.tests.test_subsume',
3200
 
                   'bzrlib.tests.test_switch',
3201
 
                   'bzrlib.tests.test_symbol_versioning',
3202
 
                   'bzrlib.tests.test_tag',
3203
 
                   'bzrlib.tests.test_testament',
3204
 
                   'bzrlib.tests.test_textfile',
3205
 
                   'bzrlib.tests.test_textmerge',
3206
 
                   'bzrlib.tests.test_timestamp',
3207
 
                   'bzrlib.tests.test_trace',
3208
 
                   'bzrlib.tests.test_transactions',
3209
 
                   'bzrlib.tests.test_transform',
3210
 
                   'bzrlib.tests.test_transport',
3211
 
                   'bzrlib.tests.test_transport_implementations',
3212
 
                   'bzrlib.tests.test_transport_log',
3213
 
                   'bzrlib.tests.test_tree',
3214
 
                   'bzrlib.tests.test_treebuilder',
3215
 
                   'bzrlib.tests.test_tsort',
3216
 
                   'bzrlib.tests.test_tuned_gzip',
3217
 
                   'bzrlib.tests.test_ui',
3218
 
                   'bzrlib.tests.test_uncommit',
3219
 
                   'bzrlib.tests.test_upgrade',
3220
 
                   'bzrlib.tests.test_upgrade_stacked',
3221
 
                   'bzrlib.tests.test_urlutils',
3222
 
                   'bzrlib.tests.test_version',
3223
 
                   'bzrlib.tests.test_version_info',
3224
 
                   'bzrlib.tests.test_versionedfile',
3225
 
                   'bzrlib.tests.test_weave',
3226
 
                   'bzrlib.tests.test_whitebox',
3227
 
                   'bzrlib.tests.test_win32utils',
3228
 
                   'bzrlib.tests.test_workingtree',
3229
 
                   'bzrlib.tests.test_workingtree_4',
3230
 
                   'bzrlib.tests.test_wsgi',
3231
 
                   'bzrlib.tests.test_xml',
3232
 
                   'bzrlib.tests.tree_implementations',
3233
 
                   'bzrlib.tests.workingtree_implementations',
3234
 
                   'bzrlib.util.tests.test_bencode',
3235
 
                   ]
3236
3887
 
3237
3888
    loader = TestUtil.TestLoader()
3238
3889
 
 
3890
    if keep_only is not None:
 
3891
        id_filter = TestIdList(keep_only)
3239
3892
    if starting_with:
3240
 
        starting_with = [test_prefix_alias_registry.resolve_alias(start)
3241
 
                         for start in starting_with]
3242
3893
        # We take precedence over keep_only because *at loading time* using
3243
3894
        # both options means we will load less tests for the same final result.
3244
3895
        def interesting_module(name):
3254
3905
        loader = TestUtil.FilteredByModuleTestLoader(interesting_module)
3255
3906
 
3256
3907
    elif keep_only is not None:
3257
 
        id_filter = TestIdList(keep_only)
3258
3908
        loader = TestUtil.FilteredByModuleTestLoader(id_filter.refers_to)
3259
3909
        def interesting_module(name):
3260
3910
            return id_filter.refers_to(name)
3268
3918
    suite = loader.suiteClass()
3269
3919
 
3270
3920
    # modules building their suite with loadTestsFromModuleNames
3271
 
    suite.addTest(loader.loadTestsFromModuleNames(testmod_names))
3272
 
 
3273
 
    modules_to_doctest = [
3274
 
        'bzrlib',
3275
 
        'bzrlib.branchbuilder',
3276
 
        'bzrlib.export',
3277
 
        'bzrlib.inventory',
3278
 
        'bzrlib.iterablefile',
3279
 
        'bzrlib.lockdir',
3280
 
        'bzrlib.merge3',
3281
 
        'bzrlib.option',
3282
 
        'bzrlib.symbol_versioning',
3283
 
        'bzrlib.tests',
3284
 
        'bzrlib.timestamp',
3285
 
        'bzrlib.version_info_formats.format_custom',
3286
 
        ]
3287
 
 
3288
 
    for mod in modules_to_doctest:
 
3921
    suite.addTest(loader.loadTestsFromModuleNames(_test_suite_testmod_names()))
 
3922
 
 
3923
    for mod in _test_suite_modules_to_doctest():
3289
3924
        if not interesting_module(mod):
3290
3925
            # No tests to keep here, move along
3291
3926
            continue
3320
3955
            reload(sys)
3321
3956
            sys.setdefaultencoding(default_encoding)
3322
3957
 
3323
 
    if starting_with:
3324
 
        suite = filter_suite_by_id_startswith(suite, starting_with)
3325
 
 
3326
3958
    if keep_only is not None:
3327
3959
        # Now that the referred modules have loaded their tests, keep only the
3328
3960
        # requested ones.
3377
4009
    the scenario name at the end of its id(), and updating the test object's
3378
4010
    __dict__ with the scenario_param_dict.
3379
4011
 
 
4012
    >>> import bzrlib.tests.test_sampler
3380
4013
    >>> r = multiply_tests(
3381
4014
    ...     bzrlib.tests.test_sampler.DemoTest('test_nothing'),
3382
4015
    ...     [('one', dict(param=1)),
3383
4016
    ...      ('two', dict(param=2))],
3384
 
    ...     TestSuite())
 
4017
    ...     TestUtil.TestSuite())
3385
4018
    >>> tests = list(iter_suite_tests(r))
3386
4019
    >>> len(tests)
3387
4020
    2
3434
4067
    :param new_id: The id to assign to it.
3435
4068
    :return: The new test.
3436
4069
    """
3437
 
    from copy import deepcopy
3438
 
    new_test = deepcopy(test)
 
4070
    new_test = copy.copy(test)
3439
4071
    new_test.id = lambda: new_id
3440
4072
    return new_test
3441
4073
 
3442
4074
 
3443
 
def _rmtree_temp_dir(dirname):
 
4075
def permute_tests_for_extension(standard_tests, loader, py_module_name,
 
4076
                                ext_module_name):
 
4077
    """Helper for permutating tests against an extension module.
 
4078
 
 
4079
    This is meant to be used inside a modules 'load_tests()' function. It will
 
4080
    create 2 scenarios, and cause all tests in the 'standard_tests' to be run
 
4081
    against both implementations. Setting 'test.module' to the appropriate
 
4082
    module. See bzrlib.tests.test__chk_map.load_tests as an example.
 
4083
 
 
4084
    :param standard_tests: A test suite to permute
 
4085
    :param loader: A TestLoader
 
4086
    :param py_module_name: The python path to a python module that can always
 
4087
        be loaded, and will be considered the 'python' implementation. (eg
 
4088
        'bzrlib._chk_map_py')
 
4089
    :param ext_module_name: The python path to an extension module. If the
 
4090
        module cannot be loaded, a single test will be added, which notes that
 
4091
        the module is not available. If it can be loaded, all standard_tests
 
4092
        will be run against that module.
 
4093
    :return: (suite, feature) suite is a test-suite that has all the permuted
 
4094
        tests. feature is the Feature object that can be used to determine if
 
4095
        the module is available.
 
4096
    """
 
4097
 
 
4098
    py_module = __import__(py_module_name, {}, {}, ['NO_SUCH_ATTRIB'])
 
4099
    scenarios = [
 
4100
        ('python', {'module': py_module}),
 
4101
    ]
 
4102
    suite = loader.suiteClass()
 
4103
    feature = ModuleAvailableFeature(ext_module_name)
 
4104
    if feature.available():
 
4105
        scenarios.append(('C', {'module': feature.module}))
 
4106
    else:
 
4107
        # the compiled module isn't available, so we add a failing test
 
4108
        class FailWithoutFeature(TestCase):
 
4109
            def test_fail(self):
 
4110
                self.requireFeature(feature)
 
4111
        suite.addTest(loader.loadTestsFromTestCase(FailWithoutFeature))
 
4112
    result = multiply_tests(standard_tests, scenarios, suite)
 
4113
    return result, feature
 
4114
 
 
4115
 
 
4116
def _rmtree_temp_dir(dirname, test_id=None):
3444
4117
    # If LANG=C we probably have created some bogus paths
3445
4118
    # which rmtree(unicode) will fail to delete
3446
4119
    # so make sure we are using rmtree(str) to delete everything
3455
4128
    try:
3456
4129
        osutils.rmtree(dirname)
3457
4130
    except OSError, e:
3458
 
        if sys.platform == 'win32' and e.errno == errno.EACCES:
3459
 
            sys.stderr.write('Permission denied: '
3460
 
                             'unable to remove testing dir '
3461
 
                             '%s\n%s'
3462
 
                             % (os.path.basename(dirname), e))
3463
 
        else:
3464
 
            raise
 
4131
        # We don't want to fail here because some useful display will be lost
 
4132
        # otherwise. Polluting the tmp dir is bad, but not giving all the
 
4133
        # possible info to the test runner is even worse.
 
4134
        if test_id != None:
 
4135
            ui.ui_factory.clear_term()
 
4136
            sys.stderr.write('\nWhile running: %s\n' % (test_id,))
 
4137
        # Ugly, but the last thing we want here is fail, so bear with it.
 
4138
        printable_e = str(e).decode(osutils.get_user_encoding(), 'replace'
 
4139
                                    ).encode('ascii', 'replace')
 
4140
        sys.stderr.write('Unable to remove testing dir %s\n%s'
 
4141
                         % (os.path.basename(dirname), printable_e))
3465
4142
 
3466
4143
 
3467
4144
class Feature(object):
3549
4226
UnicodeFilenameFeature = _UnicodeFilenameFeature()
3550
4227
 
3551
4228
 
 
4229
class _CompatabilityThunkFeature(Feature):
 
4230
    """This feature is just a thunk to another feature.
 
4231
 
 
4232
    It issues a deprecation warning if it is accessed, to let you know that you
 
4233
    should really use a different feature.
 
4234
    """
 
4235
 
 
4236
    def __init__(self, dep_version, module, name,
 
4237
                 replacement_name, replacement_module=None):
 
4238
        super(_CompatabilityThunkFeature, self).__init__()
 
4239
        self._module = module
 
4240
        if replacement_module is None:
 
4241
            replacement_module = module
 
4242
        self._replacement_module = replacement_module
 
4243
        self._name = name
 
4244
        self._replacement_name = replacement_name
 
4245
        self._dep_version = dep_version
 
4246
        self._feature = None
 
4247
 
 
4248
    def _ensure(self):
 
4249
        if self._feature is None:
 
4250
            depr_msg = self._dep_version % ('%s.%s'
 
4251
                                            % (self._module, self._name))
 
4252
            use_msg = ' Use %s.%s instead.' % (self._replacement_module,
 
4253
                                               self._replacement_name)
 
4254
            symbol_versioning.warn(depr_msg + use_msg, DeprecationWarning)
 
4255
            # Import the new feature and use it as a replacement for the
 
4256
            # deprecated one.
 
4257
            mod = __import__(self._replacement_module, {}, {},
 
4258
                             [self._replacement_name])
 
4259
            self._feature = getattr(mod, self._replacement_name)
 
4260
 
 
4261
    def _probe(self):
 
4262
        self._ensure()
 
4263
        return self._feature._probe()
 
4264
 
 
4265
 
 
4266
class ModuleAvailableFeature(Feature):
 
4267
    """This is a feature than describes a module we want to be available.
 
4268
 
 
4269
    Declare the name of the module in __init__(), and then after probing, the
 
4270
    module will be available as 'self.module'.
 
4271
 
 
4272
    :ivar module: The module if it is available, else None.
 
4273
    """
 
4274
 
 
4275
    def __init__(self, module_name):
 
4276
        super(ModuleAvailableFeature, self).__init__()
 
4277
        self.module_name = module_name
 
4278
 
 
4279
    def _probe(self):
 
4280
        try:
 
4281
            self._module = __import__(self.module_name, {}, {}, [''])
 
4282
            return True
 
4283
        except ImportError:
 
4284
            return False
 
4285
 
 
4286
    @property
 
4287
    def module(self):
 
4288
        if self.available(): # Make sure the probe has been done
 
4289
            return self._module
 
4290
        return None
 
4291
 
 
4292
    def feature_name(self):
 
4293
        return self.module_name
 
4294
 
 
4295
 
 
4296
# This is kept here for compatibility, it is recommended to use
 
4297
# 'bzrlib.tests.feature.paramiko' instead
 
4298
ParamikoFeature = _CompatabilityThunkFeature(
 
4299
    deprecated_in((2,1,0)),
 
4300
    'bzrlib.tests.features', 'ParamikoFeature', 'paramiko')
 
4301
 
 
4302
 
3552
4303
def probe_unicode_in_user_encoding():
3553
4304
    """Try to encode several unicode strings to use in unicode-aware tests.
3554
4305
    Return first successfull match.
3623
4374
UnicodeFilename = _UnicodeFilename()
3624
4375
 
3625
4376
 
 
4377
class _ByteStringNamedFilesystem(Feature):
 
4378
    """Is the filesystem based on bytes?"""
 
4379
 
 
4380
    def _probe(self):
 
4381
        if os.name == "posix":
 
4382
            return True
 
4383
        return False
 
4384
 
 
4385
ByteStringNamedFilesystem = _ByteStringNamedFilesystem()
 
4386
 
 
4387
 
3626
4388
class _UTF8Filesystem(Feature):
3627
4389
    """Is the filesystem UTF-8?"""
3628
4390
 
3634
4396
UTF8Filesystem = _UTF8Filesystem()
3635
4397
 
3636
4398
 
 
4399
class _BreakinFeature(Feature):
 
4400
    """Does this platform support the breakin feature?"""
 
4401
 
 
4402
    def _probe(self):
 
4403
        from bzrlib import breakin
 
4404
        if breakin.determine_signal() is None:
 
4405
            return False
 
4406
        if sys.platform == 'win32':
 
4407
            # Windows doesn't have os.kill, and we catch the SIGBREAK signal.
 
4408
            # We trigger SIGBREAK via a Console api so we need ctypes to
 
4409
            # access the function
 
4410
            try:
 
4411
                import ctypes
 
4412
            except OSError:
 
4413
                return False
 
4414
        return True
 
4415
 
 
4416
    def feature_name(self):
 
4417
        return "SIGQUIT or SIGBREAK w/ctypes on win32"
 
4418
 
 
4419
 
 
4420
BreakinFeature = _BreakinFeature()
 
4421
 
 
4422
 
3637
4423
class _CaseInsCasePresFilenameFeature(Feature):
3638
4424
    """Is the file-system case insensitive, but case-preserving?"""
3639
4425
 
3689
4475
CaseInsensitiveFilesystemFeature = _CaseInsensitiveFilesystemFeature()
3690
4476
 
3691
4477
 
3692
 
class _SubUnitFeature(Feature):
3693
 
    """Check if subunit is available."""
 
4478
class _CaseSensitiveFilesystemFeature(Feature):
3694
4479
 
3695
4480
    def _probe(self):
3696
 
        try:
3697
 
            import subunit
 
4481
        if CaseInsCasePresFilenameFeature.available():
 
4482
            return False
 
4483
        elif CaseInsensitiveFilesystemFeature.available():
 
4484
            return False
 
4485
        else:
3698
4486
            return True
3699
 
        except ImportError:
3700
 
            return False
3701
4487
 
3702
4488
    def feature_name(self):
3703
 
        return 'subunit'
3704
 
 
3705
 
SubUnitFeature = _SubUnitFeature()
 
4489
        return 'case-sensitive filesystem'
 
4490
 
 
4491
# new coding style is for feature instances to be lowercase
 
4492
case_sensitive_filesystem_feature = _CaseSensitiveFilesystemFeature()
 
4493
 
 
4494
 
 
4495
# Kept for compatibility, use bzrlib.tests.features.subunit instead
 
4496
SubUnitFeature = _CompatabilityThunkFeature(
 
4497
    deprecated_in((2,1,0)),
 
4498
    'bzrlib.tests.features', 'SubUnitFeature', 'subunit')
3706
4499
# Only define SubUnitBzrRunner if subunit is available.
3707
4500
try:
3708
4501
    from subunit import TestProtocolClient
 
4502
    from subunit.test_results import AutoTimingTestResultDecorator
3709
4503
    class SubUnitBzrRunner(TextTestRunner):
3710
4504
        def run(self, test):
3711
 
            # undo out claim for testing which looks like a test start to subunit
3712
 
            self.stream.write("success: %s\n" % (osutils.realpath(sys.argv[0]),))
3713
 
            result = TestProtocolClient(self.stream)
 
4505
            result = AutoTimingTestResultDecorator(
 
4506
                TestProtocolClient(self.stream))
3714
4507
            test.run(result)
3715
4508
            return result
3716
4509
except ImportError:
3717
4510
    pass
 
4511
 
 
4512
class _PosixPermissionsFeature(Feature):
 
4513
 
 
4514
    def _probe(self):
 
4515
        def has_perms():
 
4516
            # create temporary file and check if specified perms are maintained.
 
4517
            import tempfile
 
4518
 
 
4519
            write_perms = stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR
 
4520
            f = tempfile.mkstemp(prefix='bzr_perms_chk_')
 
4521
            fd, name = f
 
4522
            os.close(fd)
 
4523
            os.chmod(name, write_perms)
 
4524
 
 
4525
            read_perms = os.stat(name).st_mode & 0777
 
4526
            os.unlink(name)
 
4527
            return (write_perms == read_perms)
 
4528
 
 
4529
        return (os.name == 'posix') and has_perms()
 
4530
 
 
4531
    def feature_name(self):
 
4532
        return 'POSIX permissions support'
 
4533
 
 
4534
posix_permissions_feature = _PosixPermissionsFeature()