/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/__init__.py

  • Committer: John Arbash Meinel
  • Date: 2011-01-25 22:54:08 UTC
  • mto: This revision was merged to the branch mainline in revision 5636.
  • Revision ID: john@arbash-meinel.com-20110125225408-w5b5mmh117q4jjz1
Implement a reset-to-known-state ability for DirState.

Use this in reset_state(). Allow it to use header information if it can
be parsed, otherwise allow us to pass in the information.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/__init__.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005-2011 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
29
29
 
30
30
import atexit
31
31
import codecs
32
 
from copy import copy
 
32
import copy
33
33
from cStringIO import StringIO
34
34
import difflib
35
35
import doctest
36
36
import errno
 
37
import itertools
37
38
import logging
38
 
import math
39
39
import os
40
 
from pprint import pformat
 
40
import platform
 
41
import pprint
41
42
import random
42
43
import re
43
44
import shlex
44
45
import stat
45
 
from subprocess import Popen, PIPE, STDOUT
 
46
import subprocess
46
47
import sys
47
48
import tempfile
48
49
import threading
54
55
import testtools
55
56
# nb: check this before importing anything else from within it
56
57
_testtools_version = getattr(testtools, '__version__', ())
57
 
if _testtools_version < (0, 9, 2):
58
 
    raise ImportError("need at least testtools 0.9.2: %s is %r"
 
58
if _testtools_version < (0, 9, 5):
 
59
    raise ImportError("need at least testtools 0.9.5: %s is %r"
59
60
        % (testtools.__file__, _testtools_version))
60
61
from testtools import content
61
62
 
 
63
import bzrlib
62
64
from bzrlib import (
63
65
    branchbuilder,
64
66
    bzrdir,
65
67
    chk_map,
 
68
    commands as _mod_commands,
66
69
    config,
67
70
    debug,
68
71
    errors,
69
72
    hooks,
70
73
    lock as _mod_lock,
 
74
    lockdir,
71
75
    memorytree,
72
76
    osutils,
73
 
    progress,
 
77
    plugin as _mod_plugin,
 
78
    pyutils,
74
79
    ui,
75
80
    urlutils,
76
81
    registry,
 
82
    symbol_versioning,
 
83
    trace,
 
84
    transport as _mod_transport,
77
85
    workingtree,
78
86
    )
79
 
import bzrlib.branch
80
 
import bzrlib.commands
81
 
import bzrlib.timestamp
82
 
import bzrlib.export
83
 
import bzrlib.inventory
84
 
import bzrlib.iterablefile
85
 
import bzrlib.lockdir
86
87
try:
87
88
    import bzrlib.lsprof
88
89
except ImportError:
89
90
    # lsprof not available
90
91
    pass
91
 
from bzrlib.merge import merge_inner
92
 
import bzrlib.merge3
93
 
import bzrlib.plugin
94
 
from bzrlib.smart import client, request, server
95
 
import bzrlib.store
96
 
from bzrlib import symbol_versioning
97
 
from bzrlib.symbol_versioning import (
98
 
    DEPRECATED_PARAMETER,
99
 
    deprecated_function,
100
 
    deprecated_in,
101
 
    deprecated_method,
102
 
    deprecated_passed,
103
 
    )
104
 
import bzrlib.trace
 
92
from bzrlib.smart import client, request
105
93
from bzrlib.transport import (
106
 
    get_transport,
107
94
    memory,
108
95
    pathfilter,
109
96
    )
110
 
import bzrlib.transport
111
 
from bzrlib.trace import mutter, note
112
97
from bzrlib.tests import (
113
98
    test_server,
114
99
    TestUtil,
 
100
    treeshape,
115
101
    )
116
 
from bzrlib.tests.http_server import HttpServer
117
 
from bzrlib.tests.TestUtil import (
118
 
                          TestSuite,
119
 
                          TestLoader,
120
 
                          )
121
 
from bzrlib.tests.treeshape import build_tree_contents
122
102
from bzrlib.ui import NullProgressView
123
103
from bzrlib.ui.text import TextUIFactory
124
 
import bzrlib.version_info_formats.format_custom
125
 
from bzrlib.workingtree import WorkingTree, WorkingTreeFormat2
126
104
 
127
105
# Mark this python module as being part of the implementation
128
106
# of unittest: this gives us better tracebacks where the last
140
118
SUBUNIT_SEEK_SET = 0
141
119
SUBUNIT_SEEK_CUR = 1
142
120
 
143
 
 
144
 
class ExtendedTestResult(unittest._TextTestResult):
 
121
# These are intentionally brought into this namespace. That way plugins, etc
 
122
# can just "from bzrlib.tests import TestCase, TestLoader, etc"
 
123
TestSuite = TestUtil.TestSuite
 
124
TestLoader = TestUtil.TestLoader
 
125
 
 
126
# Tests should run in a clean and clearly defined environment. The goal is to
 
127
# keep them isolated from the running environment as mush as possible. The test
 
128
# framework ensures the variables defined below are set (or deleted if the
 
129
# value is None) before a test is run and reset to their original value after
 
130
# the test is run. Generally if some code depends on an environment variable,
 
131
# the tests should start without this variable in the environment. There are a
 
132
# few exceptions but you shouldn't violate this rule lightly.
 
133
isolated_environ = {
 
134
    'BZR_HOME': None,
 
135
    'HOME': None,
 
136
    # bzr now uses the Win32 API and doesn't rely on APPDATA, but the
 
137
    # tests do check our impls match APPDATA
 
138
    'BZR_EDITOR': None, # test_msgeditor manipulates this variable
 
139
    'VISUAL': None,
 
140
    'EDITOR': None,
 
141
    'BZR_EMAIL': None,
 
142
    'BZREMAIL': None, # may still be present in the environment
 
143
    'EMAIL': 'jrandom@example.com', # set EMAIL as bzr does not guess
 
144
    'BZR_PROGRESS_BAR': None,
 
145
    'BZR_LOG': None,
 
146
    'BZR_PLUGIN_PATH': None,
 
147
    'BZR_DISABLE_PLUGINS': None,
 
148
    'BZR_PLUGINS_AT': None,
 
149
    'BZR_CONCURRENCY': None,
 
150
    # Make sure that any text ui tests are consistent regardless of
 
151
    # the environment the test case is run in; you may want tests that
 
152
    # test other combinations.  'dumb' is a reasonable guess for tests
 
153
    # going to a pipe or a StringIO.
 
154
    'TERM': 'dumb',
 
155
    'LINES': '25',
 
156
    'COLUMNS': '80',
 
157
    'BZR_COLUMNS': '80',
 
158
    # Disable SSH Agent
 
159
    'SSH_AUTH_SOCK': None,
 
160
    # Proxies
 
161
    'http_proxy': None,
 
162
    'HTTP_PROXY': None,
 
163
    'https_proxy': None,
 
164
    'HTTPS_PROXY': None,
 
165
    'no_proxy': None,
 
166
    'NO_PROXY': None,
 
167
    'all_proxy': None,
 
168
    'ALL_PROXY': None,
 
169
    # Nobody cares about ftp_proxy, FTP_PROXY AFAIK. So far at
 
170
    # least. If you do (care), please update this comment
 
171
    # -- vila 20080401
 
172
    'ftp_proxy': None,
 
173
    'FTP_PROXY': None,
 
174
    'BZR_REMOTE_PATH': None,
 
175
    # Generally speaking, we don't want apport reporting on crashes in
 
176
    # the test envirnoment unless we're specifically testing apport,
 
177
    # so that it doesn't leak into the real system environment.  We
 
178
    # use an env var so it propagates to subprocesses.
 
179
    'APPORT_DISABLE': '1',
 
180
    }
 
181
 
 
182
 
 
183
def override_os_environ(test, env=None):
 
184
    """Modify os.environ keeping a copy.
 
185
    
 
186
    :param test: A test instance
 
187
 
 
188
    :param env: A dict containing variable definitions to be installed
 
189
    """
 
190
    if env is None:
 
191
        env = isolated_environ
 
192
    test._original_os_environ = dict([(var, value)
 
193
                                      for var, value in os.environ.iteritems()])
 
194
    for var, value in env.iteritems():
 
195
        osutils.set_or_unset_env(var, value)
 
196
        if var not in test._original_os_environ:
 
197
            # The var is new, add it with a value of None, so
 
198
            # restore_os_environ will delete it
 
199
            test._original_os_environ[var] = None
 
200
 
 
201
 
 
202
def restore_os_environ(test):
 
203
    """Restore os.environ to its original state.
 
204
 
 
205
    :param test: A test instance previously passed to override_os_environ.
 
206
    """
 
207
    for var, value in test._original_os_environ.iteritems():
 
208
        # Restore the original value (or delete it if the value has been set to
 
209
        # None in override_os_environ).
 
210
        osutils.set_or_unset_env(var, value)
 
211
 
 
212
 
 
213
class ExtendedTestResult(testtools.TextTestResult):
145
214
    """Accepts, reports and accumulates the results of running tests.
146
215
 
147
216
    Compared to the unittest version this class adds support for
168
237
        :param bench_history: Optionally, a writable file object to accumulate
169
238
            benchmark results.
170
239
        """
171
 
        unittest._TextTestResult.__init__(self, stream, descriptions, verbosity)
 
240
        testtools.TextTestResult.__init__(self, stream)
172
241
        if bench_history is not None:
173
242
            from bzrlib.version import _get_bzr_source_tree
174
243
            src_tree = _get_bzr_source_tree()
195
264
        self.count = 0
196
265
        self._overall_start_time = time.time()
197
266
        self._strict = strict
 
267
        self._first_thread_leaker_id = None
 
268
        self._tests_leaking_threads_count = 0
 
269
        self._traceback_from_test = None
198
270
 
199
271
    def stopTestRun(self):
200
272
        run = self.testsRun
201
273
        actionTaken = "Ran"
202
274
        stopTime = time.time()
203
275
        timeTaken = stopTime - self.startTime
204
 
        self.printErrors()
205
 
        self.stream.writeln(self.separator2)
206
 
        self.stream.writeln("%s %d test%s in %.3fs" % (actionTaken,
 
276
        # GZ 2010-07-19: Seems testtools has no printErrors method, and though
 
277
        #                the parent class method is similar have to duplicate
 
278
        self._show_list('ERROR', self.errors)
 
279
        self._show_list('FAIL', self.failures)
 
280
        self.stream.write(self.sep2)
 
281
        self.stream.write("%s %d test%s in %.3fs\n\n" % (actionTaken,
207
282
                            run, run != 1 and "s" or "", timeTaken))
208
 
        self.stream.writeln()
209
283
        if not self.wasSuccessful():
210
284
            self.stream.write("FAILED (")
211
285
            failed, errored = map(len, (self.failures, self.errors))
218
292
                if failed or errored: self.stream.write(", ")
219
293
                self.stream.write("known_failure_count=%d" %
220
294
                    self.known_failure_count)
221
 
            self.stream.writeln(")")
 
295
            self.stream.write(")\n")
222
296
        else:
223
297
            if self.known_failure_count:
224
 
                self.stream.writeln("OK (known_failures=%d)" %
 
298
                self.stream.write("OK (known_failures=%d)\n" %
225
299
                    self.known_failure_count)
226
300
            else:
227
 
                self.stream.writeln("OK")
 
301
                self.stream.write("OK\n")
228
302
        if self.skip_count > 0:
229
303
            skipped = self.skip_count
230
 
            self.stream.writeln('%d test%s skipped' %
 
304
            self.stream.write('%d test%s skipped\n' %
231
305
                                (skipped, skipped != 1 and "s" or ""))
232
306
        if self.unsupported:
233
307
            for feature, count in sorted(self.unsupported.items()):
234
 
                self.stream.writeln("Missing feature '%s' skipped %d tests." %
 
308
                self.stream.write("Missing feature '%s' skipped %d tests.\n" %
235
309
                    (feature, count))
236
310
        if self._strict:
237
311
            ok = self.wasStrictlySuccessful()
238
312
        else:
239
313
            ok = self.wasSuccessful()
240
 
        if TestCase._first_thread_leaker_id:
 
314
        if self._first_thread_leaker_id:
241
315
            self.stream.write(
242
316
                '%s is leaking threads among %d leaking tests.\n' % (
243
 
                TestCase._first_thread_leaker_id,
244
 
                TestCase._leaking_threads_tests))
 
317
                self._first_thread_leaker_id,
 
318
                self._tests_leaking_threads_count))
245
319
            # We don't report the main thread as an active one.
246
320
            self.stream.write(
247
321
                '%d non-main threads were left active in the end.\n'
248
 
                % (TestCase._active_threads - 1))
 
322
                % (len(self._active_threads) - 1))
249
323
 
250
324
    def getDescription(self, test):
251
325
        return test.id()
258
332
 
259
333
    def _elapsedTestTimeString(self):
260
334
        """Return a time string for the overall time the current test has taken."""
261
 
        return self._formatTime(time.time() - self._start_time)
 
335
        return self._formatTime(self._delta_to_float(
 
336
            self._now() - self._start_datetime))
262
337
 
263
338
    def _testTimeString(self, testCase):
264
339
        benchmark_time = self._extractBenchmarkTime(testCase)
275
350
 
276
351
    def _shortened_test_description(self, test):
277
352
        what = test.id()
278
 
        what = re.sub(r'^bzrlib\.(tests|benchmarks)\.', '', what)
 
353
        what = re.sub(r'^bzrlib\.tests\.', '', what)
279
354
        return what
280
355
 
 
356
    # GZ 2010-10-04: Cloned tests may end up harmlessly calling this method
 
357
    #                multiple times in a row, because the handler is added for
 
358
    #                each test but the container list is shared between cases.
 
359
    #                See lp:498869 lp:625574 and lp:637725 for background.
 
360
    def _record_traceback_from_test(self, exc_info):
 
361
        """Store the traceback from passed exc_info tuple till"""
 
362
        self._traceback_from_test = exc_info[2]
 
363
 
281
364
    def startTest(self, test):
282
 
        unittest.TestResult.startTest(self, test)
 
365
        super(ExtendedTestResult, self).startTest(test)
283
366
        if self.count == 0:
284
367
            self.startTests()
 
368
        self.count += 1
285
369
        self.report_test_start(test)
286
370
        test.number = self.count
287
371
        self._recordTestStartTime()
 
372
        # Make testtools cases give us the real traceback on failure
 
373
        addOnException = getattr(test, "addOnException", None)
 
374
        if addOnException is not None:
 
375
            addOnException(self._record_traceback_from_test)
 
376
        # Only check for thread leaks on bzrlib derived test cases
 
377
        if isinstance(test, TestCase):
 
378
            test.addCleanup(self._check_leaked_threads, test)
288
379
 
289
380
    def startTests(self):
290
 
        import platform
291
 
        if getattr(sys, 'frozen', None) is None:
292
 
            bzr_path = osutils.realpath(sys.argv[0])
293
 
        else:
294
 
            bzr_path = sys.executable
295
 
        self.stream.write(
296
 
            'bzr selftest: %s\n' % (bzr_path,))
297
 
        self.stream.write(
298
 
            '   %s\n' % (
299
 
                    bzrlib.__path__[0],))
300
 
        self.stream.write(
301
 
            '   bzr-%s python-%s %s\n' % (
302
 
                    bzrlib.version_string,
303
 
                    bzrlib._format_version_tuple(sys.version_info),
304
 
                    platform.platform(aliased=1),
305
 
                    ))
306
 
        self.stream.write('\n')
 
381
        self.report_tests_starting()
 
382
        self._active_threads = threading.enumerate()
 
383
 
 
384
    def stopTest(self, test):
 
385
        self._traceback_from_test = None
 
386
 
 
387
    def _check_leaked_threads(self, test):
 
388
        """See if any threads have leaked since last call
 
389
 
 
390
        A sample of live threads is stored in the _active_threads attribute,
 
391
        when this method runs it compares the current live threads and any not
 
392
        in the previous sample are treated as having leaked.
 
393
        """
 
394
        now_active_threads = set(threading.enumerate())
 
395
        threads_leaked = now_active_threads.difference(self._active_threads)
 
396
        if threads_leaked:
 
397
            self._report_thread_leak(test, threads_leaked, now_active_threads)
 
398
            self._tests_leaking_threads_count += 1
 
399
            if self._first_thread_leaker_id is None:
 
400
                self._first_thread_leaker_id = test.id()
 
401
            self._active_threads = now_active_threads
307
402
 
308
403
    def _recordTestStartTime(self):
309
404
        """Record that a test has started."""
310
 
        self._start_time = time.time()
311
 
 
312
 
    def _cleanupLogFile(self, test):
313
 
        # We can only do this if we have one of our TestCases, not if
314
 
        # we have a doctest.
315
 
        setKeepLogfile = getattr(test, 'setKeepLogfile', None)
316
 
        if setKeepLogfile is not None:
317
 
            setKeepLogfile()
 
405
        self._start_datetime = self._now()
318
406
 
319
407
    def addError(self, test, err):
320
408
        """Tell result that test finished with an error.
322
410
        Called from the TestCase run() method when the test
323
411
        fails with an unexpected error.
324
412
        """
325
 
        self._post_mortem()
326
 
        unittest.TestResult.addError(self, test, err)
 
413
        self._post_mortem(self._traceback_from_test)
 
414
        super(ExtendedTestResult, self).addError(test, err)
327
415
        self.error_count += 1
328
416
        self.report_error(test, err)
329
417
        if self.stop_early:
330
418
            self.stop()
331
 
        self._cleanupLogFile(test)
332
419
 
333
420
    def addFailure(self, test, err):
334
421
        """Tell result that test failed.
336
423
        Called from the TestCase run() method when the test
337
424
        fails because e.g. an assert() method failed.
338
425
        """
339
 
        self._post_mortem()
340
 
        unittest.TestResult.addFailure(self, test, err)
 
426
        self._post_mortem(self._traceback_from_test)
 
427
        super(ExtendedTestResult, self).addFailure(test, err)
341
428
        self.failure_count += 1
342
429
        self.report_failure(test, err)
343
430
        if self.stop_early:
344
431
            self.stop()
345
 
        self._cleanupLogFile(test)
346
432
 
347
433
    def addSuccess(self, test, details=None):
348
434
        """Tell result that test completed successfully.
356
442
                    self._formatTime(benchmark_time),
357
443
                    test.id()))
358
444
        self.report_success(test)
359
 
        self._cleanupLogFile(test)
360
 
        unittest.TestResult.addSuccess(self, test)
 
445
        super(ExtendedTestResult, self).addSuccess(test)
361
446
        test._log_contents = ''
362
447
 
363
448
    def addExpectedFailure(self, test, err):
386
471
        self.not_applicable_count += 1
387
472
        self.report_not_applicable(test, reason)
388
473
 
389
 
    def _post_mortem(self):
 
474
    def _post_mortem(self, tb=None):
390
475
        """Start a PDB post mortem session."""
391
476
        if os.environ.get('BZR_TEST_PDB', None):
392
 
            import pdb;pdb.post_mortem()
 
477
            import pdb
 
478
            pdb.post_mortem(tb)
393
479
 
394
480
    def progress(self, offset, whence):
395
481
        """The test is adjusting the count of tests to run."""
400
486
        else:
401
487
            raise errors.BzrError("Unknown whence %r" % whence)
402
488
 
403
 
    def report_cleaning_up(self):
404
 
        pass
 
489
    def report_tests_starting(self):
 
490
        """Display information before the test run begins"""
 
491
        if getattr(sys, 'frozen', None) is None:
 
492
            bzr_path = osutils.realpath(sys.argv[0])
 
493
        else:
 
494
            bzr_path = sys.executable
 
495
        self.stream.write(
 
496
            'bzr selftest: %s\n' % (bzr_path,))
 
497
        self.stream.write(
 
498
            '   %s\n' % (
 
499
                    bzrlib.__path__[0],))
 
500
        self.stream.write(
 
501
            '   bzr-%s python-%s %s\n' % (
 
502
                    bzrlib.version_string,
 
503
                    bzrlib._format_version_tuple(sys.version_info),
 
504
                    platform.platform(aliased=1),
 
505
                    ))
 
506
        self.stream.write('\n')
 
507
 
 
508
    def report_test_start(self, test):
 
509
        """Display information on the test just about to be run"""
 
510
 
 
511
    def _report_thread_leak(self, test, leaked_threads, active_threads):
 
512
        """Display information on a test that leaked one or more threads"""
 
513
        # GZ 2010-09-09: A leak summary reported separately from the general
 
514
        #                thread debugging would be nice. Tests under subunit
 
515
        #                need something not using stream, perhaps adding a
 
516
        #                testtools details object would be fitting.
 
517
        if 'threads' in selftest_debug_flags:
 
518
            self.stream.write('%s is leaking, active is now %d\n' %
 
519
                (test.id(), len(active_threads)))
405
520
 
406
521
    def startTestRun(self):
407
522
        self.startTime = time.time()
444
559
        self.pb.finished()
445
560
        super(TextTestResult, self).stopTestRun()
446
561
 
447
 
    def startTestRun(self):
448
 
        super(TextTestResult, self).startTestRun()
 
562
    def report_tests_starting(self):
 
563
        super(TextTestResult, self).report_tests_starting()
449
564
        self.pb.update('[test 0/%d] Starting' % (self.num_tests))
450
565
 
451
 
    def printErrors(self):
452
 
        # clear the pb to make room for the error listing
453
 
        self.pb.clear()
454
 
        super(TextTestResult, self).printErrors()
455
 
 
456
566
    def _progress_prefix_text(self):
457
567
        # the longer this text, the less space we have to show the test
458
568
        # name...
480
590
        return a
481
591
 
482
592
    def report_test_start(self, test):
483
 
        self.count += 1
484
593
        self.pb.update(
485
594
                self._progress_prefix_text()
486
595
                + ' '
513
622
    def report_unsupported(self, test, feature):
514
623
        """test cannot be run because feature is missing."""
515
624
 
516
 
    def report_cleaning_up(self):
517
 
        self.pb.update('Cleaning up')
518
 
 
519
625
 
520
626
class VerboseTestResult(ExtendedTestResult):
521
627
    """Produce long output, with one line per test run plus times"""
528
634
            result = a_string
529
635
        return result.ljust(final_width)
530
636
 
531
 
    def startTestRun(self):
532
 
        super(VerboseTestResult, self).startTestRun()
 
637
    def report_tests_starting(self):
533
638
        self.stream.write('running %d tests...\n' % self.num_tests)
 
639
        super(VerboseTestResult, self).report_tests_starting()
534
640
 
535
641
    def report_test_start(self, test):
536
 
        self.count += 1
537
642
        name = self._shortened_test_description(test)
538
643
        width = osutils.terminal_width()
539
644
        if width is not None:
551
656
        return '%s%s' % (indent, err[1])
552
657
 
553
658
    def report_error(self, test, err):
554
 
        self.stream.writeln('ERROR %s\n%s'
 
659
        self.stream.write('ERROR %s\n%s\n'
555
660
                % (self._testTimeString(test),
556
661
                   self._error_summary(err)))
557
662
 
558
663
    def report_failure(self, test, err):
559
 
        self.stream.writeln(' FAIL %s\n%s'
 
664
        self.stream.write(' FAIL %s\n%s\n'
560
665
                % (self._testTimeString(test),
561
666
                   self._error_summary(err)))
562
667
 
563
668
    def report_known_failure(self, test, err):
564
 
        self.stream.writeln('XFAIL %s\n%s'
 
669
        self.stream.write('XFAIL %s\n%s\n'
565
670
                % (self._testTimeString(test),
566
671
                   self._error_summary(err)))
567
672
 
568
673
    def report_success(self, test):
569
 
        self.stream.writeln('   OK %s' % self._testTimeString(test))
 
674
        self.stream.write('   OK %s\n' % self._testTimeString(test))
570
675
        for bench_called, stats in getattr(test, '_benchcalls', []):
571
 
            self.stream.writeln('LSProf output for %s(%s, %s)' % bench_called)
 
676
            self.stream.write('LSProf output for %s(%s, %s)\n' % bench_called)
572
677
            stats.pprint(file=self.stream)
573
678
        # flush the stream so that we get smooth output. This verbose mode is
574
679
        # used to show the output in PQM.
575
680
        self.stream.flush()
576
681
 
577
682
    def report_skip(self, test, reason):
578
 
        self.stream.writeln(' SKIP %s\n%s'
 
683
        self.stream.write(' SKIP %s\n%s\n'
579
684
                % (self._testTimeString(test), reason))
580
685
 
581
686
    def report_not_applicable(self, test, reason):
582
 
        self.stream.writeln('  N/A %s\n    %s'
 
687
        self.stream.write('  N/A %s\n    %s\n'
583
688
                % (self._testTimeString(test), reason))
584
689
 
585
690
    def report_unsupported(self, test, feature):
586
691
        """test cannot be run because feature is missing."""
587
 
        self.stream.writeln("NODEP %s\n    The feature '%s' is not available."
 
692
        self.stream.write("NODEP %s\n    The feature '%s' is not available.\n"
588
693
                %(self._testTimeString(test), feature))
589
694
 
590
695
 
617
722
            encode = codec[0]
618
723
        else:
619
724
            encode = codec.encode
620
 
        stream = osutils.UnicodeOrBytesToBytesWriter(encode, stream)
 
725
        # GZ 2010-09-08: Really we don't want to be writing arbitrary bytes,
 
726
        #                so should swap to the plain codecs.StreamWriter
 
727
        stream = osutils.UnicodeOrBytesToBytesWriter(encode, stream,
 
728
            "backslashreplace")
621
729
        stream.encoding = new_encoding
622
 
        self.stream = unittest._WritelnDecorator(stream)
 
730
        self.stream = stream
623
731
        self.descriptions = descriptions
624
732
        self.verbosity = verbosity
625
733
        self._bench_history = bench_history
749
857
    # XXX: Should probably unify more with CannedInputUIFactory or a
750
858
    # particular configuration of TextUIFactory, or otherwise have a clearer
751
859
    # idea of how they're supposed to be different.
752
 
    # See https://bugs.edge.launchpad.net/bzr/+bug/408213
 
860
    # See https://bugs.launchpad.net/bzr/+bug/408213
753
861
 
754
862
    def __init__(self, stdout=None, stderr=None, stdin=None):
755
863
        if stdin is not None:
773
881
        return NullProgressView()
774
882
 
775
883
 
 
884
def isolated_doctest_setUp(test):
 
885
    override_os_environ(test)
 
886
 
 
887
 
 
888
def isolated_doctest_tearDown(test):
 
889
    restore_os_environ(test)
 
890
 
 
891
 
 
892
def IsolatedDocTestSuite(*args, **kwargs):
 
893
    """Overrides doctest.DocTestSuite to handle isolation.
 
894
 
 
895
    The method is really a factory and users are expected to use it as such.
 
896
    """
 
897
    
 
898
    kwargs['setUp'] = isolated_doctest_setUp
 
899
    kwargs['tearDown'] = isolated_doctest_tearDown
 
900
    return doctest.DocTestSuite(*args, **kwargs)
 
901
 
 
902
 
776
903
class TestCase(testtools.TestCase):
777
904
    """Base class for bzr unit tests.
778
905
 
789
916
    routine, and to build and check bzr trees.
790
917
 
791
918
    In addition to the usual method of overriding tearDown(), this class also
792
 
    allows subclasses to register functions into the _cleanups list, which is
 
919
    allows subclasses to register cleanup functions via addCleanup, which are
793
920
    run in order as the object is torn down.  It's less likely this will be
794
921
    accidentally overlooked.
795
922
    """
796
923
 
797
 
    _active_threads = None
798
 
    _leaking_threads_tests = 0
799
 
    _first_thread_leaker_id = None
800
 
    _log_file_name = None
 
924
    _log_file = None
801
925
    # record lsprof data when performing benchmark calls.
802
926
    _gather_lsprof_in_benchmarks = False
803
927
 
804
928
    def __init__(self, methodName='testMethod'):
805
929
        super(TestCase, self).__init__(methodName)
806
 
        self._cleanups = []
807
930
        self._directory_isolation = True
808
931
        self.exception_handlers.insert(0,
809
932
            (UnavailableFeature, self._do_unsupported_or_skip))
827
950
        self._track_transports()
828
951
        self._track_locks()
829
952
        self._clear_debug_flags()
830
 
        TestCase._active_threads = threading.activeCount()
831
 
        self.addCleanup(self._check_leaked_threads)
 
953
        # Isolate global verbosity level, to make sure it's reproducible
 
954
        # between tests.  We should get rid of this altogether: bug 656694. --
 
955
        # mbp 20101008
 
956
        self.overrideAttr(bzrlib.trace, '_verbosity_level', 0)
832
957
 
833
958
    def debug(self):
834
959
        # debug a frame up.
835
960
        import pdb
836
961
        pdb.Pdb().set_trace(sys._getframe().f_back)
837
962
 
838
 
    def _check_leaked_threads(self):
839
 
        active = threading.activeCount()
840
 
        leaked_threads = active - TestCase._active_threads
841
 
        TestCase._active_threads = active
842
 
        # If some tests make the number of threads *decrease*, we'll consider
843
 
        # that they are just observing old threads dieing, not agressively kill
844
 
        # random threads. So we don't report these tests as leaking. The risk
845
 
        # is that we have false positives that way (the test see 2 threads
846
 
        # going away but leak one) but it seems less likely than the actual
847
 
        # false positives (the test see threads going away and does not leak).
848
 
        if leaked_threads > 0:
849
 
            TestCase._leaking_threads_tests += 1
850
 
            if TestCase._first_thread_leaker_id is None:
851
 
                TestCase._first_thread_leaker_id = self.id()
 
963
    def discardDetail(self, name):
 
964
        """Extend the addDetail, getDetails api so we can remove a detail.
 
965
 
 
966
        eg. bzr always adds the 'log' detail at startup, but we don't want to
 
967
        include it for skipped, xfail, etc tests.
 
968
 
 
969
        It is safe to call this for a detail that doesn't exist, in case this
 
970
        gets called multiple times.
 
971
        """
 
972
        # We cheat. details is stored in __details which means we shouldn't
 
973
        # touch it. but getDetails() returns the dict directly, so we can
 
974
        # mutate it.
 
975
        details = self.getDetails()
 
976
        if name in details:
 
977
            del details[name]
852
978
 
853
979
    def _clear_debug_flags(self):
854
980
        """Prevent externally set debug flags affecting tests.
865
991
 
866
992
    def _clear_hooks(self):
867
993
        # prevent hooks affecting tests
 
994
        known_hooks = hooks.known_hooks
868
995
        self._preserved_hooks = {}
869
 
        for key, factory in hooks.known_hooks.items():
870
 
            parent, name = hooks.known_hooks_key_to_parent_and_attribute(key)
871
 
            current_hooks = hooks.known_hooks_key_to_object(key)
 
996
        for key, (parent, name) in known_hooks.iter_parent_objects():
 
997
            current_hooks = getattr(parent, name)
872
998
            self._preserved_hooks[parent] = (name, current_hooks)
873
999
        self.addCleanup(self._restoreHooks)
874
 
        for key, factory in hooks.known_hooks.items():
875
 
            parent, name = hooks.known_hooks_key_to_parent_and_attribute(key)
 
1000
        for key, (parent, name) in known_hooks.iter_parent_objects():
 
1001
            factory = known_hooks.get(key)
876
1002
            setattr(parent, name, factory())
877
1003
        # this hook should always be installed
878
1004
        request._install_hook()
943
1069
 
944
1070
    def permit_dir(self, name):
945
1071
        """Permit a directory to be used by this test. See permit_url."""
946
 
        name_transport = get_transport(name)
 
1072
        name_transport = _mod_transport.get_transport(name)
947
1073
        self.permit_url(name)
948
1074
        self.permit_url(name_transport.base)
949
1075
 
972
1098
            try:
973
1099
                workingtree.WorkingTree.open(path)
974
1100
            except (errors.NotBranchError, errors.NoWorkingTree):
975
 
                return
 
1101
                raise TestSkipped('Needs a working tree of bzr sources')
976
1102
        finally:
977
1103
            self.enable_directory_isolation()
978
1104
 
1028
1154
        self.addCleanup(transport_server.stop_server)
1029
1155
        # Obtain a real transport because if the server supplies a password, it
1030
1156
        # will be hidden from the base on the client side.
1031
 
        t = get_transport(transport_server.get_url())
 
1157
        t = _mod_transport.get_transport(transport_server.get_url())
1032
1158
        # Some transport servers effectively chroot the backing transport;
1033
1159
        # others like SFTPServer don't - users of the transport can walk up the
1034
1160
        # transport to read the entire backing transport. This wouldn't matter
1090
1216
        except UnicodeError, e:
1091
1217
            # If we can't compare without getting a UnicodeError, then
1092
1218
            # obviously they are different
1093
 
            mutter('UnicodeError: %s', e)
 
1219
            trace.mutter('UnicodeError: %s', e)
1094
1220
        if message:
1095
1221
            message += '\n'
1096
1222
        raise AssertionError("%snot equal:\na = %s\nb = %s\n"
1097
1223
            % (message,
1098
 
               pformat(a), pformat(b)))
 
1224
               pprint.pformat(a), pprint.pformat(b)))
1099
1225
 
1100
1226
    assertEquals = assertEqual
1101
1227
 
1156
1282
    def assertLogsError(self, exception_class, func, *args, **kwargs):
1157
1283
        """Assert that func(*args, **kwargs) quietly logs a specific exception.
1158
1284
        """
1159
 
        from bzrlib import trace
1160
1285
        captured = []
1161
1286
        orig_log_exception_quietly = trace.log_exception_quietly
1162
1287
        try:
1211
1336
        if haystack.find(needle) == -1:
1212
1337
            self.fail("string %r not found in '''%s'''" % (needle, haystack))
1213
1338
 
 
1339
    def assertNotContainsString(self, haystack, needle):
 
1340
        if haystack.find(needle) != -1:
 
1341
            self.fail("string %r found in '''%s'''" % (needle, haystack))
 
1342
 
1214
1343
    def assertSubset(self, sublist, superlist):
1215
1344
        """Assert that every entry in sublist is present in superlist."""
1216
1345
        missing = set(sublist) - set(superlist)
1455
1584
 
1456
1585
        The file is removed as the test is torn down.
1457
1586
        """
1458
 
        fileno, name = tempfile.mkstemp(suffix='.log', prefix='testbzr')
1459
 
        self._log_file = os.fdopen(fileno, 'w+')
1460
 
        self._log_memento = bzrlib.trace.push_log_file(self._log_file)
1461
 
        self._log_file_name = name
 
1587
        self._log_file = StringIO()
 
1588
        self._log_memento = trace.push_log_file(self._log_file)
1462
1589
        self.addCleanup(self._finishLogFile)
1463
1590
 
1464
1591
    def _finishLogFile(self):
1466
1593
 
1467
1594
        Close the file and delete it, unless setKeepLogfile was called.
1468
1595
        """
1469
 
        if bzrlib.trace._trace_file:
 
1596
        if trace._trace_file:
1470
1597
            # flush the log file, to get all content
1471
 
            bzrlib.trace._trace_file.flush()
1472
 
        bzrlib.trace.pop_log_file(self._log_memento)
 
1598
            trace._trace_file.flush()
 
1599
        trace.pop_log_file(self._log_memento)
1473
1600
        # Cache the log result and delete the file on disk
1474
1601
        self._get_log(False)
1475
1602
 
1486
1613
        """
1487
1614
        debug.debug_flags.discard('strict_locks')
1488
1615
 
1489
 
    def addCleanup(self, callable, *args, **kwargs):
1490
 
        """Arrange to run a callable when this case is torn down.
1491
 
 
1492
 
        Callables are run in the reverse of the order they are registered,
1493
 
        ie last-in first-out.
1494
 
        """
1495
 
        self._cleanups.append((callable, args, kwargs))
1496
 
 
1497
1616
    def overrideAttr(self, obj, attr_name, new=_unitialized_attr):
1498
1617
        """Overrides an object attribute restoring it after the test.
1499
1618
 
1513
1632
            setattr(obj, attr_name, new)
1514
1633
        return value
1515
1634
 
 
1635
    def overrideEnv(self, name, new):
 
1636
        """Set an environment variable, and reset it after the test.
 
1637
 
 
1638
        :param name: The environment variable name.
 
1639
 
 
1640
        :param new: The value to set the variable to. If None, the 
 
1641
            variable is deleted from the environment.
 
1642
 
 
1643
        :returns: The actual variable value.
 
1644
        """
 
1645
        value = osutils.set_or_unset_env(name, new)
 
1646
        self.addCleanup(osutils.set_or_unset_env, name, value)
 
1647
        return value
 
1648
 
1516
1649
    def _cleanEnvironment(self):
1517
 
        new_env = {
1518
 
            'BZR_HOME': None, # Don't inherit BZR_HOME to all the tests.
1519
 
            'HOME': os.getcwd(),
1520
 
            # bzr now uses the Win32 API and doesn't rely on APPDATA, but the
1521
 
            # tests do check our impls match APPDATA
1522
 
            'BZR_EDITOR': None, # test_msgeditor manipulates this variable
1523
 
            'VISUAL': None,
1524
 
            'EDITOR': None,
1525
 
            'BZR_EMAIL': None,
1526
 
            'BZREMAIL': None, # may still be present in the environment
1527
 
            'EMAIL': None,
1528
 
            'BZR_PROGRESS_BAR': None,
1529
 
            'BZR_LOG': None,
1530
 
            'BZR_PLUGIN_PATH': None,
1531
 
            'BZR_DISABLE_PLUGINS': None,
1532
 
            'BZR_PLUGINS_AT': None,
1533
 
            'BZR_CONCURRENCY': None,
1534
 
            # Make sure that any text ui tests are consistent regardless of
1535
 
            # the environment the test case is run in; you may want tests that
1536
 
            # test other combinations.  'dumb' is a reasonable guess for tests
1537
 
            # going to a pipe or a StringIO.
1538
 
            'TERM': 'dumb',
1539
 
            'LINES': '25',
1540
 
            'COLUMNS': '80',
1541
 
            'BZR_COLUMNS': '80',
1542
 
            # SSH Agent
1543
 
            'SSH_AUTH_SOCK': None,
1544
 
            # Proxies
1545
 
            'http_proxy': None,
1546
 
            'HTTP_PROXY': None,
1547
 
            'https_proxy': None,
1548
 
            'HTTPS_PROXY': None,
1549
 
            'no_proxy': None,
1550
 
            'NO_PROXY': None,
1551
 
            'all_proxy': None,
1552
 
            'ALL_PROXY': None,
1553
 
            # Nobody cares about ftp_proxy, FTP_PROXY AFAIK. So far at
1554
 
            # least. If you do (care), please update this comment
1555
 
            # -- vila 20080401
1556
 
            'ftp_proxy': None,
1557
 
            'FTP_PROXY': None,
1558
 
            'BZR_REMOTE_PATH': None,
1559
 
            # Generally speaking, we don't want apport reporting on crashes in
1560
 
            # the test envirnoment unless we're specifically testing apport,
1561
 
            # so that it doesn't leak into the real system environment.  We
1562
 
            # use an env var so it propagates to subprocesses.
1563
 
            'APPORT_DISABLE': '1',
1564
 
        }
1565
 
        self._old_env = {}
1566
 
        self.addCleanup(self._restoreEnvironment)
1567
 
        for name, value in new_env.iteritems():
1568
 
            self._captureVar(name, value)
1569
 
 
1570
 
    def _captureVar(self, name, newvalue):
1571
 
        """Set an environment variable, and reset it when finished."""
1572
 
        self._old_env[name] = osutils.set_or_unset_env(name, newvalue)
1573
 
 
1574
 
    def _restoreEnvironment(self):
1575
 
        for name, value in self._old_env.iteritems():
1576
 
            osutils.set_or_unset_env(name, value)
 
1650
        for name, value in isolated_environ.iteritems():
 
1651
            self.overrideEnv(name, value)
1577
1652
 
1578
1653
    def _restoreHooks(self):
1579
1654
        for klass, (name, hooks) in self._preserved_hooks.items():
1583
1658
        """This test has failed for some known reason."""
1584
1659
        raise KnownFailure(reason)
1585
1660
 
 
1661
    def _suppress_log(self):
 
1662
        """Remove the log info from details."""
 
1663
        self.discardDetail('log')
 
1664
 
1586
1665
    def _do_skip(self, result, reason):
 
1666
        self._suppress_log()
1587
1667
        addSkip = getattr(result, 'addSkip', None)
1588
1668
        if not callable(addSkip):
1589
1669
            result.addSuccess(result)
1592
1672
 
1593
1673
    @staticmethod
1594
1674
    def _do_known_failure(self, result, e):
 
1675
        self._suppress_log()
1595
1676
        err = sys.exc_info()
1596
1677
        addExpectedFailure = getattr(result, 'addExpectedFailure', None)
1597
1678
        if addExpectedFailure is not None:
1605
1686
            reason = 'No reason given'
1606
1687
        else:
1607
1688
            reason = e.args[0]
 
1689
        self._suppress_log ()
1608
1690
        addNotApplicable = getattr(result, 'addNotApplicable', None)
1609
1691
        if addNotApplicable is not None:
1610
1692
            result.addNotApplicable(self, reason)
1612
1694
            self._do_skip(result, reason)
1613
1695
 
1614
1696
    @staticmethod
 
1697
    def _report_skip(self, result, err):
 
1698
        """Override the default _report_skip.
 
1699
 
 
1700
        We want to strip the 'log' detail. If we waint until _do_skip, it has
 
1701
        already been formatted into the 'reason' string, and we can't pull it
 
1702
        out again.
 
1703
        """
 
1704
        self._suppress_log()
 
1705
        super(TestCase, self)._report_skip(self, result, err)
 
1706
 
 
1707
    @staticmethod
 
1708
    def _report_expected_failure(self, result, err):
 
1709
        """Strip the log.
 
1710
 
 
1711
        See _report_skip for motivation.
 
1712
        """
 
1713
        self._suppress_log()
 
1714
        super(TestCase, self)._report_expected_failure(self, result, err)
 
1715
 
 
1716
    @staticmethod
1615
1717
    def _do_unsupported_or_skip(self, result, e):
1616
1718
        reason = e.args[0]
 
1719
        self._suppress_log()
1617
1720
        addNotSupported = getattr(result, 'addNotSupported', None)
1618
1721
        if addNotSupported is not None:
1619
1722
            result.addNotSupported(self, reason)
1645
1748
            self._benchtime += time.time() - start
1646
1749
 
1647
1750
    def log(self, *args):
1648
 
        mutter(*args)
 
1751
        trace.mutter(*args)
1649
1752
 
1650
1753
    def _get_log(self, keep_log_file=False):
1651
1754
        """Internal helper to get the log from bzrlib.trace for this test.
1666
1769
                unicodestr = self._log_contents.decode('utf8', 'replace')
1667
1770
                self._log_contents = unicodestr.encode('utf8')
1668
1771
            return self._log_contents
1669
 
        import bzrlib.trace
1670
 
        if bzrlib.trace._trace_file:
1671
 
            # flush the log file, to get all content
1672
 
            bzrlib.trace._trace_file.flush()
1673
 
        if self._log_file_name is not None:
1674
 
            logfile = open(self._log_file_name)
1675
 
            try:
1676
 
                log_contents = logfile.read()
1677
 
            finally:
1678
 
                logfile.close()
 
1772
        if self._log_file is not None:
 
1773
            log_contents = self._log_file.getvalue()
1679
1774
            try:
1680
1775
                log_contents.decode('utf8')
1681
1776
            except UnicodeDecodeError:
1682
1777
                unicodestr = log_contents.decode('utf8', 'replace')
1683
1778
                log_contents = unicodestr.encode('utf8')
1684
1779
            if not keep_log_file:
1685
 
                close_attempts = 0
1686
 
                max_close_attempts = 100
1687
 
                first_close_error = None
1688
 
                while close_attempts < max_close_attempts:
1689
 
                    close_attempts += 1
1690
 
                    try:
1691
 
                        self._log_file.close()
1692
 
                    except IOError, ioe:
1693
 
                        if ioe.errno is None:
1694
 
                            # No errno implies 'close() called during
1695
 
                            # concurrent operation on the same file object', so
1696
 
                            # retry.  Probably a thread is trying to write to
1697
 
                            # the log file.
1698
 
                            if first_close_error is None:
1699
 
                                first_close_error = ioe
1700
 
                            continue
1701
 
                        raise
1702
 
                    else:
1703
 
                        break
1704
 
                if close_attempts > 1:
1705
 
                    sys.stderr.write(
1706
 
                        'Unable to close log file on first attempt, '
1707
 
                        'will retry: %s\n' % (first_close_error,))
1708
 
                    if close_attempts == max_close_attempts:
1709
 
                        sys.stderr.write(
1710
 
                            'Unable to close log file after %d attempts.\n'
1711
 
                            % (max_close_attempts,))
1712
1780
                self._log_file = None
1713
1781
                # Permit multiple calls to get_log until we clean it up in
1714
1782
                # finishLogFile
1715
1783
                self._log_contents = log_contents
1716
 
                try:
1717
 
                    os.remove(self._log_file_name)
1718
 
                except OSError, e:
1719
 
                    if sys.platform == 'win32' and e.errno == errno.EACCES:
1720
 
                        sys.stderr.write(('Unable to delete log file '
1721
 
                                             ' %r\n' % self._log_file_name))
1722
 
                    else:
1723
 
                        raise
1724
 
                self._log_file_name = None
1725
1784
            return log_contents
1726
1785
        else:
1727
 
            return "No log file content and no log file name."
 
1786
            return "No log file content."
1728
1787
 
1729
1788
    def get_log(self):
1730
1789
        """Get a unicode string containing the log from bzrlib.trace.
1780
1839
 
1781
1840
        try:
1782
1841
            try:
1783
 
                result = self.apply_redirected(ui.ui_factory.stdin,
 
1842
                result = self.apply_redirected(
 
1843
                    ui.ui_factory.stdin,
1784
1844
                    stdout, stderr,
1785
 
                    bzrlib.commands.run_bzr_catch_user_errors,
 
1845
                    _mod_commands.run_bzr_catch_user_errors,
1786
1846
                    args)
1787
1847
            except KeyboardInterrupt:
1788
1848
                # Reraise KeyboardInterrupt with contents of redirected stdout
1945
2005
            variables. A value of None will unset the env variable.
1946
2006
            The values must be strings. The change will only occur in the
1947
2007
            child, so you don't need to fix the environment after running.
1948
 
        :param skip_if_plan_to_signal: raise TestSkipped when true and os.kill
1949
 
            is not available.
 
2008
        :param skip_if_plan_to_signal: raise TestSkipped when true and system
 
2009
            doesn't support signalling subprocesses.
1950
2010
        :param allow_plugins: If False (default) pass --no-plugins to bzr.
1951
2011
 
1952
2012
        :returns: Popen object for the started process.
1953
2013
        """
1954
2014
        if skip_if_plan_to_signal:
1955
 
            if not getattr(os, 'kill', None):
1956
 
                raise TestSkipped("os.kill not available.")
 
2015
            if os.name != "posix":
 
2016
                raise TestSkipped("Sending signals not supported")
1957
2017
 
1958
2018
        if env_changes is None:
1959
2019
            env_changes = {}
1986
2046
            if not allow_plugins:
1987
2047
                command.append('--no-plugins')
1988
2048
            command.extend(process_args)
1989
 
            process = self._popen(command, stdin=PIPE, stdout=PIPE, stderr=PIPE)
 
2049
            process = self._popen(command, stdin=subprocess.PIPE,
 
2050
                                  stdout=subprocess.PIPE,
 
2051
                                  stderr=subprocess.PIPE)
1990
2052
        finally:
1991
2053
            restore_environment()
1992
2054
            if cwd is not None:
2000
2062
        Allows tests to override this method to intercept the calls made to
2001
2063
        Popen for introspection.
2002
2064
        """
2003
 
        return Popen(*args, **kwargs)
 
2065
        return subprocess.Popen(*args, **kwargs)
2004
2066
 
2005
2067
    def get_source_path(self):
2006
2068
        """Return the path of the directory containing bzrlib."""
2008
2070
 
2009
2071
    def get_bzr_path(self):
2010
2072
        """Return the path of the 'bzr' executable for this test suite."""
2011
 
        bzr_path = self.get_source_path()+'/bzr'
 
2073
        bzr_path = os.path.join(self.get_source_path(), "bzr")
2012
2074
        if not os.path.isfile(bzr_path):
2013
2075
            # We are probably installed. Assume sys.argv is the right file
2014
2076
            bzr_path = sys.argv[0]
2036
2098
        if retcode is not None and retcode != process.returncode:
2037
2099
            if process_args is None:
2038
2100
                process_args = "(unknown args)"
2039
 
            mutter('Output of bzr %s:\n%s', process_args, out)
2040
 
            mutter('Error for bzr %s:\n%s', process_args, err)
 
2101
            trace.mutter('Output of bzr %s:\n%s', process_args, out)
 
2102
            trace.mutter('Error for bzr %s:\n%s', process_args, err)
2041
2103
            self.fail('Command bzr %s failed with retcode %s != %s'
2042
2104
                      % (process_args, retcode, process.returncode))
2043
2105
        return [out, err]
2100
2162
 
2101
2163
        Tests that expect to provoke LockContention errors should call this.
2102
2164
        """
2103
 
        self.overrideAttr(bzrlib.lockdir, '_DEFAULT_TIMEOUT_SECONDS', 0)
 
2165
        self.overrideAttr(lockdir, '_DEFAULT_TIMEOUT_SECONDS', 0)
2104
2166
 
2105
2167
    def make_utf8_encoded_stringio(self, encoding_type=None):
2106
2168
        """Return a StringIOWrapper instance, that will encode Unicode
2186
2248
 
2187
2249
        :param relpath: a path relative to the base url.
2188
2250
        """
2189
 
        t = get_transport(self.get_url(relpath))
 
2251
        t = _mod_transport.get_transport(self.get_url(relpath))
2190
2252
        self.assertFalse(t.is_readonly())
2191
2253
        return t
2192
2254
 
2198
2260
 
2199
2261
        :param relpath: a path relative to the base url.
2200
2262
        """
2201
 
        t = get_transport(self.get_readonly_url(relpath))
 
2263
        t = _mod_transport.get_transport(self.get_readonly_url(relpath))
2202
2264
        self.assertTrue(t.is_readonly())
2203
2265
        return t
2204
2266
 
2334
2396
        propagating. This method ensures than a test did not leaked.
2335
2397
        """
2336
2398
        root = TestCaseWithMemoryTransport.TEST_ROOT
2337
 
        self.permit_url(get_transport(root).base)
 
2399
        self.permit_url(_mod_transport.get_transport(root).base)
2338
2400
        wt = workingtree.WorkingTree.open(root)
2339
2401
        last_rev = wt.last_revision()
2340
2402
        if last_rev != 'null:':
2385
2447
            # might be a relative or absolute path
2386
2448
            maybe_a_url = self.get_url(relpath)
2387
2449
            segments = maybe_a_url.rsplit('/', 1)
2388
 
            t = get_transport(maybe_a_url)
 
2450
            t = _mod_transport.get_transport(maybe_a_url)
2389
2451
            if len(segments) > 1 and segments[-1] not in ('', '.'):
2390
2452
                t.ensure_base()
2391
2453
            if format is None:
2408
2470
        made_control = self.make_bzrdir(relpath, format=format)
2409
2471
        return made_control.create_repository(shared=shared)
2410
2472
 
2411
 
    def make_smart_server(self, path):
 
2473
    def make_smart_server(self, path, backing_server=None):
 
2474
        if backing_server is None:
 
2475
            backing_server = self.get_server()
2412
2476
        smart_server = test_server.SmartTCPServer_for_testing()
2413
 
        self.start_server(smart_server, self.get_server())
2414
 
        remote_transport = get_transport(smart_server.get_url()).clone(path)
 
2477
        self.start_server(smart_server, backing_server)
 
2478
        remote_transport = _mod_transport.get_transport(smart_server.get_url()
 
2479
                                                   ).clone(path)
2415
2480
        return remote_transport
2416
2481
 
2417
2482
    def make_branch_and_memory_tree(self, relpath, format=None):
2427
2492
        test_home_dir = self.test_home_dir
2428
2493
        if isinstance(test_home_dir, unicode):
2429
2494
            test_home_dir = test_home_dir.encode(sys.getfilesystemencoding())
2430
 
        os.environ['HOME'] = test_home_dir
2431
 
        os.environ['BZR_HOME'] = test_home_dir
 
2495
        self.overrideEnv('HOME', test_home_dir)
 
2496
        self.overrideEnv('BZR_HOME', test_home_dir)
2432
2497
 
2433
2498
    def setUp(self):
2434
2499
        super(TestCaseWithMemoryTransport, self).setUp()
 
2500
        # Ensure that ConnectedTransport doesn't leak sockets
 
2501
        def get_transport_with_cleanup(*args, **kwargs):
 
2502
            t = orig_get_transport(*args, **kwargs)
 
2503
            if isinstance(t, _mod_transport.ConnectedTransport):
 
2504
                self.addCleanup(t.disconnect)
 
2505
            return t
 
2506
 
 
2507
        orig_get_transport = self.overrideAttr(_mod_transport, '_get_transport',
 
2508
                                               get_transport_with_cleanup)
2435
2509
        self._make_test_root()
2436
2510
        self.addCleanup(os.chdir, os.getcwdu())
2437
2511
        self.makeAndChdirToTestDir()
2482
2556
 
2483
2557
    def check_file_contents(self, filename, expect):
2484
2558
        self.log("check contents of file %s" % filename)
2485
 
        contents = file(filename, 'r').read()
 
2559
        f = file(filename)
 
2560
        try:
 
2561
            contents = f.read()
 
2562
        finally:
 
2563
            f.close()
2486
2564
        if contents != expect:
2487
2565
            self.log("expected: %r" % expect)
2488
2566
            self.log("actually: %r" % contents)
2562
2640
                "a list or a tuple. Got %r instead" % (shape,))
2563
2641
        # It's OK to just create them using forward slashes on windows.
2564
2642
        if transport is None or transport.is_readonly():
2565
 
            transport = get_transport(".")
 
2643
            transport = _mod_transport.get_transport(".")
2566
2644
        for name in shape:
2567
2645
            self.assertIsInstance(name, basestring)
2568
2646
            if name[-1] == '/':
2578
2656
                content = "contents of %s%s" % (name.encode('utf-8'), end)
2579
2657
                transport.put_bytes_non_atomic(urlutils.escape(name), content)
2580
2658
 
2581
 
    def build_tree_contents(self, shape):
2582
 
        build_tree_contents(shape)
 
2659
    build_tree_contents = staticmethod(treeshape.build_tree_contents)
2583
2660
 
2584
2661
    def assertInWorkingTree(self, path, root_path='.', tree=None):
2585
2662
        """Assert whether path or paths are in the WorkingTree"""
2726
2803
    """
2727
2804
 
2728
2805
    def setUp(self):
 
2806
        from bzrlib.tests import http_server
2729
2807
        super(ChrootedTestCase, self).setUp()
2730
2808
        if not self.vfs_transport_factory == memory.MemoryServer:
2731
 
            self.transport_readonly_server = HttpServer
 
2809
            self.transport_readonly_server = http_server.HttpServer
2732
2810
 
2733
2811
 
2734
2812
def condition_id_re(pattern):
2737
2815
    :param pattern: A regular expression string.
2738
2816
    :return: A callable that returns True if the re matches.
2739
2817
    """
2740
 
    filter_re = osutils.re_compile_checked(pattern, 0,
2741
 
        'test filter')
 
2818
    filter_re = re.compile(pattern, 0)
2742
2819
    def condition(test):
2743
2820
        test_id = test.id()
2744
2821
        return filter_re.search(test_id)
2996
3073
 
2997
3074
 
2998
3075
def fork_decorator(suite):
 
3076
    if getattr(os, "fork", None) is None:
 
3077
        raise errors.BzrCommandError("platform does not support fork,"
 
3078
            " try --parallel=subprocess instead.")
2999
3079
    concurrency = osutils.local_concurrency()
3000
3080
    if concurrency == 1:
3001
3081
        return suite
3056
3136
    return suite
3057
3137
 
3058
3138
 
3059
 
class TestDecorator(TestSuite):
 
3139
class TestDecorator(TestUtil.TestSuite):
3060
3140
    """A decorator for TestCase/TestSuite objects.
3061
3141
    
3062
3142
    Usually, subclasses should override __iter__(used when flattening test
3065
3145
    """
3066
3146
 
3067
3147
    def __init__(self, suite):
3068
 
        TestSuite.__init__(self)
 
3148
        TestUtil.TestSuite.__init__(self)
3069
3149
        self.addTest(suite)
3070
3150
 
3071
3151
    def countTestCases(self):
3190
3270
 
3191
3271
def partition_tests(suite, count):
3192
3272
    """Partition suite into count lists of tests."""
3193
 
    result = []
3194
 
    tests = list(iter_suite_tests(suite))
3195
 
    tests_per_process = int(math.ceil(float(len(tests)) / count))
3196
 
    for block in range(count):
3197
 
        low_test = block * tests_per_process
3198
 
        high_test = low_test + tests_per_process
3199
 
        process_tests = tests[low_test:high_test]
3200
 
        result.append(process_tests)
3201
 
    return result
 
3273
    # This just assigns tests in a round-robin fashion.  On one hand this
 
3274
    # splits up blocks of related tests that might run faster if they shared
 
3275
    # resources, but on the other it avoids assigning blocks of slow tests to
 
3276
    # just one partition.  So the slowest partition shouldn't be much slower
 
3277
    # than the fastest.
 
3278
    partitions = [list() for i in range(count)]
 
3279
    tests = iter_suite_tests(suite)
 
3280
    for partition, test in itertools.izip(itertools.cycle(partitions), tests):
 
3281
        partition.append(test)
 
3282
    return partitions
3202
3283
 
3203
3284
 
3204
3285
def workaround_zealous_crypto_random():
3238
3319
 
3239
3320
    test_blocks = partition_tests(suite, concurrency)
3240
3321
    for process_tests in test_blocks:
3241
 
        process_suite = TestSuite()
 
3322
        process_suite = TestUtil.TestSuite()
3242
3323
        process_suite.addTests(process_tests)
3243
3324
        c2pread, c2pwrite = os.pipe()
3244
3325
        pid = os.fork()
3310
3391
                '--subunit']
3311
3392
            if '--no-plugins' in sys.argv:
3312
3393
                argv.append('--no-plugins')
3313
 
            # stderr=STDOUT would be ideal, but until we prevent noise on
3314
 
            # stderr it can interrupt the subunit protocol.
3315
 
            process = Popen(argv, stdin=PIPE, stdout=PIPE, stderr=PIPE,
3316
 
                bufsize=1)
 
3394
            # stderr=subprocess.STDOUT would be ideal, but until we prevent
 
3395
            # noise on stderr it can interrupt the subunit protocol.
 
3396
            process = subprocess.Popen(argv, stdin=subprocess.PIPE,
 
3397
                                      stdout=subprocess.PIPE,
 
3398
                                      stderr=subprocess.PIPE,
 
3399
                                      bufsize=1)
3317
3400
            test = TestInSubprocess(process, test_list_file_name)
3318
3401
            result.append(test)
3319
3402
        except:
3322
3405
    return result
3323
3406
 
3324
3407
 
3325
 
class ForwardingResult(unittest.TestResult):
3326
 
 
3327
 
    def __init__(self, target):
3328
 
        unittest.TestResult.__init__(self)
3329
 
        self.result = target
3330
 
 
3331
 
    def startTest(self, test):
3332
 
        self.result.startTest(test)
3333
 
 
3334
 
    def stopTest(self, test):
3335
 
        self.result.stopTest(test)
3336
 
 
3337
 
    def startTestRun(self):
3338
 
        self.result.startTestRun()
3339
 
 
3340
 
    def stopTestRun(self):
3341
 
        self.result.stopTestRun()
3342
 
 
3343
 
    def addSkip(self, test, reason):
3344
 
        self.result.addSkip(test, reason)
3345
 
 
3346
 
    def addSuccess(self, test):
3347
 
        self.result.addSuccess(test)
3348
 
 
3349
 
    def addError(self, test, err):
3350
 
        self.result.addError(test, err)
3351
 
 
3352
 
    def addFailure(self, test, err):
3353
 
        self.result.addFailure(test, err)
3354
 
ForwardingResult = testtools.ExtendedToOriginalDecorator
3355
 
 
3356
 
 
3357
 
class ProfileResult(ForwardingResult):
 
3408
class ProfileResult(testtools.ExtendedToOriginalDecorator):
3358
3409
    """Generate profiling data for all activity between start and success.
3359
3410
    
3360
3411
    The profile data is appended to the test's _benchcalls attribute and can
3368
3419
 
3369
3420
    def startTest(self, test):
3370
3421
        self.profiler = bzrlib.lsprof.BzrProfiler()
 
3422
        # Prevent deadlocks in tests that use lsprof: those tests will
 
3423
        # unavoidably fail.
 
3424
        bzrlib.lsprof.BzrProfiler.profiler_block = 0
3371
3425
        self.profiler.start()
3372
 
        ForwardingResult.startTest(self, test)
 
3426
        testtools.ExtendedToOriginalDecorator.startTest(self, test)
3373
3427
 
3374
3428
    def addSuccess(self, test):
3375
3429
        stats = self.profiler.stop()
3379
3433
            test._benchcalls = []
3380
3434
            calls = test._benchcalls
3381
3435
        calls.append(((test.id(), "", ""), stats))
3382
 
        ForwardingResult.addSuccess(self, test)
 
3436
        testtools.ExtendedToOriginalDecorator.addSuccess(self, test)
3383
3437
 
3384
3438
    def stopTest(self, test):
3385
 
        ForwardingResult.stopTest(self, test)
 
3439
        testtools.ExtendedToOriginalDecorator.stopTest(self, test)
3386
3440
        self.profiler = None
3387
3441
 
3388
3442
 
3394
3448
#                           rather than failing tests. And no longer raise
3395
3449
#                           LockContention when fctnl locks are not being used
3396
3450
#                           with proper exclusion rules.
 
3451
#   -Ethreads               Will display thread ident at creation/join time to
 
3452
#                           help track thread leaks
3397
3453
selftest_debug_flags = set()
3398
3454
 
3399
3455
 
3593
3649
                key, obj, help=help, info=info, override_existing=False)
3594
3650
        except KeyError:
3595
3651
            actual = self.get(key)
3596
 
            note('Test prefix alias %s is already used for %s, ignoring %s'
3597
 
                 % (key, actual, obj))
 
3652
            trace.note(
 
3653
                'Test prefix alias %s is already used for %s, ignoring %s'
 
3654
                % (key, actual, obj))
3598
3655
 
3599
3656
    def resolve_alias(self, id_start):
3600
3657
        """Replace the alias by the prefix in the given string.
3632
3689
        'bzrlib.doc',
3633
3690
        'bzrlib.tests.blackbox',
3634
3691
        'bzrlib.tests.commands',
 
3692
        'bzrlib.tests.doc_generate',
3635
3693
        'bzrlib.tests.per_branch',
3636
3694
        'bzrlib.tests.per_bzrdir',
3637
 
        'bzrlib.tests.per_bzrdir_colo',
 
3695
        'bzrlib.tests.per_controldir',
 
3696
        'bzrlib.tests.per_controldir_colo',
3638
3697
        'bzrlib.tests.per_foreign_vcs',
3639
3698
        'bzrlib.tests.per_interrepository',
3640
3699
        'bzrlib.tests.per_intertree',
3653
3712
        'bzrlib.tests.per_workingtree',
3654
3713
        'bzrlib.tests.test__annotator',
3655
3714
        'bzrlib.tests.test__bencode',
 
3715
        'bzrlib.tests.test__btree_serializer',
3656
3716
        'bzrlib.tests.test__chk_map',
3657
3717
        'bzrlib.tests.test__dirstate_helpers',
3658
3718
        'bzrlib.tests.test__groupcompress',
3701
3761
        'bzrlib.tests.test_export',
3702
3762
        'bzrlib.tests.test_extract',
3703
3763
        'bzrlib.tests.test_fetch',
 
3764
        'bzrlib.tests.test_fixtures',
3704
3765
        'bzrlib.tests.test_fifo_cache',
3705
3766
        'bzrlib.tests.test_filters',
3706
3767
        'bzrlib.tests.test_ftp_transport',
3727
3788
        'bzrlib.tests.test_knit',
3728
3789
        'bzrlib.tests.test_lazy_import',
3729
3790
        'bzrlib.tests.test_lazy_regex',
 
3791
        'bzrlib.tests.test_library_state',
3730
3792
        'bzrlib.tests.test_lock',
3731
3793
        'bzrlib.tests.test_lockable_files',
3732
3794
        'bzrlib.tests.test_lockdir',
3754
3816
        'bzrlib.tests.test_permissions',
3755
3817
        'bzrlib.tests.test_plugins',
3756
3818
        'bzrlib.tests.test_progress',
 
3819
        'bzrlib.tests.test_pyutils',
3757
3820
        'bzrlib.tests.test_read_bundle',
3758
3821
        'bzrlib.tests.test_reconcile',
3759
3822
        'bzrlib.tests.test_reconfigure',
3768
3831
        'bzrlib.tests.test_rio',
3769
3832
        'bzrlib.tests.test_rules',
3770
3833
        'bzrlib.tests.test_sampler',
 
3834
        'bzrlib.tests.test_scenarios',
3771
3835
        'bzrlib.tests.test_script',
3772
3836
        'bzrlib.tests.test_selftest',
3773
3837
        'bzrlib.tests.test_serializer',
3789
3853
        'bzrlib.tests.test_switch',
3790
3854
        'bzrlib.tests.test_symbol_versioning',
3791
3855
        'bzrlib.tests.test_tag',
 
3856
        'bzrlib.tests.test_test_server',
3792
3857
        'bzrlib.tests.test_testament',
3793
3858
        'bzrlib.tests.test_textfile',
3794
3859
        'bzrlib.tests.test_textmerge',
3800
3865
        'bzrlib.tests.test_transport_log',
3801
3866
        'bzrlib.tests.test_tree',
3802
3867
        'bzrlib.tests.test_treebuilder',
 
3868
        'bzrlib.tests.test_treeshape',
3803
3869
        'bzrlib.tests.test_tsort',
3804
3870
        'bzrlib.tests.test_tuned_gzip',
3805
3871
        'bzrlib.tests.test_ui',
3809
3875
        'bzrlib.tests.test_urlutils',
3810
3876
        'bzrlib.tests.test_version',
3811
3877
        'bzrlib.tests.test_version_info',
 
3878
        'bzrlib.tests.test_versionedfile',
3812
3879
        'bzrlib.tests.test_weave',
3813
3880
        'bzrlib.tests.test_whitebox',
3814
3881
        'bzrlib.tests.test_win32utils',
3834
3901
        'bzrlib.lockdir',
3835
3902
        'bzrlib.merge3',
3836
3903
        'bzrlib.option',
 
3904
        'bzrlib.pyutils',
3837
3905
        'bzrlib.symbol_versioning',
3838
3906
        'bzrlib.tests',
 
3907
        'bzrlib.tests.fixtures',
3839
3908
        'bzrlib.timestamp',
 
3909
        'bzrlib.transport.http',
3840
3910
        'bzrlib.version_info_formats.format_custom',
3841
3911
        ]
3842
3912
 
3895
3965
        try:
3896
3966
            # note that this really does mean "report only" -- doctest
3897
3967
            # still runs the rest of the examples
3898
 
            doc_suite = doctest.DocTestSuite(mod,
3899
 
                optionflags=doctest.REPORT_ONLY_FIRST_FAILURE)
 
3968
            doc_suite = IsolatedDocTestSuite(
 
3969
                mod, optionflags=doctest.REPORT_ONLY_FIRST_FAILURE)
3900
3970
        except ValueError, e:
3901
3971
            print '**failed to get doctest for: %s\n%s' % (mod, e)
3902
3972
            raise
3905
3975
        suite.addTest(doc_suite)
3906
3976
 
3907
3977
    default_encoding = sys.getdefaultencoding()
3908
 
    for name, plugin in bzrlib.plugin.plugins().items():
 
3978
    for name, plugin in _mod_plugin.plugins().items():
3909
3979
        if not interesting_module(plugin.module.__name__):
3910
3980
            continue
3911
3981
        plugin_suite = plugin.test_suite()
3917
3987
        if plugin_suite is not None:
3918
3988
            suite.addTest(plugin_suite)
3919
3989
        if default_encoding != sys.getdefaultencoding():
3920
 
            bzrlib.trace.warning(
 
3990
            trace.warning(
3921
3991
                'Plugin "%s" tried to reset default encoding to: %s', name,
3922
3992
                sys.getdefaultencoding())
3923
3993
            reload(sys)
3938
4008
            # Some tests mentioned in the list are not in the test suite. The
3939
4009
            # list may be out of date, report to the tester.
3940
4010
            for id in not_found:
3941
 
                bzrlib.trace.warning('"%s" not found in the test suite', id)
 
4011
                trace.warning('"%s" not found in the test suite', id)
3942
4012
        for id in duplicates:
3943
 
            bzrlib.trace.warning('"%s" is used as an id by several tests', id)
 
4013
            trace.warning('"%s" is used as an id by several tests', id)
3944
4014
 
3945
4015
    return suite
3946
4016
 
3947
4017
 
3948
 
def multiply_scenarios(scenarios_left, scenarios_right):
 
4018
def multiply_scenarios(*scenarios):
 
4019
    """Multiply two or more iterables of scenarios.
 
4020
 
 
4021
    It is safe to pass scenario generators or iterators.
 
4022
 
 
4023
    :returns: A list of compound scenarios: the cross-product of all 
 
4024
        scenarios, with the names concatenated and the parameters
 
4025
        merged together.
 
4026
    """
 
4027
    return reduce(_multiply_two_scenarios, map(list, scenarios))
 
4028
 
 
4029
 
 
4030
def _multiply_two_scenarios(scenarios_left, scenarios_right):
3949
4031
    """Multiply two sets of scenarios.
3950
4032
 
3951
4033
    :returns: the cartesian product of the two sets of scenarios, that is
3982
4064
    ...     bzrlib.tests.test_sampler.DemoTest('test_nothing'),
3983
4065
    ...     [('one', dict(param=1)),
3984
4066
    ...      ('two', dict(param=2))],
3985
 
    ...     TestSuite())
 
4067
    ...     TestUtil.TestSuite())
3986
4068
    >>> tests = list(iter_suite_tests(r))
3987
4069
    >>> len(tests)
3988
4070
    2
4035
4117
    :param new_id: The id to assign to it.
4036
4118
    :return: The new test.
4037
4119
    """
4038
 
    new_test = copy(test)
 
4120
    new_test = copy.copy(test)
4039
4121
    new_test.id = lambda: new_id
 
4122
    # XXX: Workaround <https://bugs.launchpad.net/testtools/+bug/637725>, which
 
4123
    # causes cloned tests to share the 'details' dict.  This makes it hard to
 
4124
    # read the test output for parameterized tests, because tracebacks will be
 
4125
    # associated with irrelevant tests.
 
4126
    try:
 
4127
        details = new_test._TestCase__details
 
4128
    except AttributeError:
 
4129
        # must be a different version of testtools than expected.  Do nothing.
 
4130
        pass
 
4131
    else:
 
4132
        # Reset the '__details' dict.
 
4133
        new_test._TestCase__details = {}
4040
4134
    return new_test
4041
4135
 
4042
4136
 
4063
4157
        the module is available.
4064
4158
    """
4065
4159
 
4066
 
    py_module = __import__(py_module_name, {}, {}, ['NO_SUCH_ATTRIB'])
 
4160
    py_module = pyutils.get_named_object(py_module_name)
4067
4161
    scenarios = [
4068
4162
        ('python', {'module': py_module}),
4069
4163
    ]
4102
4196
        if test_id != None:
4103
4197
            ui.ui_factory.clear_term()
4104
4198
            sys.stderr.write('\nWhile running: %s\n' % (test_id,))
 
4199
        # Ugly, but the last thing we want here is fail, so bear with it.
 
4200
        printable_e = str(e).decode(osutils.get_user_encoding(), 'replace'
 
4201
                                    ).encode('ascii', 'replace')
4105
4202
        sys.stderr.write('Unable to remove testing dir %s\n%s'
4106
 
                         % (os.path.basename(dirname), e))
 
4203
                         % (os.path.basename(dirname), printable_e))
4107
4204
 
4108
4205
 
4109
4206
class Feature(object):
4219
4316
            symbol_versioning.warn(depr_msg + use_msg, DeprecationWarning)
4220
4317
            # Import the new feature and use it as a replacement for the
4221
4318
            # deprecated one.
4222
 
            mod = __import__(self._replacement_module, {}, {},
4223
 
                             [self._replacement_name])
4224
 
            self._feature = getattr(mod, self._replacement_name)
 
4319
            self._feature = pyutils.get_named_object(
 
4320
                self._replacement_module, self._replacement_name)
4225
4321
 
4226
4322
    def _probe(self):
4227
4323
        self._ensure()
4258
4354
        return self.module_name
4259
4355
 
4260
4356
 
4261
 
# This is kept here for compatibility, it is recommended to use
4262
 
# 'bzrlib.tests.feature.paramiko' instead
4263
 
ParamikoFeature = _CompatabilityThunkFeature(
4264
 
    deprecated_in((2,1,0)),
4265
 
    'bzrlib.tests.features', 'ParamikoFeature', 'paramiko')
4266
 
 
4267
 
 
4268
4357
def probe_unicode_in_user_encoding():
4269
4358
    """Try to encode several unicode strings to use in unicode-aware tests.
4270
4359
    Return first successfull match.
4339
4428
UnicodeFilename = _UnicodeFilename()
4340
4429
 
4341
4430
 
 
4431
class _ByteStringNamedFilesystem(Feature):
 
4432
    """Is the filesystem based on bytes?"""
 
4433
 
 
4434
    def _probe(self):
 
4435
        if os.name == "posix":
 
4436
            return True
 
4437
        return False
 
4438
 
 
4439
ByteStringNamedFilesystem = _ByteStringNamedFilesystem()
 
4440
 
 
4441
 
4342
4442
class _UTF8Filesystem(Feature):
4343
4443
    """Is the filesystem UTF-8?"""
4344
4444
 
4446
4546
case_sensitive_filesystem_feature = _CaseSensitiveFilesystemFeature()
4447
4547
 
4448
4548
 
4449
 
# Kept for compatibility, use bzrlib.tests.features.subunit instead
4450
 
SubUnitFeature = _CompatabilityThunkFeature(
4451
 
    deprecated_in((2,1,0)),
4452
 
    'bzrlib.tests.features', 'SubUnitFeature', 'subunit')
4453
4549
# Only define SubUnitBzrRunner if subunit is available.
4454
4550
try:
4455
4551
    from subunit import TestProtocolClient
4456
4552
    from subunit.test_results import AutoTimingTestResultDecorator
 
4553
    class SubUnitBzrProtocolClient(TestProtocolClient):
 
4554
 
 
4555
        def addSuccess(self, test, details=None):
 
4556
            # The subunit client always includes the details in the subunit
 
4557
            # stream, but we don't want to include it in ours.
 
4558
            if details is not None and 'log' in details:
 
4559
                del details['log']
 
4560
            return super(SubUnitBzrProtocolClient, self).addSuccess(
 
4561
                test, details)
 
4562
 
4457
4563
    class SubUnitBzrRunner(TextTestRunner):
4458
4564
        def run(self, test):
4459
4565
            result = AutoTimingTestResultDecorator(
4460
 
                TestProtocolClient(self.stream))
 
4566
                SubUnitBzrProtocolClient(self.stream))
4461
4567
            test.run(result)
4462
4568
            return result
4463
4569
except ImportError: