/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: Canonical.com Patch Queue Manager
  • Date: 2010-02-11 04:02:41 UTC
  • mfrom: (5017.2.2 tariff)
  • Revision ID: pqm@pqm.ubuntu.com-20100211040241-w6n021dz0uus341n
(mbp) add import-tariff tests

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/__init__.py
1
 
# Copyright (C) 2005-2013, 2015, 2016 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"""
18
17
 
19
 
from __future__ import absolute_import
 
18
# TODO: Perhaps there should be an API to find out if bzr running under the
 
19
# test suite -- some plugins might want to avoid making intrusive changes if
 
20
# this is the case.  However, we want behaviour under to test to diverge as
 
21
# little as possible, so this should be used rarely if it's added at all.
 
22
# (Suggestion from j-a-meinel, 2005-11-24)
20
23
 
21
24
# NOTE: Some classes in here use camelCaseNaming() rather than
22
25
# underscore_naming().  That's for consistency with unittest; it's not the
23
 
# general style of breezy.  Please continue that consistency when adding e.g.
 
26
# general style of bzrlib.  Please continue that consistency when adding e.g.
24
27
# new assertFoo() methods.
25
28
 
26
29
import atexit
27
30
import codecs
28
 
import copy
 
31
from copy import copy
 
32
from cStringIO import StringIO
29
33
import difflib
30
34
import doctest
31
35
import errno
32
 
import functools
33
 
from io import (
34
 
    BytesIO,
35
 
    StringIO,
36
 
    TextIOWrapper,
37
 
    )
38
 
import itertools
39
36
import logging
40
37
import math
41
38
import os
42
 
import platform
43
 
import pprint
 
39
from pprint import pformat
44
40
import random
45
41
import re
46
42
import shlex
47
 
import site
48
43
import stat
49
 
import subprocess
 
44
from subprocess import Popen, PIPE, STDOUT
50
45
import sys
51
46
import tempfile
52
47
import threading
58
53
import testtools
59
54
# nb: check this before importing anything else from within it
60
55
_testtools_version = getattr(testtools, '__version__', ())
61
 
if _testtools_version < (0, 9, 5):
62
 
    raise ImportError("need at least testtools 0.9.5: %s is %r"
63
 
                      % (testtools.__file__, _testtools_version))
 
56
if _testtools_version < (0, 9, 2):
 
57
    raise ImportError("need at least testtools 0.9.2: %s is %r"
 
58
        % (testtools.__file__, _testtools_version))
64
59
from testtools import content
65
60
 
66
 
import breezy
67
 
from .. import (
 
61
from bzrlib import (
68
62
    branchbuilder,
69
 
    controldir,
70
 
    commands as _mod_commands,
 
63
    bzrdir,
 
64
    chk_map,
71
65
    config,
72
 
    i18n,
73
66
    debug,
74
67
    errors,
75
68
    hooks,
76
69
    lock as _mod_lock,
77
 
    lockdir,
 
70
    memorytree,
78
71
    osutils,
79
 
    plugin as _mod_plugin,
80
 
    pyutils,
 
72
    progress,
81
73
    ui,
82
74
    urlutils,
83
75
    registry,
84
 
    symbol_versioning,
85
 
    trace,
86
 
    transport as _mod_transport,
87
76
    workingtree,
88
77
    )
89
 
from breezy.bzr import (
90
 
    chk_map,
91
 
    )
 
78
import bzrlib.branch
 
79
import bzrlib.commands
 
80
import bzrlib.timestamp
 
81
import bzrlib.export
 
82
import bzrlib.inventory
 
83
import bzrlib.iterablefile
 
84
import bzrlib.lockdir
92
85
try:
93
 
    import breezy.lsprof
 
86
    import bzrlib.lsprof
94
87
except ImportError:
95
88
    # lsprof not available
96
89
    pass
97
 
from ..sixish import (
98
 
    int2byte,
99
 
    PY3,
100
 
    string_types,
101
 
    text_type,
102
 
    )
103
 
from ..bzr.smart import client, request
104
 
from ..transport import (
105
 
    memory,
106
 
    pathfilter,
107
 
    )
108
 
from ..tests import (
109
 
    fixtures,
110
 
    test_server,
111
 
    TestUtil,
112
 
    treeshape,
113
 
    ui_testing,
114
 
    )
 
90
from bzrlib.merge import merge_inner
 
91
import bzrlib.merge3
 
92
import bzrlib.plugin
 
93
from bzrlib.smart import client, request, server
 
94
import bzrlib.store
 
95
from bzrlib import symbol_versioning
 
96
from bzrlib.symbol_versioning import (
 
97
    DEPRECATED_PARAMETER,
 
98
    deprecated_function,
 
99
    deprecated_in,
 
100
    deprecated_method,
 
101
    deprecated_passed,
 
102
    )
 
103
import bzrlib.trace
 
104
from bzrlib.transport import get_transport, pathfilter
 
105
import bzrlib.transport
 
106
from bzrlib.transport.local import LocalURLServer
 
107
from bzrlib.transport.memory import MemoryServer
 
108
from bzrlib.transport.readonly import ReadonlyServer
 
109
from bzrlib.trace import mutter, note
 
110
from bzrlib.tests import TestUtil
 
111
from bzrlib.tests.http_server import HttpServer
 
112
from bzrlib.tests.TestUtil import (
 
113
                          TestSuite,
 
114
                          TestLoader,
 
115
                          )
 
116
from bzrlib.tests.treeshape import build_tree_contents
 
117
from bzrlib.ui import NullProgressView
 
118
from bzrlib.ui.text import TextUIFactory
 
119
import bzrlib.version_info_formats.format_custom
 
120
from bzrlib.workingtree import WorkingTree, WorkingTreeFormat2
115
121
 
116
122
# Mark this python module as being part of the implementation
117
123
# of unittest: this gives us better tracebacks where the last
118
124
# shown frame is the test code, not our assertXYZ.
119
125
__unittest = 1
120
126
 
121
 
default_transport = test_server.LocalURLServer
 
127
default_transport = LocalURLServer
122
128
 
123
129
 
124
130
_unitialized_attr = object()
129
135
SUBUNIT_SEEK_SET = 0
130
136
SUBUNIT_SEEK_CUR = 1
131
137
 
132
 
# These are intentionally brought into this namespace. That way plugins, etc
133
 
# can just "from breezy.tests import TestCase, TestLoader, etc"
134
 
TestSuite = TestUtil.TestSuite
135
 
TestLoader = TestUtil.TestLoader
136
 
 
137
 
# Tests should run in a clean and clearly defined environment. The goal is to
138
 
# keep them isolated from the running environment as mush as possible. The test
139
 
# framework ensures the variables defined below are set (or deleted if the
140
 
# value is None) before a test is run and reset to their original value after
141
 
# the test is run. Generally if some code depends on an environment variable,
142
 
# the tests should start without this variable in the environment. There are a
143
 
# few exceptions but you shouldn't violate this rule lightly.
144
 
isolated_environ = {
145
 
    'BRZ_HOME': None,
146
 
    'HOME': None,
147
 
    'GNUPGHOME': None,
148
 
    'XDG_CONFIG_HOME': None,
149
 
    # brz now uses the Win32 API and doesn't rely on APPDATA, but the
150
 
    # tests do check our impls match APPDATA
151
 
    'BRZ_EDITOR': None,  # test_msgeditor manipulates this variable
152
 
    'VISUAL': None,
153
 
    'EDITOR': None,
154
 
    'BRZ_EMAIL': None,
155
 
    'BZREMAIL': None,  # may still be present in the environment
156
 
    'EMAIL': 'jrandom@example.com',  # set EMAIL as brz does not guess
157
 
    'BRZ_PROGRESS_BAR': None,
158
 
    # Trap leaks to $XDG_CACHE_HOME/breezy/brz.log. This occurs when tests use
159
 
    # TestCase as a base class instead of TestCaseInTempDir. Tests inheriting
160
 
    # from TestCase should not use disk resources, BRZ_LOG is one.
161
 
    'BRZ_LOG': '/you-should-use-TestCaseInTempDir-if-you-need-a-log-file',
162
 
    'BRZ_PLUGIN_PATH': '-site',
163
 
    'BRZ_DISABLE_PLUGINS': None,
164
 
    'BRZ_PLUGINS_AT': None,
165
 
    'BRZ_CONCURRENCY': None,
166
 
    # Make sure that any text ui tests are consistent regardless of
167
 
    # the environment the test case is run in; you may want tests that
168
 
    # test other combinations.  'dumb' is a reasonable guess for tests
169
 
    # going to a pipe or a BytesIO.
170
 
    'TERM': 'dumb',
171
 
    'LINES': '25',
172
 
    'COLUMNS': '80',
173
 
    'BRZ_COLUMNS': '80',
174
 
    # Disable SSH Agent
175
 
    'SSH_AUTH_SOCK': None,
176
 
    # Proxies
177
 
    'http_proxy': None,
178
 
    'HTTP_PROXY': None,
179
 
    'https_proxy': None,
180
 
    'HTTPS_PROXY': None,
181
 
    'no_proxy': None,
182
 
    'NO_PROXY': None,
183
 
    'all_proxy': None,
184
 
    'ALL_PROXY': None,
185
 
    'BZR_REMOTE_PATH': None,
186
 
    # Generally speaking, we don't want apport reporting on crashes in
187
 
    # the test envirnoment unless we're specifically testing apport,
188
 
    # so that it doesn't leak into the real system environment.  We
189
 
    # use an env var so it propagates to subprocesses.
190
 
    'APPORT_DISABLE': '1',
191
 
    }
192
 
 
193
 
 
194
 
def override_os_environ(test, env=None):
195
 
    """Modify os.environ keeping a copy.
196
 
 
197
 
    :param test: A test instance
198
 
 
199
 
    :param env: A dict containing variable definitions to be installed
200
 
    """
201
 
    if env is None:
202
 
        env = isolated_environ
203
 
    test._original_os_environ = dict(**os.environ)
204
 
    for var in env:
205
 
        osutils.set_or_unset_env(var, env[var])
206
 
        if var not in test._original_os_environ:
207
 
            # The var is new, add it with a value of None, so
208
 
            # restore_os_environ will delete it
209
 
            test._original_os_environ[var] = None
210
 
 
211
 
 
212
 
def restore_os_environ(test):
213
 
    """Restore os.environ to its original state.
214
 
 
215
 
    :param test: A test instance previously passed to override_os_environ.
216
 
    """
217
 
    for var, value in test._original_os_environ.items():
218
 
        # Restore the original value (or delete it if the value has been set to
219
 
        # None in override_os_environ).
220
 
        osutils.set_or_unset_env(var, value)
221
 
 
222
 
 
223
 
def _clear__type_equality_funcs(test):
224
 
    """Cleanup bound methods stored on TestCase instances
225
 
 
226
 
    Clear the dict breaking a few (mostly) harmless cycles in the affected
227
 
    unittests released with Python 2.6 and initial Python 2.7 versions.
228
 
 
229
 
    For a few revisions between Python 2.7.1 and Python 2.7.2 that annoyingly
230
 
    shipped in Oneiric, an object with no clear method was used, hence the
231
 
    extra complications, see bug 809048 for details.
232
 
    """
233
 
    type_equality_funcs = getattr(test, "_type_equality_funcs", None)
234
 
    if type_equality_funcs is not None:
235
 
        tef_clear = getattr(type_equality_funcs, "clear", None)
236
 
        if tef_clear is None:
237
 
            tef_instance_dict = getattr(type_equality_funcs, "__dict__", None)
238
 
            if tef_instance_dict is not None:
239
 
                tef_clear = tef_instance_dict.clear
240
 
        if tef_clear is not None:
241
 
            tef_clear()
242
 
 
243
 
 
244
 
class ExtendedTestResult(testtools.TextTestResult):
 
138
 
 
139
class ExtendedTestResult(unittest._TextTestResult):
245
140
    """Accepts, reports and accumulates the results of running tests.
246
141
 
247
142
    Compared to the unittest version this class adds support for
250
145
    different types of display.
251
146
 
252
147
    When a test finishes, in whatever way, it calls one of the addSuccess,
253
 
    addFailure or addError methods.  These in turn may redirect to a more
 
148
    addFailure or addError classes.  These in turn may redirect to a more
254
149
    specific case for the special test results supported by our extended
255
150
    tests.
256
151
 
268
163
        :param bench_history: Optionally, a writable file object to accumulate
269
164
            benchmark results.
270
165
        """
271
 
        testtools.TextTestResult.__init__(self, stream)
 
166
        unittest._TextTestResult.__init__(self, stream, descriptions, verbosity)
272
167
        if bench_history is not None:
273
 
            from breezy.version import _get_bzr_source_tree
 
168
            from bzrlib.version import _get_bzr_source_tree
274
169
            src_tree = _get_bzr_source_tree()
275
170
            if src_tree:
276
171
                try:
278
173
                except IndexError:
279
174
                    # XXX: if this is a brand new tree, do the same as if there
280
175
                    # is no branch.
281
 
                    revision_id = b''
 
176
                    revision_id = ''
282
177
            else:
283
178
                # XXX: If there's no branch, what should we do?
284
 
                revision_id = b''
 
179
                revision_id = ''
285
180
            bench_history.write("--date %s %s\n" % (time.time(), revision_id))
286
181
        self._bench_history = bench_history
287
182
        self.ui = ui.ui_factory
295
190
        self.count = 0
296
191
        self._overall_start_time = time.time()
297
192
        self._strict = strict
298
 
        self._first_thread_leaker_id = None
299
 
        self._tests_leaking_threads_count = 0
300
 
        self._traceback_from_test = None
301
193
 
302
194
    def stopTestRun(self):
303
195
        run = self.testsRun
304
196
        actionTaken = "Ran"
305
197
        stopTime = time.time()
306
198
        timeTaken = stopTime - self.startTime
307
 
        # GZ 2010-07-19: Seems testtools has no printErrors method, and though
308
 
        #                the parent class method is similar have to duplicate
309
 
        self._show_list('ERROR', self.errors)
310
 
        self._show_list('FAIL', self.failures)
311
 
        self.stream.write(self.sep2)
312
 
        self.stream.write("%s %d test%s in %.3fs\n\n" % (
313
 
            actionTaken, run, run != 1 and "s" or "", timeTaken))
 
199
        self.printErrors()
 
200
        self.stream.writeln(self.separator2)
 
201
        self.stream.writeln("%s %d test%s in %.3fs" % (actionTaken,
 
202
                            run, run != 1 and "s" or "", timeTaken))
 
203
        self.stream.writeln()
314
204
        if not self.wasSuccessful():
315
205
            self.stream.write("FAILED (")
316
206
            failed, errored = map(len, (self.failures, self.errors))
317
207
            if failed:
318
208
                self.stream.write("failures=%d" % failed)
319
209
            if errored:
320
 
                if failed:
321
 
                    self.stream.write(", ")
 
210
                if failed: self.stream.write(", ")
322
211
                self.stream.write("errors=%d" % errored)
323
212
            if self.known_failure_count:
324
 
                if failed or errored:
325
 
                    self.stream.write(", ")
 
213
                if failed or errored: self.stream.write(", ")
326
214
                self.stream.write("known_failure_count=%d" %
327
 
                                  self.known_failure_count)
328
 
            self.stream.write(")\n")
 
215
                    self.known_failure_count)
 
216
            self.stream.writeln(")")
329
217
        else:
330
218
            if self.known_failure_count:
331
 
                self.stream.write("OK (known_failures=%d)\n" %
332
 
                                  self.known_failure_count)
 
219
                self.stream.writeln("OK (known_failures=%d)" %
 
220
                    self.known_failure_count)
333
221
            else:
334
 
                self.stream.write("OK\n")
 
222
                self.stream.writeln("OK")
335
223
        if self.skip_count > 0:
336
224
            skipped = self.skip_count
337
 
            self.stream.write('%d test%s skipped\n' %
338
 
                              (skipped, skipped != 1 and "s" or ""))
 
225
            self.stream.writeln('%d test%s skipped' %
 
226
                                (skipped, skipped != 1 and "s" or ""))
339
227
        if self.unsupported:
340
228
            for feature, count in sorted(self.unsupported.items()):
341
 
                self.stream.write("Missing feature '%s' skipped %d tests.\n" %
342
 
                                  (feature, count))
 
229
                self.stream.writeln("Missing feature '%s' skipped %d tests." %
 
230
                    (feature, count))
343
231
        if self._strict:
344
232
            ok = self.wasStrictlySuccessful()
345
233
        else:
346
234
            ok = self.wasSuccessful()
347
 
        if self._first_thread_leaker_id:
 
235
        if TestCase._first_thread_leaker_id:
348
236
            self.stream.write(
349
237
                '%s is leaking threads among %d leaking tests.\n' % (
350
 
                    self._first_thread_leaker_id,
351
 
                    self._tests_leaking_threads_count))
 
238
                TestCase._first_thread_leaker_id,
 
239
                TestCase._leaking_threads_tests))
352
240
            # We don't report the main thread as an active one.
353
241
            self.stream.write(
354
242
                '%d non-main threads were left active in the end.\n'
355
 
                % (len(self._active_threads) - 1))
 
243
                % (TestCase._active_threads - 1))
356
244
 
357
245
    def getDescription(self, test):
358
246
        return test.id()
363
251
            return float(''.join(details['benchtime'].iter_bytes()))
364
252
        return getattr(testCase, "_benchtime", None)
365
253
 
366
 
    def _delta_to_float(self, a_timedelta, precision):
367
 
        # This calls ceiling to ensure that the most pessimistic view of time
368
 
        # taken is shown (rather than leaving it to the Python %f operator
369
 
        # to decide whether to round/floor/ceiling. This was added when we
370
 
        # had pyp3 test failures that suggest a floor was happening.
371
 
        shift = 10 ** precision
372
 
        return math.ceil(
373
 
            (a_timedelta.days * 86400.0 + a_timedelta.seconds +
374
 
             a_timedelta.microseconds / 1000000.0) * shift) / shift
375
 
 
376
254
    def _elapsedTestTimeString(self):
377
 
        """Return time string for overall time the current test has taken."""
378
 
        return self._formatTime(self._delta_to_float(
379
 
            self._now() - self._start_datetime, 3))
 
255
        """Return a time string for the overall time the current test has taken."""
 
256
        return self._formatTime(time.time() - self._start_time)
380
257
 
381
258
    def _testTimeString(self, testCase):
382
259
        benchmark_time = self._extractBenchmarkTime(testCase)
393
270
 
394
271
    def _shortened_test_description(self, test):
395
272
        what = test.id()
396
 
        what = re.sub(r'^breezy\.tests\.', '', what)
 
273
        what = re.sub(r'^bzrlib\.(tests|benchmarks)\.', '', what)
397
274
        return what
398
275
 
399
 
    # GZ 2010-10-04: Cloned tests may end up harmlessly calling this method
400
 
    #                multiple times in a row, because the handler is added for
401
 
    #                each test but the container list is shared between cases.
402
 
    #                See lp:498869 lp:625574 and lp:637725 for background.
403
 
    def _record_traceback_from_test(self, exc_info):
404
 
        """Store the traceback from passed exc_info tuple till"""
405
 
        self._traceback_from_test = exc_info[2]
406
 
 
407
276
    def startTest(self, test):
408
 
        super(ExtendedTestResult, self).startTest(test)
 
277
        unittest.TestResult.startTest(self, test)
409
278
        if self.count == 0:
410
279
            self.startTests()
411
 
        self.count += 1
412
280
        self.report_test_start(test)
413
281
        test.number = self.count
414
282
        self._recordTestStartTime()
415
 
        # Make testtools cases give us the real traceback on failure
416
 
        addOnException = getattr(test, "addOnException", None)
417
 
        if addOnException is not None:
418
 
            addOnException(self._record_traceback_from_test)
419
 
        # Only check for thread leaks on breezy derived test cases
420
 
        if isinstance(test, TestCase):
421
 
            test.addCleanup(self._check_leaked_threads, test)
422
 
 
423
 
    def stopTest(self, test):
424
 
        super(ExtendedTestResult, self).stopTest(test)
425
 
        # Manually break cycles, means touching various private things but hey
426
 
        getDetails = getattr(test, "getDetails", None)
427
 
        if getDetails is not None:
428
 
            getDetails().clear()
429
 
        _clear__type_equality_funcs(test)
430
 
        self._traceback_from_test = None
431
283
 
432
284
    def startTests(self):
433
 
        self.report_tests_starting()
434
 
        self._active_threads = threading.enumerate()
435
 
 
436
 
    def _check_leaked_threads(self, test):
437
 
        """See if any threads have leaked since last call
438
 
 
439
 
        A sample of live threads is stored in the _active_threads attribute,
440
 
        when this method runs it compares the current live threads and any not
441
 
        in the previous sample are treated as having leaked.
442
 
        """
443
 
        now_active_threads = set(threading.enumerate())
444
 
        threads_leaked = now_active_threads.difference(self._active_threads)
445
 
        if threads_leaked:
446
 
            self._report_thread_leak(test, threads_leaked, now_active_threads)
447
 
            self._tests_leaking_threads_count += 1
448
 
            if self._first_thread_leaker_id is None:
449
 
                self._first_thread_leaker_id = test.id()
450
 
            self._active_threads = now_active_threads
 
285
        import platform
 
286
        if getattr(sys, 'frozen', None) is None:
 
287
            bzr_path = osutils.realpath(sys.argv[0])
 
288
        else:
 
289
            bzr_path = sys.executable
 
290
        self.stream.write(
 
291
            'bzr selftest: %s\n' % (bzr_path,))
 
292
        self.stream.write(
 
293
            '   %s\n' % (
 
294
                    bzrlib.__path__[0],))
 
295
        self.stream.write(
 
296
            '   bzr-%s python-%s %s\n' % (
 
297
                    bzrlib.version_string,
 
298
                    bzrlib._format_version_tuple(sys.version_info),
 
299
                    platform.platform(aliased=1),
 
300
                    ))
 
301
        self.stream.write('\n')
451
302
 
452
303
    def _recordTestStartTime(self):
453
304
        """Record that a test has started."""
454
 
        self._start_datetime = self._now()
 
305
        self._start_time = time.time()
 
306
 
 
307
    def _cleanupLogFile(self, test):
 
308
        # We can only do this if we have one of our TestCases, not if
 
309
        # we have a doctest.
 
310
        setKeepLogfile = getattr(test, 'setKeepLogfile', None)
 
311
        if setKeepLogfile is not None:
 
312
            setKeepLogfile()
455
313
 
456
314
    def addError(self, test, err):
457
315
        """Tell result that test finished with an error.
459
317
        Called from the TestCase run() method when the test
460
318
        fails with an unexpected error.
461
319
        """
462
 
        self._post_mortem(self._traceback_from_test or err[2])
463
 
        super(ExtendedTestResult, self).addError(test, err)
 
320
        self._post_mortem()
 
321
        unittest.TestResult.addError(self, test, err)
464
322
        self.error_count += 1
465
323
        self.report_error(test, err)
466
324
        if self.stop_early:
467
325
            self.stop()
 
326
        self._cleanupLogFile(test)
468
327
 
469
328
    def addFailure(self, test, err):
470
329
        """Tell result that test failed.
472
331
        Called from the TestCase run() method when the test
473
332
        fails because e.g. an assert() method failed.
474
333
        """
475
 
        self._post_mortem(self._traceback_from_test or err[2])
476
 
        super(ExtendedTestResult, self).addFailure(test, err)
 
334
        self._post_mortem()
 
335
        unittest.TestResult.addFailure(self, test, err)
477
336
        self.failure_count += 1
478
337
        self.report_failure(test, err)
479
338
        if self.stop_early:
480
339
            self.stop()
 
340
        self._cleanupLogFile(test)
481
341
 
482
342
    def addSuccess(self, test, details=None):
483
343
        """Tell result that test completed successfully.
491
351
                    self._formatTime(benchmark_time),
492
352
                    test.id()))
493
353
        self.report_success(test)
494
 
        super(ExtendedTestResult, self).addSuccess(test)
 
354
        self._cleanupLogFile(test)
 
355
        unittest.TestResult.addSuccess(self, test)
495
356
        test._log_contents = ''
496
357
 
497
358
    def addExpectedFailure(self, test, err):
498
359
        self.known_failure_count += 1
499
360
        self.report_known_failure(test, err)
500
361
 
501
 
    def addUnexpectedSuccess(self, test, details=None):
502
 
        """Tell result the test unexpectedly passed, counting as a failure
503
 
 
504
 
        When the minimum version of testtools required becomes 0.9.8 this
505
 
        can be updated to use the new handling there.
506
 
        """
507
 
        super(ExtendedTestResult, self).addFailure(test, details=details)
508
 
        self.failure_count += 1
509
 
        self.report_unexpected_success(test,
510
 
                                       "".join(details["reason"].iter_text()))
511
 
        if self.stop_early:
512
 
            self.stop()
513
 
 
514
362
    def addNotSupported(self, test, feature):
515
363
        """The test will not be run because of a missing feature.
516
364
        """
533
381
        self.not_applicable_count += 1
534
382
        self.report_not_applicable(test, reason)
535
383
 
536
 
    def _count_stored_tests(self):
537
 
        """Count of tests instances kept alive due to not succeeding"""
538
 
        return self.error_count + self.failure_count + self.known_failure_count
539
 
 
540
 
    def _post_mortem(self, tb=None):
 
384
    def _post_mortem(self):
541
385
        """Start a PDB post mortem session."""
542
 
        if os.environ.get('BRZ_TEST_PDB', None):
543
 
            import pdb
544
 
            pdb.post_mortem(tb)
 
386
        if os.environ.get('BZR_TEST_PDB', None):
 
387
            import pdb;pdb.post_mortem()
545
388
 
546
389
    def progress(self, offset, whence):
547
390
        """The test is adjusting the count of tests to run."""
552
395
        else:
553
396
            raise errors.BzrError("Unknown whence %r" % whence)
554
397
 
555
 
    def report_tests_starting(self):
556
 
        """Display information before the test run begins"""
557
 
        if getattr(sys, 'frozen', None) is None:
558
 
            bzr_path = osutils.realpath(sys.argv[0])
559
 
        else:
560
 
            bzr_path = sys.executable
561
 
        self.stream.write(
562
 
            'brz selftest: %s\n' % (bzr_path,))
563
 
        self.stream.write(
564
 
            '   %s\n' % (
565
 
                breezy.__path__[0],))
566
 
        self.stream.write(
567
 
            '   bzr-%s python-%s %s\n' % (
568
 
                breezy.version_string,
569
 
                breezy._format_version_tuple(sys.version_info),
570
 
                platform.platform(aliased=1),
571
 
                ))
572
 
        self.stream.write('\n')
573
 
 
574
 
    def report_test_start(self, test):
575
 
        """Display information on the test just about to be run"""
576
 
 
577
 
    def _report_thread_leak(self, test, leaked_threads, active_threads):
578
 
        """Display information on a test that leaked one or more threads"""
579
 
        # GZ 2010-09-09: A leak summary reported separately from the general
580
 
        #                thread debugging would be nice. Tests under subunit
581
 
        #                need something not using stream, perhaps adding a
582
 
        #                testtools details object would be fitting.
583
 
        if 'threads' in selftest_debug_flags:
584
 
            self.stream.write('%s is leaking, active is now %d\n' %
585
 
                              (test.id(), len(active_threads)))
 
398
    def report_cleaning_up(self):
 
399
        pass
586
400
 
587
401
    def startTestRun(self):
588
402
        self.startTime = time.time()
601
415
 
602
416
    def __init__(self, stream, descriptions, verbosity,
603
417
                 bench_history=None,
 
418
                 pb=None,
604
419
                 strict=None,
605
420
                 ):
606
421
        ExtendedTestResult.__init__(self, stream, descriptions, verbosity,
607
 
                                    bench_history, strict)
 
422
            bench_history, strict)
 
423
        # We no longer pass them around, but just rely on the UIFactory stack
 
424
        # for state
 
425
        if pb is not None:
 
426
            warnings.warn("Passing pb to TextTestResult is deprecated")
608
427
        self.pb = self.ui.nested_progress_bar()
609
428
        self.pb.show_pct = False
610
429
        self.pb.show_spinner = False
620
439
        self.pb.finished()
621
440
        super(TextTestResult, self).stopTestRun()
622
441
 
623
 
    def report_tests_starting(self):
624
 
        super(TextTestResult, self).report_tests_starting()
 
442
    def startTestRun(self):
 
443
        super(TextTestResult, self).startTestRun()
625
444
        self.pb.update('[test 0/%d] Starting' % (self.num_tests))
626
445
 
 
446
    def printErrors(self):
 
447
        # clear the pb to make room for the error listing
 
448
        self.pb.clear()
 
449
        super(TextTestResult, self).printErrors()
 
450
 
627
451
    def _progress_prefix_text(self):
628
452
        # the longer this text, the less space we have to show the test
629
453
        # name...
630
454
        a = '[%d' % self.count              # total that have been run
631
455
        # tests skipped as known not to be relevant are not important enough
632
456
        # to show here
633
 
        # if self.skip_count:
634
 
        #     a += ', %d skip' % self.skip_count
635
 
        # if self.known_failure_count:
636
 
        #     a += '+%dX' % self.known_failure_count
 
457
        ## if self.skip_count:
 
458
        ##     a += ', %d skip' % self.skip_count
 
459
        ## if self.known_failure_count:
 
460
        ##     a += '+%dX' % self.known_failure_count
637
461
        if self.num_tests:
638
 
            a += '/%d' % self.num_tests
 
462
            a +='/%d' % self.num_tests
639
463
        a += ' in '
640
464
        runtime = time.time() - self._overall_start_time
641
465
        if runtime >= 60:
651
475
        return a
652
476
 
653
477
    def report_test_start(self, test):
 
478
        self.count += 1
654
479
        self.pb.update(
655
 
            self._progress_prefix_text() +
656
 
            ' ' +
657
 
            self._shortened_test_description(test))
 
480
                self._progress_prefix_text()
 
481
                + ' '
 
482
                + self._shortened_test_description(test))
658
483
 
659
484
    def _test_description(self, test):
660
485
        return self._shortened_test_description(test)
661
486
 
662
487
    def report_error(self, test, err):
663
 
        self.stream.write('ERROR: %s\n    %s\n' % (
 
488
        self.ui.note('ERROR: %s\n    %s\n' % (
664
489
            self._test_description(test),
665
490
            err[1],
666
491
            ))
667
492
 
668
493
    def report_failure(self, test, err):
669
 
        self.stream.write('FAIL: %s\n    %s\n' % (
 
494
        self.ui.note('FAIL: %s\n    %s\n' % (
670
495
            self._test_description(test),
671
496
            err[1],
672
497
            ))
674
499
    def report_known_failure(self, test, err):
675
500
        pass
676
501
 
677
 
    def report_unexpected_success(self, test, reason):
678
 
        self.stream.write('FAIL: %s\n    %s: %s\n' % (
679
 
            self._test_description(test),
680
 
            "Unexpected success. Should have failed",
681
 
            reason,
682
 
            ))
683
 
 
684
502
    def report_skip(self, test, reason):
685
503
        pass
686
504
 
690
508
    def report_unsupported(self, test, feature):
691
509
        """test cannot be run because feature is missing."""
692
510
 
 
511
    def report_cleaning_up(self):
 
512
        self.pb.update('Cleaning up')
 
513
 
693
514
 
694
515
class VerboseTestResult(ExtendedTestResult):
695
516
    """Produce long output, with one line per test run plus times"""
697
518
    def _ellipsize_to_right(self, a_string, final_width):
698
519
        """Truncate and pad a string, keeping the right hand side"""
699
520
        if len(a_string) > final_width:
700
 
            result = '...' + a_string[3 - final_width:]
 
521
            result = '...' + a_string[3-final_width:]
701
522
        else:
702
523
            result = a_string
703
524
        return result.ljust(final_width)
704
525
 
705
 
    def report_tests_starting(self):
 
526
    def startTestRun(self):
 
527
        super(VerboseTestResult, self).startTestRun()
706
528
        self.stream.write('running %d tests...\n' % self.num_tests)
707
 
        super(VerboseTestResult, self).report_tests_starting()
708
529
 
709
530
    def report_test_start(self, test):
 
531
        self.count += 1
710
532
        name = self._shortened_test_description(test)
711
533
        width = osutils.terminal_width()
712
534
        if width is not None:
714
536
            # 11-char time string, plus a trailing blank
715
537
            # when NUMBERED_DIRS: plus 5 chars on test number, plus 1 char on
716
538
            # space
717
 
            self.stream.write(self._ellipsize_to_right(name, width - 18))
 
539
            self.stream.write(self._ellipsize_to_right(name, width-18))
718
540
        else:
719
541
            self.stream.write(name)
720
542
        self.stream.flush()
724
546
        return '%s%s' % (indent, err[1])
725
547
 
726
548
    def report_error(self, test, err):
727
 
        self.stream.write('ERROR %s\n%s\n'
728
 
                          % (self._testTimeString(test),
729
 
                             self._error_summary(err)))
 
549
        self.stream.writeln('ERROR %s\n%s'
 
550
                % (self._testTimeString(test),
 
551
                   self._error_summary(err)))
730
552
 
731
553
    def report_failure(self, test, err):
732
 
        self.stream.write(' FAIL %s\n%s\n'
733
 
                          % (self._testTimeString(test),
734
 
                             self._error_summary(err)))
 
554
        self.stream.writeln(' FAIL %s\n%s'
 
555
                % (self._testTimeString(test),
 
556
                   self._error_summary(err)))
735
557
 
736
558
    def report_known_failure(self, test, err):
737
 
        self.stream.write('XFAIL %s\n%s\n'
738
 
                          % (self._testTimeString(test),
739
 
                             self._error_summary(err)))
740
 
 
741
 
    def report_unexpected_success(self, test, reason):
742
 
        self.stream.write(' FAIL %s\n%s: %s\n'
743
 
                          % (self._testTimeString(test),
744
 
                             "Unexpected success. Should have failed",
745
 
                             reason))
 
559
        self.stream.writeln('XFAIL %s\n%s'
 
560
                % (self._testTimeString(test),
 
561
                   self._error_summary(err)))
746
562
 
747
563
    def report_success(self, test):
748
 
        self.stream.write('   OK %s\n' % self._testTimeString(test))
 
564
        self.stream.writeln('   OK %s' % self._testTimeString(test))
749
565
        for bench_called, stats in getattr(test, '_benchcalls', []):
750
 
            self.stream.write('LSProf output for %s(%s, %s)\n' % bench_called)
 
566
            self.stream.writeln('LSProf output for %s(%s, %s)' % bench_called)
751
567
            stats.pprint(file=self.stream)
752
568
        # flush the stream so that we get smooth output. This verbose mode is
753
569
        # used to show the output in PQM.
754
570
        self.stream.flush()
755
571
 
756
572
    def report_skip(self, test, reason):
757
 
        self.stream.write(' SKIP %s\n%s\n'
758
 
                          % (self._testTimeString(test), reason))
 
573
        self.stream.writeln(' SKIP %s\n%s'
 
574
                % (self._testTimeString(test), reason))
759
575
 
760
576
    def report_not_applicable(self, test, reason):
761
 
        self.stream.write('  N/A %s\n    %s\n'
762
 
                          % (self._testTimeString(test), reason))
 
577
        self.stream.writeln('  N/A %s\n    %s'
 
578
                % (self._testTimeString(test), reason))
763
579
 
764
580
    def report_unsupported(self, test, feature):
765
581
        """test cannot be run because feature is missing."""
766
 
        self.stream.write("NODEP %s\n    The feature '%s' is not available.\n"
767
 
                          % (self._testTimeString(test), feature))
 
582
        self.stream.writeln("NODEP %s\n    The feature '%s' is not available."
 
583
                %(self._testTimeString(test), feature))
768
584
 
769
585
 
770
586
class TextTestRunner(object):
782
598
 
783
599
        :param result_decorators: An optional list of decorators to apply
784
600
            to the result object being used by the runner. Decorators are
785
 
            applied left to right - the first element in the list is the
 
601
            applied left to right - the first element in the list is the 
786
602
            innermost decorator.
787
603
        """
788
604
        # stream may know claim to know to write unicode strings, but in older
791
607
        # to encode using ascii.
792
608
        new_encoding = osutils.get_terminal_encoding()
793
609
        codec = codecs.lookup(new_encoding)
794
 
        encode = codec.encode
795
 
        # GZ 2010-09-08: Really we don't want to be writing arbitrary bytes,
796
 
        #                so should swap to the plain codecs.StreamWriter
797
 
        stream = osutils.UnicodeOrBytesToBytesWriter(encode, stream,
798
 
                                                     "backslashreplace")
 
610
        if type(codec) is tuple:
 
611
            # Python 2.4
 
612
            encode = codec[0]
 
613
        else:
 
614
            encode = codec.encode
 
615
        stream = osutils.UnicodeOrBytesToBytesWriter(encode, stream)
799
616
        stream.encoding = new_encoding
800
 
        self.stream = stream
 
617
        self.stream = unittest._WritelnDecorator(stream)
801
618
        self.descriptions = descriptions
802
619
        self.verbosity = verbosity
803
620
        self._bench_history = bench_history
811
628
        elif self.verbosity >= 2:
812
629
            result_class = VerboseTestResult
813
630
        original_result = result_class(self.stream,
814
 
                                       self.descriptions,
815
 
                                       self.verbosity,
816
 
                                       bench_history=self._bench_history,
817
 
                                       strict=self._strict,
818
 
                                       )
 
631
                              self.descriptions,
 
632
                              self.verbosity,
 
633
                              bench_history=self._bench_history,
 
634
                              strict=self._strict,
 
635
                              )
819
636
        # Signal to result objects that look at stop early policy to stop,
820
637
        original_result.stop_early = self.stop_on_failure
821
638
        result = original_result
863
680
def _clever_some_str(value):
864
681
    try:
865
682
        return str(value)
866
 
    except BaseException:
 
683
    except:
867
684
        try:
868
685
            return repr(value).replace('\\n', '\n')
869
 
        except BaseException:
 
686
        except:
870
687
            return '<unprintable %s object>' % type(value).__name__
871
688
 
872
 
 
873
689
traceback._some_str = _clever_some_str
874
690
 
875
691
 
886
702
    """
887
703
 
888
704
 
889
 
class StringIOWrapper(ui_testing.BytesIOWithEncoding):
890
 
 
891
 
    @symbol_versioning.deprecated_method(
892
 
        symbol_versioning.deprecated_in((3, 0)))
 
705
class StringIOWrapper(object):
 
706
    """A wrapper around cStringIO which just adds an encoding attribute.
 
707
 
 
708
    Internally we can check sys.stdout to see what the output encoding
 
709
    should be. However, cStringIO has no encoding attribute that we can
 
710
    set. So we wrap it instead.
 
711
    """
 
712
    encoding='ascii'
 
713
    _cstring = None
 
714
 
893
715
    def __init__(self, s=None):
894
 
        super(StringIOWrapper, self).__init__(s)
895
 
 
896
 
 
897
 
TestUIFactory = ui_testing.TestUIFactory
898
 
 
899
 
 
900
 
def isolated_doctest_setUp(test):
901
 
    override_os_environ(test)
902
 
    osutils.set_or_unset_env('BRZ_HOME', '/nonexistent')
903
 
    test._orig_ui_factory = ui.ui_factory
904
 
    ui.ui_factory = ui.SilentUIFactory()
905
 
 
906
 
 
907
 
def isolated_doctest_tearDown(test):
908
 
    restore_os_environ(test)
909
 
    ui.ui_factory = test._orig_ui_factory
910
 
 
911
 
 
912
 
def IsolatedDocTestSuite(*args, **kwargs):
913
 
    """Overrides doctest.DocTestSuite to handle isolation.
914
 
 
915
 
    The method is really a factory and users are expected to use it as such.
 
716
        if s is not None:
 
717
            self.__dict__['_cstring'] = StringIO(s)
 
718
        else:
 
719
            self.__dict__['_cstring'] = StringIO()
 
720
 
 
721
    def __getattr__(self, name, getattr=getattr):
 
722
        return getattr(self.__dict__['_cstring'], name)
 
723
 
 
724
    def __setattr__(self, name, val):
 
725
        if name == 'encoding':
 
726
            self.__dict__['encoding'] = val
 
727
        else:
 
728
            return setattr(self._cstring, name, val)
 
729
 
 
730
 
 
731
class TestUIFactory(TextUIFactory):
 
732
    """A UI Factory for testing.
 
733
 
 
734
    Hide the progress bar but emit note()s.
 
735
    Redirect stdin.
 
736
    Allows get_password to be tested without real tty attached.
 
737
 
 
738
    See also CannedInputUIFactory which lets you provide programmatic input in
 
739
    a structured way.
916
740
    """
917
 
 
918
 
    kwargs['setUp'] = isolated_doctest_setUp
919
 
    kwargs['tearDown'] = isolated_doctest_tearDown
920
 
    return doctest.DocTestSuite(*args, **kwargs)
 
741
    # TODO: Capture progress events at the model level and allow them to be
 
742
    # observed by tests that care.
 
743
    #
 
744
    # XXX: Should probably unify more with CannedInputUIFactory or a
 
745
    # particular configuration of TextUIFactory, or otherwise have a clearer
 
746
    # idea of how they're supposed to be different.
 
747
    # See https://bugs.edge.launchpad.net/bzr/+bug/408213
 
748
 
 
749
    def __init__(self, stdout=None, stderr=None, stdin=None):
 
750
        if stdin is not None:
 
751
            # We use a StringIOWrapper to be able to test various
 
752
            # encodings, but the user is still responsible to
 
753
            # encode the string and to set the encoding attribute
 
754
            # of StringIOWrapper.
 
755
            stdin = StringIOWrapper(stdin)
 
756
        super(TestUIFactory, self).__init__(stdin, stdout, stderr)
 
757
 
 
758
    def get_non_echoed_password(self):
 
759
        """Get password from stdin without trying to handle the echo mode"""
 
760
        password = self.stdin.readline()
 
761
        if not password:
 
762
            raise EOFError
 
763
        if password[-1] == '\n':
 
764
            password = password[:-1]
 
765
        return password
 
766
 
 
767
    def make_progress_view(self):
 
768
        return NullProgressView()
921
769
 
922
770
 
923
771
class TestCase(testtools.TestCase):
924
 
    """Base class for brz unit tests.
 
772
    """Base class for bzr unit tests.
925
773
 
926
774
    Tests that need access to disk resources should subclass
927
775
    TestCaseInTempDir not TestCase.
933
781
    is read into memory and removed from disk.
934
782
 
935
783
    There are also convenience functions to invoke bzr's command-line
936
 
    routine, and to build and check brz trees.
 
784
    routine, and to build and check bzr trees.
937
785
 
938
786
    In addition to the usual method of overriding tearDown(), this class also
939
 
    allows subclasses to register cleanup functions via addCleanup, which are
 
787
    allows subclasses to register functions into the _cleanups list, which is
940
788
    run in order as the object is torn down.  It's less likely this will be
941
789
    accidentally overlooked.
942
790
    """
943
791
 
944
 
    _log_file = None
 
792
    _active_threads = None
 
793
    _leaking_threads_tests = 0
 
794
    _first_thread_leaker_id = None
 
795
    _log_file_name = None
945
796
    # record lsprof data when performing benchmark calls.
946
797
    _gather_lsprof_in_benchmarks = False
947
798
 
948
799
    def __init__(self, methodName='testMethod'):
949
800
        super(TestCase, self).__init__(methodName)
 
801
        self._cleanups = []
950
802
        self._directory_isolation = True
951
 
        self.exception_handlers.insert(
952
 
            0, (UnavailableFeature, self._do_unsupported_or_skip))
953
 
        self.exception_handlers.insert(
954
 
            0, (TestNotApplicable, self._do_not_applicable))
 
803
        self.exception_handlers.insert(0,
 
804
            (UnavailableFeature, self._do_unsupported_or_skip))
 
805
        self.exception_handlers.insert(0,
 
806
            (TestNotApplicable, self._do_not_applicable))
955
807
 
956
808
    def setUp(self):
957
809
        super(TestCase, self).setUp()
958
 
 
959
 
        # At this point we're still accessing the config files in $BRZ_HOME (as
960
 
        # set by the user running selftest).
961
 
        timeout = config.GlobalStack().get('selftest.timeout')
962
 
        if timeout:
963
 
            timeout_fixture = fixtures.TimeoutFixture(timeout)
964
 
            timeout_fixture.setUp()
965
 
            self.addCleanup(timeout_fixture.cleanUp)
966
 
 
967
810
        for feature in getattr(self, '_test_needs_features', []):
968
811
            self.requireFeature(feature)
 
812
        self._log_contents = None
 
813
        self.addDetail("log", content.Content(content.ContentType("text",
 
814
            "plain", {"charset": "utf8"}),
 
815
            lambda:[self._get_log(keep_log_file=True)]))
969
816
        self._cleanEnvironment()
970
 
 
971
 
        self.overrideAttr(breezy.get_global_state(), 'cmdline_overrides',
972
 
                          config.CommandLineStore())
973
 
 
974
817
        self._silenceUI()
975
818
        self._startLogFile()
976
819
        self._benchcalls = []
979
822
        self._track_transports()
980
823
        self._track_locks()
981
824
        self._clear_debug_flags()
982
 
        # Isolate global verbosity level, to make sure it's reproducible
983
 
        # between tests.  We should get rid of this altogether: bug 656694. --
984
 
        # mbp 20101008
985
 
        self.overrideAttr(breezy.trace, '_verbosity_level', 0)
986
 
        self._log_files = set()
987
 
        # Each key in the ``_counters`` dict holds a value for a different
988
 
        # counter. When the test ends, addDetail() should be used to output the
989
 
        # counter values. This happens in install_counter_hook().
990
 
        self._counters = {}
991
 
        if 'config_stats' in selftest_debug_flags:
992
 
            self._install_config_stats_hooks()
993
 
        # Do not use i18n for tests (unless the test reverses this)
994
 
        i18n.disable_i18n()
 
825
        TestCase._active_threads = threading.activeCount()
 
826
        self.addCleanup(self._check_leaked_threads)
995
827
 
996
828
    def debug(self):
997
829
        # debug a frame up.
998
830
        import pdb
999
 
        # The sys preserved stdin/stdout should allow blackbox tests debugging
1000
 
        pdb.Pdb(stdin=sys.__stdin__, stdout=sys.__stdout__
1001
 
                ).set_trace(sys._getframe().f_back)
1002
 
 
1003
 
    def discardDetail(self, name):
1004
 
        """Extend the addDetail, getDetails api so we can remove a detail.
1005
 
 
1006
 
        eg. brz always adds the 'log' detail at startup, but we don't want to
1007
 
        include it for skipped, xfail, etc tests.
1008
 
 
1009
 
        It is safe to call this for a detail that doesn't exist, in case this
1010
 
        gets called multiple times.
1011
 
        """
1012
 
        # We cheat. details is stored in __details which means we shouldn't
1013
 
        # touch it. but getDetails() returns the dict directly, so we can
1014
 
        # mutate it.
1015
 
        details = self.getDetails()
1016
 
        if name in details:
1017
 
            del details[name]
1018
 
 
1019
 
    def install_counter_hook(self, hooks, name, counter_name=None):
1020
 
        """Install a counting hook.
1021
 
 
1022
 
        Any hook can be counted as long as it doesn't need to return a value.
1023
 
 
1024
 
        :param hooks: Where the hook should be installed.
1025
 
 
1026
 
        :param name: The hook name that will be counted.
1027
 
 
1028
 
        :param counter_name: The counter identifier in ``_counters``, defaults
1029
 
            to ``name``.
1030
 
        """
1031
 
        _counters = self._counters  # Avoid closing over self
1032
 
        if counter_name is None:
1033
 
            counter_name = name
1034
 
        if counter_name in _counters:
1035
 
            raise AssertionError('%s is already used as a counter name'
1036
 
                                 % (counter_name,))
1037
 
        _counters[counter_name] = 0
1038
 
        self.addDetail(counter_name, content.Content(
1039
 
            content.UTF8_TEXT,
1040
 
            lambda: [b'%d' % (_counters[counter_name],)]))
1041
 
 
1042
 
        def increment_counter(*args, **kwargs):
1043
 
            _counters[counter_name] += 1
1044
 
        label = 'count %s calls' % (counter_name,)
1045
 
        hooks.install_named_hook(name, increment_counter, label)
1046
 
        self.addCleanup(hooks.uninstall_named_hook, name, label)
1047
 
 
1048
 
    def _install_config_stats_hooks(self):
1049
 
        """Install config hooks to count hook calls.
1050
 
 
1051
 
        """
1052
 
        for hook_name in ('get', 'set', 'remove', 'load', 'save'):
1053
 
            self.install_counter_hook(config.ConfigHooks, hook_name,
1054
 
                                      'config.%s' % (hook_name,))
1055
 
 
1056
 
        # The OldConfigHooks are private and need special handling to protect
1057
 
        # against recursive tests (tests that run other tests), so we just do
1058
 
        # manually what registering them into _builtin_known_hooks will provide
1059
 
        # us.
1060
 
        self.overrideAttr(config, 'OldConfigHooks', config._OldConfigHooks())
1061
 
        for hook_name in ('get', 'set', 'remove', 'load', 'save'):
1062
 
            self.install_counter_hook(config.OldConfigHooks, hook_name,
1063
 
                                      'old_config.%s' % (hook_name,))
 
831
        pdb.Pdb().set_trace(sys._getframe().f_back)
 
832
 
 
833
    def _check_leaked_threads(self):
 
834
        active = threading.activeCount()
 
835
        leaked_threads = active - TestCase._active_threads
 
836
        TestCase._active_threads = active
 
837
        # If some tests make the number of threads *decrease*, we'll consider
 
838
        # that they are just observing old threads dieing, not agressively kill
 
839
        # random threads. So we don't report these tests as leaking. The risk
 
840
        # is that we have false positives that way (the test see 2 threads
 
841
        # going away but leak one) but it seems less likely than the actual
 
842
        # false positives (the test see threads going away and does not leak).
 
843
        if leaked_threads > 0:
 
844
            TestCase._leaking_threads_tests += 1
 
845
            if TestCase._first_thread_leaker_id is None:
 
846
                TestCase._first_thread_leaker_id = self.id()
1064
847
 
1065
848
    def _clear_debug_flags(self):
1066
849
        """Prevent externally set debug flags affecting tests.
1077
860
 
1078
861
    def _clear_hooks(self):
1079
862
        # prevent hooks affecting tests
1080
 
        known_hooks = hooks.known_hooks
1081
863
        self._preserved_hooks = {}
1082
 
        for key, (parent, name) in known_hooks.iter_parent_objects():
1083
 
            current_hooks = getattr(parent, name)
 
864
        for key, factory in hooks.known_hooks.items():
 
865
            parent, name = hooks.known_hooks_key_to_parent_and_attribute(key)
 
866
            current_hooks = hooks.known_hooks_key_to_object(key)
1084
867
            self._preserved_hooks[parent] = (name, current_hooks)
1085
 
        self._preserved_lazy_hooks = hooks._lazy_hooks
1086
 
        hooks._lazy_hooks = {}
1087
868
        self.addCleanup(self._restoreHooks)
1088
 
        for key, (parent, name) in known_hooks.iter_parent_objects():
1089
 
            factory = known_hooks.get(key)
 
869
        for key, factory in hooks.known_hooks.items():
 
870
            parent, name = hooks.known_hooks_key_to_parent_and_attribute(key)
1090
871
            setattr(parent, name, factory())
1091
872
        # this hook should always be installed
1092
873
        request._install_hook()
1121
902
        # break some locks on purpose and should be taken into account by
1122
903
        # considering that breaking a lock is just a dirty way of releasing it.
1123
904
        if len(acquired_locks) != (len(released_locks) + len(broken_locks)):
1124
 
            message = (
1125
 
                'Different number of acquired and '
1126
 
                'released or broken locks.\n'
1127
 
                'acquired=%s\n'
1128
 
                'released=%s\n'
1129
 
                'broken=%s\n' %
1130
 
                (acquired_locks, released_locks, broken_locks))
 
905
            message = ('Different number of acquired and '
 
906
                       'released or broken locks. (%s, %s + %s)' %
 
907
                       (acquired_locks, released_locks, broken_locks))
1131
908
            if not self._lock_check_thorough:
1132
909
                # Rather than fail, just warn
1133
 
                print("Broken test %s: %s" % (self, message))
 
910
                print "Broken test %s: %s" % (self, message)
1134
911
                return
1135
912
            self.fail(message)
1136
913
 
1161
938
 
1162
939
    def permit_dir(self, name):
1163
940
        """Permit a directory to be used by this test. See permit_url."""
1164
 
        name_transport = _mod_transport.get_transport_from_path(name)
 
941
        name_transport = get_transport(name)
1165
942
        self.permit_url(name)
1166
943
        self.permit_url(name_transport.base)
1167
944
 
1168
945
    def permit_url(self, url):
1169
946
        """Declare that url is an ok url to use in this test.
1170
 
 
 
947
        
1171
948
        Do this for memory transports, temporary test directory etc.
1172
 
 
 
949
        
1173
950
        Do not do this for the current working directory, /tmp, or any other
1174
951
        preexisting non isolated url.
1175
952
        """
1178
955
        self._bzr_selftest_roots.append(url)
1179
956
 
1180
957
    def permit_source_tree_branch_repo(self):
1181
 
        """Permit the source tree brz is running from to be opened.
 
958
        """Permit the source tree bzr is running from to be opened.
1182
959
 
1183
 
        Some code such as breezy.version attempts to read from the brz branch
1184
 
        that brz is executing from (if any). This method permits that directory
 
960
        Some code such as bzrlib.version attempts to read from the bzr branch
 
961
        that bzr is executing from (if any). This method permits that directory
1185
962
        to be used in the test suite.
1186
963
        """
1187
964
        path = self.get_source_path()
1190
967
            try:
1191
968
                workingtree.WorkingTree.open(path)
1192
969
            except (errors.NotBranchError, errors.NoWorkingTree):
1193
 
                raise TestSkipped('Needs a working tree of brz sources')
 
970
                return
1194
971
        finally:
1195
972
            self.enable_directory_isolation()
1196
973
 
1219
996
            return
1220
997
        # This prevents all transports, including e.g. sftp ones backed on disk
1221
998
        # from working unless they are explicitly granted permission. We then
1222
 
        # depend on the code that sets up test transports to check that they
1223
 
        # are appropriately isolated and enable their use by calling
 
999
        # depend on the code that sets up test transports to check that they are
 
1000
        # appropriately isolated and enable their use by calling
1224
1001
        # self.permit_transport()
1225
1002
        if not osutils.is_inside_any(self._bzr_selftest_roots, url):
1226
1003
            raise errors.BzrError("Attempt to escape test isolation: %r %r"
1227
 
                                  % (url, self._bzr_selftest_roots))
 
1004
                % (url, self._bzr_selftest_roots))
1228
1005
 
1229
1006
    def record_directory_isolation(self):
1230
1007
        """Gather accessed directories to permit later access.
1231
 
 
1232
 
        This is used for tests that access the branch brz is running from.
 
1008
        
 
1009
        This is used for tests that access the branch bzr is running from.
1233
1010
        """
1234
1011
        self._directory_isolation = "record"
1235
1012
 
1246
1023
        self.addCleanup(transport_server.stop_server)
1247
1024
        # Obtain a real transport because if the server supplies a password, it
1248
1025
        # will be hidden from the base on the client side.
1249
 
        t = _mod_transport.get_transport_from_url(transport_server.get_url())
 
1026
        t = get_transport(transport_server.get_url())
1250
1027
        # Some transport servers effectively chroot the backing transport;
1251
1028
        # others like SFTPServer don't - users of the transport can walk up the
1252
1029
        # transport to read the entire backing transport. This wouldn't matter
1263
1040
        if t.base.endswith('/work/'):
1264
1041
            # we have safety net/test root/work
1265
1042
            t = t.clone('../..')
1266
 
        elif isinstance(transport_server,
1267
 
                        test_server.SmartTCPServer_for_testing):
 
1043
        elif isinstance(transport_server, server.SmartTCPServer_for_testing):
1268
1044
            # The smart server adds a path similar to work, which is traversed
1269
1045
            # up from by the client. But the server is chrooted - the actual
1270
1046
            # backing transport is not escaped from, and VFS requests to the
1280
1056
        # TestCase has no safe place it can write to.
1281
1057
        self._bzr_selftest_roots = []
1282
1058
        # Currently the easiest way to be sure that nothing is going on is to
1283
 
        # hook into brz dir opening. This leaves a small window of error for
 
1059
        # hook into bzr dir opening. This leaves a small window of error for
1284
1060
        # transport tests, but they are well known, and we can improve on this
1285
1061
        # step.
1286
 
        controldir.ControlDir.hooks.install_named_hook(
1287
 
            "pre_open", self._preopen_isolate_transport,
1288
 
            "Check brz directories are safe.")
 
1062
        bzrdir.BzrDir.hooks.install_named_hook("pre_open",
 
1063
            self._preopen_isolate_transport, "Check bzr directories are safe.")
1289
1064
 
1290
1065
    def _ndiff_strings(self, a, b):
1291
1066
        """Return ndiff between two strings containing lines.
1292
1067
 
1293
1068
        A trailing newline is added if missing to make the strings
1294
1069
        print properly."""
1295
 
        if b and not b.endswith('\n'):
 
1070
        if b and b[-1] != '\n':
1296
1071
            b += '\n'
1297
 
        if a and not a.endswith('\n'):
 
1072
        if a and a[-1] != '\n':
1298
1073
            a += '\n'
1299
1074
        difflines = difflib.ndiff(a.splitlines(True),
1300
1075
                                  b.splitlines(True),
1306
1081
        try:
1307
1082
            if a == b:
1308
1083
                return
1309
 
        except UnicodeError as e:
 
1084
        except UnicodeError, e:
1310
1085
            # If we can't compare without getting a UnicodeError, then
1311
1086
            # obviously they are different
1312
 
            trace.mutter('UnicodeError: %s', e)
 
1087
            mutter('UnicodeError: %s', e)
1313
1088
        if message:
1314
1089
            message += '\n'
1315
1090
        raise AssertionError("%snot equal:\na = %s\nb = %s\n"
1316
 
                             % (message,
1317
 
                                pprint.pformat(a), pprint.pformat(b)))
 
1091
            % (message,
 
1092
               pformat(a), pformat(b)))
1318
1093
 
1319
 
    # FIXME: This is deprecated in unittest2 but plugins may still use it so we
1320
 
    # need a deprecation period for them -- vila 2016-02-01
1321
1094
    assertEquals = assertEqual
1322
1095
 
1323
1096
    def assertEqualDiff(self, a, b, message=None):
1326
1099
        This is intended for use with multi-line strings where it can
1327
1100
        be hard to find the differences by eye.
1328
1101
        """
1329
 
        # TODO: perhaps override assertEqual to call this for strings?
 
1102
        # TODO: perhaps override assertEquals to call this for strings?
1330
1103
        if a == b:
1331
1104
            return
1332
1105
        if message is None:
1333
1106
            message = "texts not equal:\n"
1334
 
        if a + ('\n' if isinstance(a, text_type) else b'\n') == b:
 
1107
        if a + '\n' == b:
1335
1108
            message = 'first string is missing a final newline.\n'
1336
 
        if a == b + ('\n' if isinstance(b, text_type) else b'\n'):
 
1109
        if a == b + '\n':
1337
1110
            message = 'second string is missing a final newline.\n'
1338
 
        raise AssertionError(message
1339
 
                             + self._ndiff_strings(
1340
 
                                 a if isinstance(a, text_type) else a.decode(),
1341
 
                                 b if isinstance(b, text_type) else b.decode()))
 
1111
        raise AssertionError(message +
 
1112
                             self._ndiff_strings(a, b))
1342
1113
 
1343
1114
    def assertEqualMode(self, mode, mode_test):
1344
1115
        self.assertEqual(mode, mode_test,
1358
1129
                         'st_mtime did not match')
1359
1130
        self.assertEqual(expected.st_ctime, actual.st_ctime,
1360
1131
                         'st_ctime did not match')
1361
 
        if sys.platform == 'win32':
 
1132
        if sys.platform != 'win32':
1362
1133
            # On Win32 both 'dev' and 'ino' cannot be trusted. In python2.4 it
1363
1134
            # is 'dev' that varies, in python 2.5 (6?) it is st_ino that is
1364
 
            # odd. We just force it to always be 0 to avoid any problems.
1365
 
            self.assertEqual(0, expected.st_dev)
1366
 
            self.assertEqual(0, actual.st_dev)
1367
 
            self.assertEqual(0, expected.st_ino)
1368
 
            self.assertEqual(0, actual.st_ino)
1369
 
        else:
 
1135
            # odd. Regardless we shouldn't actually try to assert anything
 
1136
            # about their values
1370
1137
            self.assertEqual(expected.st_dev, actual.st_dev,
1371
1138
                             'st_dev did not match')
1372
1139
            self.assertEqual(expected.st_ino, actual.st_ino,
1381
1148
                length, len(obj_with_len), obj_with_len))
1382
1149
 
1383
1150
    def assertLogsError(self, exception_class, func, *args, **kwargs):
1384
 
        """Assert that `func(*args, **kwargs)` quietly logs a specific error.
 
1151
        """Assert that func(*args, **kwargs) quietly logs a specific exception.
1385
1152
        """
 
1153
        from bzrlib import trace
1386
1154
        captured = []
1387
1155
        orig_log_exception_quietly = trace.log_exception_quietly
1388
1156
        try:
1389
1157
            def capture():
1390
1158
                orig_log_exception_quietly()
1391
 
                captured.append(sys.exc_info()[1])
 
1159
                captured.append(sys.exc_info())
1392
1160
            trace.log_exception_quietly = capture
1393
1161
            func(*args, **kwargs)
1394
1162
        finally:
1395
1163
            trace.log_exception_quietly = orig_log_exception_quietly
1396
1164
        self.assertLength(1, captured)
1397
 
        err = captured[0]
 
1165
        err = captured[0][1]
1398
1166
        self.assertIsInstance(err, exception_class)
1399
1167
        return err
1400
1168
 
1408
1176
 
1409
1177
    def assertStartsWith(self, s, prefix):
1410
1178
        if not s.startswith(prefix):
1411
 
            raise AssertionError(
1412
 
                'string %r does not start with %r' % (s, prefix))
 
1179
            raise AssertionError('string %r does not start with %r' % (s, prefix))
1413
1180
 
1414
1181
    def assertEndsWith(self, s, suffix):
1415
1182
        """Asserts that s ends with suffix."""
1416
1183
        if not s.endswith(suffix):
1417
 
            raise AssertionError(
1418
 
                'string %r does not end with %r' % (s, suffix))
 
1184
            raise AssertionError('string %r does not end with %r' % (s, suffix))
1419
1185
 
1420
1186
    def assertContainsRe(self, haystack, needle_re, flags=0):
1421
1187
        """Assert that a contains something matching a regular expression."""
1422
1188
        if not re.search(needle_re, haystack, flags):
1423
 
            if (('\n' if isinstance(haystack, str) else b'\n') in haystack or
1424
 
                    len(haystack) > 60):
 
1189
            if '\n' in haystack or len(haystack) > 60:
1425
1190
                # a long string, format it in a more readable way
1426
1191
                raise AssertionError(
1427
 
                    'pattern "%s" not found in\n"""\\\n%s"""\n'
1428
 
                    % (needle_re, haystack))
 
1192
                        'pattern "%s" not found in\n"""\\\n%s"""\n'
 
1193
                        % (needle_re, haystack))
1429
1194
            else:
1430
1195
                raise AssertionError('pattern "%s" not found in "%s"'
1431
 
                                     % (needle_re, haystack))
 
1196
                        % (needle_re, haystack))
1432
1197
 
1433
1198
    def assertNotContainsRe(self, haystack, needle_re, flags=0):
1434
1199
        """Assert that a does not match a regular expression"""
1435
1200
        if re.search(needle_re, haystack, flags):
1436
1201
            raise AssertionError('pattern "%s" found in "%s"'
1437
 
                                 % (needle_re, haystack))
 
1202
                    % (needle_re, haystack))
1438
1203
 
1439
1204
    def assertContainsString(self, haystack, needle):
1440
1205
        if haystack.find(needle) == -1:
1441
1206
            self.fail("string %r not found in '''%s'''" % (needle, haystack))
1442
1207
 
1443
 
    def assertNotContainsString(self, haystack, needle):
1444
 
        if haystack.find(needle) != -1:
1445
 
            self.fail("string %r found in '''%s'''" % (needle, haystack))
1446
 
 
1447
1208
    def assertSubset(self, sublist, superlist):
1448
1209
        """Assert that every entry in sublist is present in superlist."""
1449
1210
        missing = set(sublist) - set(superlist)
1460
1221
        """
1461
1222
        try:
1462
1223
            list(func(*args, **kwargs))
1463
 
        except excClass as e:
 
1224
        except excClass, e:
1464
1225
            return e
1465
1226
        else:
1466
 
            if getattr(excClass, '__name__', None) is not None:
 
1227
            if getattr(excClass,'__name__', None) is not None:
1467
1228
                excName = excClass.__name__
1468
1229
            else:
1469
1230
                excName = str(excClass)
1470
 
            raise self.failureException("%s not raised" % excName)
 
1231
            raise self.failureException, "%s not raised" % excName
1471
1232
 
1472
1233
    def assertRaises(self, excClass, callableObj, *args, **kwargs):
1473
1234
        """Assert that a callable raises a particular exception.
1481
1242
        """
1482
1243
        try:
1483
1244
            callableObj(*args, **kwargs)
1484
 
        except excClass as e:
 
1245
        except excClass, e:
1485
1246
            return e
1486
1247
        else:
1487
 
            if getattr(excClass, '__name__', None) is not None:
 
1248
            if getattr(excClass,'__name__', None) is not None:
1488
1249
                excName = excClass.__name__
1489
1250
            else:
1490
1251
                # probably a tuple
1491
1252
                excName = str(excClass)
1492
 
            raise self.failureException("%s not raised" % excName)
 
1253
            raise self.failureException, "%s not raised" % excName
1493
1254
 
1494
1255
    def assertIs(self, left, right, message=None):
1495
1256
        if not (left is right):
1526
1287
 
1527
1288
    def assertIsInstance(self, obj, kls, msg=None):
1528
1289
        """Fail if obj is not an instance of kls
1529
 
 
 
1290
        
1530
1291
        :param msg: Supplementary message to show if the assertion fails.
1531
1292
        """
1532
1293
        if not isinstance(obj, kls):
1538
1299
 
1539
1300
    def assertFileEqual(self, content, path):
1540
1301
        """Fail if path does not contain 'content'."""
1541
 
        self.assertPathExists(path)
1542
 
 
1543
 
        mode = 'r' + ('b' if isinstance(content, bytes) else '')
1544
 
        with open(path, mode) as f:
 
1302
        self.failUnlessExists(path)
 
1303
        f = file(path, 'rb')
 
1304
        try:
1545
1305
            s = f.read()
 
1306
        finally:
 
1307
            f.close()
1546
1308
        self.assertEqualDiff(content, s)
1547
1309
 
1548
 
    def assertDocstring(self, expected_docstring, obj):
1549
 
        """Fail if obj does not have expected_docstring"""
1550
 
        if __doc__ is None:
1551
 
            # With -OO the docstring should be None instead
1552
 
            self.assertIs(obj.__doc__, None)
1553
 
        else:
1554
 
            self.assertEqual(expected_docstring, obj.__doc__)
1555
 
 
1556
 
    def assertPathExists(self, path):
 
1310
    def failUnlessExists(self, path):
1557
1311
        """Fail unless path or paths, which may be abs or relative, exist."""
1558
 
        # TODO(jelmer): Clean this up for pad.lv/1696545
1559
 
        if not isinstance(path, (bytes, str, text_type)):
 
1312
        if not isinstance(path, basestring):
1560
1313
            for p in path:
1561
 
                self.assertPathExists(p)
 
1314
                self.failUnlessExists(p)
1562
1315
        else:
1563
 
            self.assertTrue(osutils.lexists(path),
1564
 
                            path + " does not exist")
 
1316
            self.failUnless(osutils.lexists(path),path+" does not exist")
1565
1317
 
1566
 
    def assertPathDoesNotExist(self, path):
 
1318
    def failIfExists(self, path):
1567
1319
        """Fail if path or paths, which may be abs or relative, exist."""
1568
 
        if not isinstance(path, (str, text_type)):
 
1320
        if not isinstance(path, basestring):
1569
1321
            for p in path:
1570
 
                self.assertPathDoesNotExist(p)
 
1322
                self.failIfExists(p)
1571
1323
        else:
1572
 
            self.assertFalse(osutils.lexists(path),
1573
 
                             path + " exists")
 
1324
            self.failIf(osutils.lexists(path),path+" exists")
1574
1325
 
1575
1326
    def _capture_deprecation_warnings(self, a_callable, *args, **kwargs):
1576
1327
        """A helper for callDeprecated and applyDeprecated.
1582
1333
            a_callable(``*args``, ``**kwargs``).
1583
1334
        """
1584
1335
        local_warnings = []
1585
 
 
1586
1336
        def capture_warnings(msg, cls=None, stacklevel=None):
1587
1337
            # we've hooked into a deprecation specific callpath,
1588
1338
            # only deprecations should getting sent via it.
1603
1353
        not other callers that go direct to the warning module.
1604
1354
 
1605
1355
        To test that a deprecated method raises an error, do something like
1606
 
        this (remember that both assertRaises and applyDeprecated delays *args
1607
 
        and **kwargs passing)::
 
1356
        this::
1608
1357
 
1609
1358
            self.assertRaises(errors.ReservedId,
1610
1359
                self.applyDeprecated,
1624
1373
        :param kwargs: The keyword arguments for the callable
1625
1374
        :return: The result of a_callable(``*args``, ``**kwargs``)
1626
1375
        """
1627
 
        call_warnings, result = self._capture_deprecation_warnings(
1628
 
            a_callable, *args, **kwargs)
 
1376
        call_warnings, result = self._capture_deprecation_warnings(a_callable,
 
1377
            *args, **kwargs)
1629
1378
        expected_first_warning = symbol_versioning.deprecation_string(
1630
1379
            a_callable, deprecation_format)
1631
1380
        if len(call_warnings) == 0:
1632
1381
            self.fail("No deprecation warning generated by call to %s" %
1633
 
                      a_callable)
 
1382
                a_callable)
1634
1383
        self.assertEqual(expected_first_warning, call_warnings[0])
1635
1384
        return result
1636
1385
 
1650
1399
        # warnings.  It's the easiest way to insulate ourselves from -Werror,
1651
1400
        # though.  -- Andrew, 20071062
1652
1401
        wlist = []
1653
 
 
1654
1402
        def _catcher(message, category, filename, lineno, file=None, line=None):
1655
1403
            # despite the name, 'message' is normally(?) a Warning subclass
1656
1404
            # instance
1683
1431
        :param args: The positional arguments for the callable
1684
1432
        :param kwargs: The keyword arguments for the callable
1685
1433
        """
1686
 
        call_warnings, result = self._capture_deprecation_warnings(
1687
 
            callable, *args, **kwargs)
 
1434
        call_warnings, result = self._capture_deprecation_warnings(callable,
 
1435
            *args, **kwargs)
1688
1436
        self.assertEqual(expected, call_warnings)
1689
1437
        return result
1690
1438
 
1691
1439
    def _startLogFile(self):
1692
 
        """Setup a in-memory target for bzr and testcase log messages"""
1693
 
        pseudo_log_file = BytesIO()
 
1440
        """Send bzr and test log messages to a temporary file.
1694
1441
 
1695
 
        def _get_log_contents_for_weird_testtools_api():
1696
 
            return [pseudo_log_file.getvalue().decode(
1697
 
                "utf-8", "replace").encode("utf-8")]
1698
 
        self.addDetail(
1699
 
            "log", content.Content(
1700
 
                content.ContentType("text", "plain", {"charset": "utf8"}),
1701
 
                _get_log_contents_for_weird_testtools_api))
1702
 
        self._log_file = pseudo_log_file
1703
 
        self._log_memento = trace.push_log_file(self._log_file)
 
1442
        The file is removed as the test is torn down.
 
1443
        """
 
1444
        fileno, name = tempfile.mkstemp(suffix='.log', prefix='testbzr')
 
1445
        self._log_file = os.fdopen(fileno, 'w+')
 
1446
        self._log_memento = bzrlib.trace.push_log_file(self._log_file)
 
1447
        self._log_file_name = name
1704
1448
        self.addCleanup(self._finishLogFile)
1705
1449
 
1706
1450
    def _finishLogFile(self):
1707
 
        """Flush and dereference the in-memory log for this testcase"""
1708
 
        if trace._trace_file:
 
1451
        """Finished with the log file.
 
1452
 
 
1453
        Close the file and delete it, unless setKeepLogfile was called.
 
1454
        """
 
1455
        if bzrlib.trace._trace_file:
1709
1456
            # flush the log file, to get all content
1710
 
            trace._trace_file.flush()
1711
 
        trace.pop_log_file(self._log_memento)
1712
 
        # The logging module now tracks references for cleanup so discard ours
1713
 
        del self._log_memento
 
1457
            bzrlib.trace._trace_file.flush()
 
1458
        bzrlib.trace.pop_log_file(self._log_memento)
 
1459
        # Cache the log result and delete the file on disk
 
1460
        self._get_log(False)
1714
1461
 
1715
1462
    def thisFailsStrictLockCheck(self):
1716
1463
        """It is known that this test would fail with -Dstrict_locks.
1725
1472
        """
1726
1473
        debug.debug_flags.discard('strict_locks')
1727
1474
 
 
1475
    def addCleanup(self, callable, *args, **kwargs):
 
1476
        """Arrange to run a callable when this case is torn down.
 
1477
 
 
1478
        Callables are run in the reverse of the order they are registered,
 
1479
        ie last-in first-out.
 
1480
        """
 
1481
        self._cleanups.append((callable, args, kwargs))
 
1482
 
1728
1483
    def overrideAttr(self, obj, attr_name, new=_unitialized_attr):
1729
1484
        """Overrides an object attribute restoring it after the test.
1730
1485
 
1731
 
        :note: This should be used with discretion; you should think about
1732
 
        whether it's better to make the code testable without monkey-patching.
1733
 
 
1734
1486
        :param obj: The object that will be mutated.
1735
1487
 
1736
1488
        :param attr_name: The attribute name we want to preserve/override in
1740
1492
 
1741
1493
        :returns: The actual attr value.
1742
1494
        """
 
1495
        value = getattr(obj, attr_name)
1743
1496
        # The actual value is captured by the call below
1744
 
        value = getattr(obj, attr_name, _unitialized_attr)
1745
 
        if value is _unitialized_attr:
1746
 
            # When the test completes, the attribute should not exist, but if
1747
 
            # we aren't setting a value, we don't need to do anything.
1748
 
            if new is not _unitialized_attr:
1749
 
                self.addCleanup(delattr, obj, attr_name)
1750
 
        else:
1751
 
            self.addCleanup(setattr, obj, attr_name, value)
 
1497
        self.addCleanup(setattr, obj, attr_name, value)
1752
1498
        if new is not _unitialized_attr:
1753
1499
            setattr(obj, attr_name, new)
1754
1500
        return value
1755
1501
 
1756
 
    def overrideEnv(self, name, new):
1757
 
        """Set an environment variable, and reset it after the test.
1758
 
 
1759
 
        :param name: The environment variable name.
1760
 
 
1761
 
        :param new: The value to set the variable to. If None, the
1762
 
            variable is deleted from the environment.
1763
 
 
1764
 
        :returns: The actual variable value.
1765
 
        """
1766
 
        value = osutils.set_or_unset_env(name, new)
1767
 
        self.addCleanup(osutils.set_or_unset_env, name, value)
1768
 
        return value
1769
 
 
1770
 
    def recordCalls(self, obj, attr_name):
1771
 
        """Monkeypatch in a wrapper that will record calls.
1772
 
 
1773
 
        The monkeypatch is automatically removed when the test concludes.
1774
 
 
1775
 
        :param obj: The namespace holding the reference to be replaced;
1776
 
            typically a module, class, or object.
1777
 
        :param attr_name: A string for the name of the attribute to patch.
1778
 
        :returns: A list that will be extended with one item every time the
1779
 
            function is called, with a tuple of (args, kwargs).
1780
 
        """
1781
 
        calls = []
1782
 
 
1783
 
        def decorator(*args, **kwargs):
1784
 
            calls.append((args, kwargs))
1785
 
            return orig(*args, **kwargs)
1786
 
        orig = self.overrideAttr(obj, attr_name, decorator)
1787
 
        return calls
1788
 
 
1789
1502
    def _cleanEnvironment(self):
1790
 
        for name, value in isolated_environ.items():
1791
 
            self.overrideEnv(name, value)
 
1503
        new_env = {
 
1504
            'BZR_HOME': None, # Don't inherit BZR_HOME to all the tests.
 
1505
            'HOME': os.getcwd(),
 
1506
            # bzr now uses the Win32 API and doesn't rely on APPDATA, but the
 
1507
            # tests do check our impls match APPDATA
 
1508
            'BZR_EDITOR': None, # test_msgeditor manipulates this variable
 
1509
            'VISUAL': None,
 
1510
            'EDITOR': None,
 
1511
            'BZR_EMAIL': None,
 
1512
            'BZREMAIL': None, # may still be present in the environment
 
1513
            'EMAIL': None,
 
1514
            'BZR_PROGRESS_BAR': None,
 
1515
            'BZR_LOG': None,
 
1516
            'BZR_PLUGIN_PATH': None,
 
1517
            'BZR_CONCURRENCY': None,
 
1518
            # Make sure that any text ui tests are consistent regardless of
 
1519
            # the environment the test case is run in; you may want tests that
 
1520
            # test other combinations.  'dumb' is a reasonable guess for tests
 
1521
            # going to a pipe or a StringIO.
 
1522
            'TERM': 'dumb',
 
1523
            'LINES': '25',
 
1524
            'COLUMNS': '80',
 
1525
            'BZR_COLUMNS': '80',
 
1526
            # SSH Agent
 
1527
            'SSH_AUTH_SOCK': None,
 
1528
            # Proxies
 
1529
            'http_proxy': None,
 
1530
            'HTTP_PROXY': None,
 
1531
            'https_proxy': None,
 
1532
            'HTTPS_PROXY': None,
 
1533
            'no_proxy': None,
 
1534
            'NO_PROXY': None,
 
1535
            'all_proxy': None,
 
1536
            'ALL_PROXY': None,
 
1537
            # Nobody cares about ftp_proxy, FTP_PROXY AFAIK. So far at
 
1538
            # least. If you do (care), please update this comment
 
1539
            # -- vila 20080401
 
1540
            'ftp_proxy': None,
 
1541
            'FTP_PROXY': None,
 
1542
            'BZR_REMOTE_PATH': None,
 
1543
            # Generally speaking, we don't want apport reporting on crashes in
 
1544
            # the test envirnoment unless we're specifically testing apport,
 
1545
            # so that it doesn't leak into the real system environment.  We
 
1546
            # use an env var so it propagates to subprocesses.
 
1547
            'APPORT_DISABLE': '1',
 
1548
        }
 
1549
        self._old_env = {}
 
1550
        self.addCleanup(self._restoreEnvironment)
 
1551
        for name, value in new_env.iteritems():
 
1552
            self._captureVar(name, value)
 
1553
 
 
1554
    def _captureVar(self, name, newvalue):
 
1555
        """Set an environment variable, and reset it when finished."""
 
1556
        self._old_env[name] = osutils.set_or_unset_env(name, newvalue)
 
1557
 
 
1558
    def _restoreEnvironment(self):
 
1559
        for name, value in self._old_env.iteritems():
 
1560
            osutils.set_or_unset_env(name, value)
1792
1561
 
1793
1562
    def _restoreHooks(self):
1794
1563
        for klass, (name, hooks) in self._preserved_hooks.items():
1795
1564
            setattr(klass, name, hooks)
1796
 
        self._preserved_hooks.clear()
1797
 
        breezy.hooks._lazy_hooks = self._preserved_lazy_hooks
1798
 
        self._preserved_lazy_hooks.clear()
1799
1565
 
1800
1566
    def knownFailure(self, reason):
1801
 
        """Declare that this test fails for a known reason
1802
 
 
1803
 
        Tests that are known to fail should generally be using expectedFailure
1804
 
        with an appropriate reverse assertion if a change could cause the test
1805
 
        to start passing. Conversely if the test has no immediate prospect of
1806
 
        succeeding then using skip is more suitable.
1807
 
 
1808
 
        When this method is called while an exception is being handled, that
1809
 
        traceback will be used, otherwise a new exception will be thrown to
1810
 
        provide one but won't be reported.
1811
 
        """
1812
 
        self._add_reason(reason)
1813
 
        try:
1814
 
            exc_info = sys.exc_info()
1815
 
            if exc_info != (None, None, None):
1816
 
                self._report_traceback(exc_info)
1817
 
            else:
1818
 
                try:
1819
 
                    raise self.failureException(reason)
1820
 
                except self.failureException:
1821
 
                    exc_info = sys.exc_info()
1822
 
            # GZ 02-08-2011: Maybe cleanup this err.exc_info attribute too?
1823
 
            raise testtools.testcase._ExpectedFailure(exc_info)
1824
 
        finally:
1825
 
            del exc_info
1826
 
 
1827
 
    def _suppress_log(self):
1828
 
        """Remove the log info from details."""
1829
 
        self.discardDetail('log')
 
1567
        """This test has failed for some known reason."""
 
1568
        raise KnownFailure(reason)
1830
1569
 
1831
1570
    def _do_skip(self, result, reason):
1832
 
        self._suppress_log()
1833
1571
        addSkip = getattr(result, 'addSkip', None)
1834
1572
        if not callable(addSkip):
1835
1573
            result.addSuccess(result)
1836
1574
        else:
1837
 
            addSkip(self, str(reason))
 
1575
            addSkip(self, reason)
1838
1576
 
1839
1577
    @staticmethod
1840
1578
    def _do_known_failure(self, result, e):
1841
 
        self._suppress_log()
1842
1579
        err = sys.exc_info()
1843
1580
        addExpectedFailure = getattr(result, 'addExpectedFailure', None)
1844
1581
        if addExpectedFailure is not None:
1852
1589
            reason = 'No reason given'
1853
1590
        else:
1854
1591
            reason = e.args[0]
1855
 
        self._suppress_log()
1856
1592
        addNotApplicable = getattr(result, 'addNotApplicable', None)
1857
1593
        if addNotApplicable is not None:
1858
1594
            result.addNotApplicable(self, reason)
1860
1596
            self._do_skip(result, reason)
1861
1597
 
1862
1598
    @staticmethod
1863
 
    def _report_skip(self, result, err):
1864
 
        """Override the default _report_skip.
1865
 
 
1866
 
        We want to strip the 'log' detail. If we waint until _do_skip, it has
1867
 
        already been formatted into the 'reason' string, and we can't pull it
1868
 
        out again.
1869
 
        """
1870
 
        self._suppress_log()
1871
 
        super(TestCase, self)._report_skip(self, result, err)
1872
 
 
1873
 
    @staticmethod
1874
 
    def _report_expected_failure(self, result, err):
1875
 
        """Strip the log.
1876
 
 
1877
 
        See _report_skip for motivation.
1878
 
        """
1879
 
        self._suppress_log()
1880
 
        super(TestCase, self)._report_expected_failure(self, result, err)
1881
 
 
1882
 
    @staticmethod
1883
1599
    def _do_unsupported_or_skip(self, result, e):
1884
1600
        reason = e.args[0]
1885
 
        self._suppress_log()
1886
1601
        addNotSupported = getattr(result, 'addNotSupported', None)
1887
1602
        if addNotSupported is not None:
1888
1603
            result.addNotSupported(self, reason)
1892
1607
    def time(self, callable, *args, **kwargs):
1893
1608
        """Run callable and accrue the time it takes to the benchmark time.
1894
1609
 
1895
 
        If lsprofiling is enabled (i.e. by --lsprof-time to brz selftest) then
 
1610
        If lsprofiling is enabled (i.e. by --lsprof-time to bzr selftest) then
1896
1611
        this will cause lsprofile statistics to be gathered and stored in
1897
1612
        self._benchcalls.
1898
1613
        """
1899
1614
        if self._benchtime is None:
1900
 
            self.addDetail('benchtime', content.Content(
1901
 
                content.UTF8_TEXT,
1902
 
                lambda: [str(self._benchtime).encode('utf-8')]))
 
1615
            self.addDetail('benchtime', content.Content(content.ContentType(
 
1616
                "text", "plain"), lambda:[str(self._benchtime)]))
1903
1617
            self._benchtime = 0
1904
1618
        start = time.time()
1905
1619
        try:
1907
1621
                return callable(*args, **kwargs)
1908
1622
            else:
1909
1623
                # record this benchmark
1910
 
                ret, stats = breezy.lsprof.profile(callable, *args, **kwargs)
 
1624
                ret, stats = bzrlib.lsprof.profile(callable, *args, **kwargs)
1911
1625
                stats.sort()
1912
1626
                self._benchcalls.append(((callable, args, kwargs), stats))
1913
1627
                return ret
1915
1629
            self._benchtime += time.time() - start
1916
1630
 
1917
1631
    def log(self, *args):
1918
 
        trace.mutter(*args)
 
1632
        mutter(*args)
 
1633
 
 
1634
    def _get_log(self, keep_log_file=False):
 
1635
        """Internal helper to get the log from bzrlib.trace for this test.
 
1636
 
 
1637
        Please use self.getDetails, or self.get_log to access this in test case
 
1638
        code.
 
1639
 
 
1640
        :param keep_log_file: When True, if the log is still a file on disk
 
1641
            leave it as a file on disk. When False, if the log is still a file
 
1642
            on disk, the log file is deleted and the log preserved as
 
1643
            self._log_contents.
 
1644
        :return: A string containing the log.
 
1645
        """
 
1646
        if self._log_contents is not None:
 
1647
            try:
 
1648
                self._log_contents.decode('utf8')
 
1649
            except UnicodeDecodeError:
 
1650
                unicodestr = self._log_contents.decode('utf8', 'replace')
 
1651
                self._log_contents = unicodestr.encode('utf8')
 
1652
            return self._log_contents
 
1653
        import bzrlib.trace
 
1654
        if bzrlib.trace._trace_file:
 
1655
            # flush the log file, to get all content
 
1656
            bzrlib.trace._trace_file.flush()
 
1657
        if self._log_file_name is not None:
 
1658
            logfile = open(self._log_file_name)
 
1659
            try:
 
1660
                log_contents = logfile.read()
 
1661
            finally:
 
1662
                logfile.close()
 
1663
            try:
 
1664
                log_contents.decode('utf8')
 
1665
            except UnicodeDecodeError:
 
1666
                unicodestr = log_contents.decode('utf8', 'replace')
 
1667
                log_contents = unicodestr.encode('utf8')
 
1668
            if not keep_log_file:
 
1669
                self._log_file.close()
 
1670
                self._log_file = None
 
1671
                # Permit multiple calls to get_log until we clean it up in
 
1672
                # finishLogFile
 
1673
                self._log_contents = log_contents
 
1674
                try:
 
1675
                    os.remove(self._log_file_name)
 
1676
                except OSError, e:
 
1677
                    if sys.platform == 'win32' and e.errno == errno.EACCES:
 
1678
                        sys.stderr.write(('Unable to delete log file '
 
1679
                                             ' %r\n' % self._log_file_name))
 
1680
                    else:
 
1681
                        raise
 
1682
                self._log_file_name = None
 
1683
            return log_contents
 
1684
        else:
 
1685
            return "No log file content and no log file name."
1919
1686
 
1920
1687
    def get_log(self):
1921
 
        """Get a unicode string containing the log from breezy.trace.
 
1688
        """Get a unicode string containing the log from bzrlib.trace.
1922
1689
 
1923
1690
        Undecodable characters are replaced.
1924
1691
        """
1932
1699
        if not feature.available():
1933
1700
            raise UnavailableFeature(feature)
1934
1701
 
1935
 
    def _run_bzr_core(self, args, encoding, stdin, stdout, stderr,
1936
 
                      working_dir):
 
1702
    def _run_bzr_autosplit(self, args, retcode, encoding, stdin,
 
1703
            working_dir):
 
1704
        """Run bazaar command line, splitting up a string command line."""
 
1705
        if isinstance(args, basestring):
 
1706
            # shlex don't understand unicode strings,
 
1707
            # so args should be plain string (bialix 20070906)
 
1708
            args = list(shlex.split(str(args)))
 
1709
        return self._run_bzr_core(args, retcode=retcode,
 
1710
                encoding=encoding, stdin=stdin, working_dir=working_dir,
 
1711
                )
 
1712
 
 
1713
    def _run_bzr_core(self, args, retcode, encoding, stdin,
 
1714
            working_dir):
1937
1715
        # Clear chk_map page cache, because the contents are likely to mask
1938
1716
        # locking errors.
1939
1717
        chk_map.clear_cache()
1940
 
 
1941
 
        self.log('run brz: %r', args)
1942
 
 
1943
 
        if PY3:
1944
 
            self._last_cmd_stdout = stdout
1945
 
            self._last_cmd_stderr = stderr
1946
 
        else:
1947
 
            self._last_cmd_stdout = codecs.getwriter(encoding)(stdout)
1948
 
            self._last_cmd_stderr = codecs.getwriter(encoding)(stderr)
1949
 
 
 
1718
        if encoding is None:
 
1719
            encoding = osutils.get_user_encoding()
 
1720
        stdout = StringIOWrapper()
 
1721
        stderr = StringIOWrapper()
 
1722
        stdout.encoding = encoding
 
1723
        stderr.encoding = encoding
 
1724
 
 
1725
        self.log('run bzr: %r', args)
 
1726
        # FIXME: don't call into logging here
 
1727
        handler = logging.StreamHandler(stderr)
 
1728
        handler.setLevel(logging.INFO)
 
1729
        logger = logging.getLogger('')
 
1730
        logger.addHandler(handler)
1950
1731
        old_ui_factory = ui.ui_factory
1951
 
        ui.ui_factory = ui_testing.TestUIFactory(
1952
 
            stdin=stdin,
1953
 
            stdout=self._last_cmd_stdout,
1954
 
            stderr=self._last_cmd_stderr)
 
1732
        ui.ui_factory = TestUIFactory(stdin=stdin, stdout=stdout, stderr=stderr)
1955
1733
 
1956
1734
        cwd = None
1957
1735
        if working_dir is not None:
1959
1737
            os.chdir(working_dir)
1960
1738
 
1961
1739
        try:
1962
 
            with ui.ui_factory:
1963
 
                result = self.apply_redirected(
1964
 
                    ui.ui_factory.stdin,
 
1740
            try:
 
1741
                result = self.apply_redirected(ui.ui_factory.stdin,
1965
1742
                    stdout, stderr,
1966
 
                    _mod_commands.run_bzr_catch_user_errors,
 
1743
                    bzrlib.commands.run_bzr_catch_user_errors,
1967
1744
                    args)
 
1745
            except KeyboardInterrupt:
 
1746
                # Reraise KeyboardInterrupt with contents of redirected stdout
 
1747
                # and stderr as arguments, for tests which are interested in
 
1748
                # stdout and stderr and are expecting the exception.
 
1749
                out = stdout.getvalue()
 
1750
                err = stderr.getvalue()
 
1751
                if out:
 
1752
                    self.log('output:\n%r', out)
 
1753
                if err:
 
1754
                    self.log('errors:\n%r', err)
 
1755
                raise KeyboardInterrupt(out, err)
1968
1756
        finally:
 
1757
            logger.removeHandler(handler)
1969
1758
            ui.ui_factory = old_ui_factory
1970
1759
            if cwd is not None:
1971
1760
                os.chdir(cwd)
1972
1761
 
1973
 
        return result
1974
 
 
1975
 
    def run_bzr_raw(self, args, retcode=0, stdin=None, encoding=None,
1976
 
                    working_dir=None, error_regexes=[]):
1977
 
        """Invoke brz, as if it were run from the command line.
1978
 
 
1979
 
        The argument list should not include the brz program name - the
1980
 
        first argument is normally the brz command.  Arguments may be
1981
 
        passed in three ways:
1982
 
 
1983
 
        1- A list of strings, eg ["commit", "a"].  This is recommended
1984
 
        when the command contains whitespace or metacharacters, or
1985
 
        is built up at run time.
1986
 
 
1987
 
        2- A single string, eg "add a".  This is the most convenient
1988
 
        for hardcoded commands.
1989
 
 
1990
 
        This runs brz through the interface that catches and reports
1991
 
        errors, and with logging set to something approximating the
1992
 
        default, so that error reporting can be checked.
1993
 
 
1994
 
        This should be the main method for tests that want to exercise the
1995
 
        overall behavior of the brz application (rather than a unit test
1996
 
        or a functional test of the library.)
1997
 
 
1998
 
        This sends the stdout/stderr results into the test's log,
1999
 
        where it may be useful for debugging.  See also run_captured.
2000
 
 
2001
 
        :keyword stdin: A string to be used as stdin for the command.
2002
 
        :keyword retcode: The status code the command should return;
2003
 
            default 0.
2004
 
        :keyword working_dir: The directory to run the command in
2005
 
        :keyword error_regexes: A list of expected error messages.  If
2006
 
            specified they must be seen in the error output of the command.
2007
 
        """
2008
 
        if isinstance(args, string_types):
2009
 
            args = shlex.split(args)
2010
 
 
2011
 
        if encoding is None:
2012
 
            encoding = osutils.get_user_encoding()
2013
 
 
2014
 
        if sys.version_info[0] == 2:
2015
 
            wrapped_stdout = stdout = ui_testing.BytesIOWithEncoding()
2016
 
            wrapped_stderr = stderr = ui_testing.BytesIOWithEncoding()
2017
 
            stdout.encoding = stderr.encoding = encoding
2018
 
 
2019
 
            # FIXME: don't call into logging here
2020
 
            handler = trace.EncodedStreamHandler(
2021
 
                stderr, errors="replace")
2022
 
        else:
2023
 
            stdout = BytesIO()
2024
 
            stderr = BytesIO()
2025
 
            wrapped_stdout = TextIOWrapper(stdout, encoding)
2026
 
            wrapped_stderr = TextIOWrapper(stderr, encoding)
2027
 
            handler = logging.StreamHandler(wrapped_stderr)
2028
 
        handler.setLevel(logging.INFO)
2029
 
 
2030
 
        logger = logging.getLogger('')
2031
 
        logger.addHandler(handler)
2032
 
        try:
2033
 
            result = self._run_bzr_core(
2034
 
                args, encoding=encoding, stdin=stdin, stdout=wrapped_stdout,
2035
 
                stderr=wrapped_stderr, working_dir=working_dir,
2036
 
                )
2037
 
        finally:
2038
 
            logger.removeHandler(handler)
2039
 
 
2040
 
        if PY3:
2041
 
            wrapped_stdout.flush()
2042
 
            wrapped_stderr.flush()
2043
 
 
2044
 
        out = stdout.getvalue()
2045
 
        err = stderr.getvalue()
2046
 
        if out:
2047
 
            self.log('output:\n%r', out)
2048
 
        if err:
2049
 
            self.log('errors:\n%r', err)
2050
 
        if retcode is not None:
2051
 
            self.assertEqual(retcode, result,
2052
 
                             message='Unexpected return code')
2053
 
        self.assertIsInstance(error_regexes, (list, tuple))
2054
 
        for regex in error_regexes:
2055
 
            self.assertContainsRe(err, regex)
2056
 
        return out, err
2057
 
 
2058
 
    def run_bzr(self, args, retcode=0, stdin=None, encoding=None,
2059
 
                working_dir=None, error_regexes=[]):
2060
 
        """Invoke brz, as if it were run from the command line.
2061
 
 
2062
 
        The argument list should not include the brz program name - the
2063
 
        first argument is normally the brz command.  Arguments may be
2064
 
        passed in three ways:
2065
 
 
2066
 
        1- A list of strings, eg ["commit", "a"].  This is recommended
2067
 
        when the command contains whitespace or metacharacters, or
2068
 
        is built up at run time.
2069
 
 
2070
 
        2- A single string, eg "add a".  This is the most convenient
2071
 
        for hardcoded commands.
2072
 
 
2073
 
        This runs brz through the interface that catches and reports
2074
 
        errors, and with logging set to something approximating the
2075
 
        default, so that error reporting can be checked.
2076
 
 
2077
 
        This should be the main method for tests that want to exercise the
2078
 
        overall behavior of the brz application (rather than a unit test
2079
 
        or a functional test of the library.)
2080
 
 
2081
 
        This sends the stdout/stderr results into the test's log,
2082
 
        where it may be useful for debugging.  See also run_captured.
2083
 
 
2084
 
        :keyword stdin: A string to be used as stdin for the command.
2085
 
        :keyword retcode: The status code the command should return;
2086
 
            default 0.
2087
 
        :keyword working_dir: The directory to run the command in
2088
 
        :keyword error_regexes: A list of expected error messages.  If
2089
 
            specified they must be seen in the error output of the command.
2090
 
        """
2091
 
        if isinstance(args, string_types):
2092
 
            args = shlex.split(args)
2093
 
 
2094
 
        if encoding is None:
2095
 
            encoding = osutils.get_user_encoding()
2096
 
 
2097
 
        if sys.version_info[0] == 2:
2098
 
            stdout = ui_testing.BytesIOWithEncoding()
2099
 
            stderr = ui_testing.BytesIOWithEncoding()
2100
 
            stdout.encoding = stderr.encoding = encoding
2101
 
            # FIXME: don't call into logging here
2102
 
            handler = trace.EncodedStreamHandler(
2103
 
                stderr, errors="replace")
2104
 
        else:
2105
 
            stdout = ui_testing.StringIOWithEncoding()
2106
 
            stderr = ui_testing.StringIOWithEncoding()
2107
 
            stdout.encoding = stderr.encoding = encoding
2108
 
            handler = logging.StreamHandler(stream=stderr)
2109
 
        handler.setLevel(logging.INFO)
2110
 
 
2111
 
        logger = logging.getLogger('')
2112
 
        logger.addHandler(handler)
2113
 
 
2114
 
        try:
2115
 
            result = self._run_bzr_core(
2116
 
                args, encoding=encoding, stdin=stdin, stdout=stdout,
2117
 
                stderr=stderr, working_dir=working_dir)
2118
 
        finally:
2119
 
            logger.removeHandler(handler)
2120
 
 
2121
 
        out = stdout.getvalue()
2122
 
        err = stderr.getvalue()
2123
 
        if out:
2124
 
            self.log('output:\n%r', out)
2125
 
        if err:
2126
 
            self.log('errors:\n%r', err)
2127
 
        if retcode is not None:
2128
 
            self.assertEqual(retcode, result,
2129
 
                             message='Unexpected return code')
 
1762
        out = stdout.getvalue()
 
1763
        err = stderr.getvalue()
 
1764
        if out:
 
1765
            self.log('output:\n%r', out)
 
1766
        if err:
 
1767
            self.log('errors:\n%r', err)
 
1768
        if retcode is not None:
 
1769
            self.assertEquals(retcode, result,
 
1770
                              message='Unexpected return code')
 
1771
        return result, out, err
 
1772
 
 
1773
    def run_bzr(self, args, retcode=0, encoding=None, stdin=None,
 
1774
                working_dir=None, error_regexes=[], output_encoding=None):
 
1775
        """Invoke bzr, as if it were run from the command line.
 
1776
 
 
1777
        The argument list should not include the bzr program name - the
 
1778
        first argument is normally the bzr command.  Arguments may be
 
1779
        passed in three ways:
 
1780
 
 
1781
        1- A list of strings, eg ["commit", "a"].  This is recommended
 
1782
        when the command contains whitespace or metacharacters, or
 
1783
        is built up at run time.
 
1784
 
 
1785
        2- A single string, eg "add a".  This is the most convenient
 
1786
        for hardcoded commands.
 
1787
 
 
1788
        This runs bzr through the interface that catches and reports
 
1789
        errors, and with logging set to something approximating the
 
1790
        default, so that error reporting can be checked.
 
1791
 
 
1792
        This should be the main method for tests that want to exercise the
 
1793
        overall behavior of the bzr application (rather than a unit test
 
1794
        or a functional test of the library.)
 
1795
 
 
1796
        This sends the stdout/stderr results into the test's log,
 
1797
        where it may be useful for debugging.  See also run_captured.
 
1798
 
 
1799
        :keyword stdin: A string to be used as stdin for the command.
 
1800
        :keyword retcode: The status code the command should return;
 
1801
            default 0.
 
1802
        :keyword working_dir: The directory to run the command in
 
1803
        :keyword error_regexes: A list of expected error messages.  If
 
1804
            specified they must be seen in the error output of the command.
 
1805
        """
 
1806
        retcode, out, err = self._run_bzr_autosplit(
 
1807
            args=args,
 
1808
            retcode=retcode,
 
1809
            encoding=encoding,
 
1810
            stdin=stdin,
 
1811
            working_dir=working_dir,
 
1812
            )
2130
1813
        self.assertIsInstance(error_regexes, (list, tuple))
2131
1814
        for regex in error_regexes:
2132
1815
            self.assertContainsRe(err, regex)
2133
1816
        return out, err
2134
1817
 
2135
1818
    def run_bzr_error(self, error_regexes, *args, **kwargs):
2136
 
        """Run brz, and check that stderr contains the supplied regexes
 
1819
        """Run bzr, and check that stderr contains the supplied regexes
2137
1820
 
2138
1821
        :param error_regexes: Sequence of regular expressions which
2139
1822
            must each be found in the error output. The relative ordering
2140
1823
            is not enforced.
2141
 
        :param args: command-line arguments for brz
2142
 
        :param kwargs: Keyword arguments which are interpreted by run_brz
 
1824
        :param args: command-line arguments for bzr
 
1825
        :param kwargs: Keyword arguments which are interpreted by run_bzr
2143
1826
            This function changes the default value of retcode to be 3,
2144
 
            since in most cases this is run when you expect brz to fail.
 
1827
            since in most cases this is run when you expect bzr to fail.
2145
1828
 
2146
1829
        :return: (out, err) The actual output of running the command (in case
2147
1830
            you want to do more inspection)
2154
1837
            # Make sure --strict is handling an unknown file, rather than
2155
1838
            # giving us the 'nothing to do' error
2156
1839
            self.build_tree(['unknown'])
2157
 
            self.run_bzr_error(
2158
 
                ['Commit refused because there are unknown files'],
2159
 
                ['commit', --strict', '-m', 'my commit comment'])
 
1840
            self.run_bzr_error(['Commit refused because there are unknown files'],
 
1841
                               ['commit', --strict', '-m', 'my commit comment'])
2160
1842
        """
2161
1843
        kwargs.setdefault('retcode', 3)
2162
1844
        kwargs['error_regexes'] = error_regexes
2164
1846
        return out, err
2165
1847
 
2166
1848
    def run_bzr_subprocess(self, *args, **kwargs):
2167
 
        """Run brz in a subprocess for testing.
 
1849
        """Run bzr in a subprocess for testing.
2168
1850
 
2169
 
        This starts a new Python interpreter and runs brz in there.
 
1851
        This starts a new Python interpreter and runs bzr in there.
2170
1852
        This should only be used for tests that have a justifiable need for
2171
1853
        this isolation: e.g. they are testing startup time, or signal
2172
1854
        handling, or early startup code, etc.  Subprocess code can't be
2190
1872
        if len(args) == 1:
2191
1873
            if isinstance(args[0], list):
2192
1874
                args = args[0]
2193
 
            elif isinstance(args[0], (str, text_type)):
 
1875
            elif isinstance(args[0], basestring):
2194
1876
                args = list(shlex.split(args[0]))
2195
1877
        else:
2196
1878
            raise ValueError("passing varargs to run_bzr_subprocess")
2200
1882
        # We distinguish between retcode=None and retcode not passed.
2201
1883
        supplied_retcode = kwargs.get('retcode', 0)
2202
1884
        return self.finish_bzr_subprocess(process, retcode=supplied_retcode,
2203
 
                                          universal_newlines=kwargs.get(
2204
 
                                              'universal_newlines', False),
2205
 
                                          process_args=args)
 
1885
            universal_newlines=kwargs.get('universal_newlines', False),
 
1886
            process_args=args)
2206
1887
 
2207
1888
    def start_bzr_subprocess(self, process_args, env_changes=None,
2208
1889
                             skip_if_plan_to_signal=False,
2209
1890
                             working_dir=None,
2210
 
                             allow_plugins=False, stderr=subprocess.PIPE):
2211
 
        """Start brz in a subprocess for testing.
 
1891
                             allow_plugins=False):
 
1892
        """Start bzr in a subprocess for testing.
2212
1893
 
2213
 
        This starts a new Python interpreter and runs brz in there.
 
1894
        This starts a new Python interpreter and runs bzr in there.
2214
1895
        This should only be used for tests that have a justifiable need for
2215
1896
        this isolation: e.g. they are testing startup time, or signal
2216
1897
        handling, or early startup code, etc.  Subprocess code can't be
2217
1898
        profiled or debugged so easily.
2218
1899
 
2219
 
        :param process_args: a list of arguments to pass to the brz executable,
 
1900
        :param process_args: a list of arguments to pass to the bzr executable,
2220
1901
            for example ``['--version']``.
2221
1902
        :param env_changes: A dictionary which lists changes to environment
2222
1903
            variables. A value of None will unset the env variable.
2223
1904
            The values must be strings. The change will only occur in the
2224
1905
            child, so you don't need to fix the environment after running.
2225
 
        :param skip_if_plan_to_signal: raise TestSkipped when true and system
2226
 
            doesn't support signalling subprocesses.
2227
 
        :param allow_plugins: If False (default) pass --no-plugins to brz.
2228
 
        :param stderr: file to use for the subprocess's stderr.  Valid values
2229
 
            are those valid for the stderr argument of `subprocess.Popen`.
2230
 
            Default value is ``subprocess.PIPE``.
 
1906
        :param skip_if_plan_to_signal: raise TestSkipped when true and os.kill
 
1907
            is not available.
 
1908
        :param allow_plugins: If False (default) pass --no-plugins to bzr.
2231
1909
 
2232
1910
        :returns: Popen object for the started process.
2233
1911
        """
2234
1912
        if skip_if_plan_to_signal:
2235
 
            if os.name != "posix":
2236
 
                raise TestSkipped("Sending signals not supported")
 
1913
            if not getattr(os, 'kill', None):
 
1914
                raise TestSkipped("os.kill not available.")
2237
1915
 
2238
1916
        if env_changes is None:
2239
1917
            env_changes = {}
2240
 
        # Because $HOME is set to a tempdir for the context of a test, modules
2241
 
        # installed in the user dir will not be found unless $PYTHONUSERBASE
2242
 
        # gets set to the computed directory of this parent process.
2243
 
        if site.USER_BASE is not None:
2244
 
            env_changes["PYTHONUSERBASE"] = site.USER_BASE
2245
1918
        old_env = {}
2246
1919
 
2247
1920
        def cleanup_environment():
2248
 
            for env_var, value in env_changes.items():
 
1921
            for env_var, value in env_changes.iteritems():
2249
1922
                old_env[env_var] = osutils.set_or_unset_env(env_var, value)
2250
1923
 
2251
1924
        def restore_environment():
2252
 
            for env_var, value in old_env.items():
 
1925
            for env_var, value in old_env.iteritems():
2253
1926
                osutils.set_or_unset_env(env_var, value)
2254
1927
 
2255
 
        bzr_path = self.get_brz_path()
 
1928
        bzr_path = self.get_bzr_path()
2256
1929
 
2257
1930
        cwd = None
2258
1931
        if working_dir is not None:
2264
1937
            # so we will avoid using it on all platforms, just to
2265
1938
            # make sure the code path is used, and we don't break on win32
2266
1939
            cleanup_environment()
2267
 
            # Include the subprocess's log file in the test details, in case
2268
 
            # the test fails due to an error in the subprocess.
2269
 
            self._add_subprocess_log(trace._get_brz_log_filename())
2270
1940
            command = [sys.executable]
2271
1941
            # frozen executables don't need the path to bzr
2272
1942
            if getattr(sys, "frozen", None) is None:
2274
1944
            if not allow_plugins:
2275
1945
                command.append('--no-plugins')
2276
1946
            command.extend(process_args)
2277
 
            process = self._popen(command, stdin=subprocess.PIPE,
2278
 
                                  stdout=subprocess.PIPE,
2279
 
                                  stderr=stderr, bufsize=0)
 
1947
            process = self._popen(command, stdin=PIPE, stdout=PIPE, stderr=PIPE)
2280
1948
        finally:
2281
1949
            restore_environment()
2282
1950
            if cwd is not None:
2284
1952
 
2285
1953
        return process
2286
1954
 
2287
 
    def _add_subprocess_log(self, log_file_path):
2288
 
        if len(self._log_files) == 0:
2289
 
            # Register an addCleanup func.  We do this on the first call to
2290
 
            # _add_subprocess_log rather than in TestCase.setUp so that this
2291
 
            # addCleanup is registered after any cleanups for tempdirs that
2292
 
            # subclasses might create, which will probably remove the log file
2293
 
            # we want to read.
2294
 
            self.addCleanup(self._subprocess_log_cleanup)
2295
 
        # self._log_files is a set, so if a log file is reused we won't grab it
2296
 
        # twice.
2297
 
        self._log_files.add(log_file_path)
2298
 
 
2299
 
    def _subprocess_log_cleanup(self):
2300
 
        for count, log_file_path in enumerate(self._log_files):
2301
 
            # We use buffer_now=True to avoid holding the file open beyond
2302
 
            # the life of this function, which might interfere with e.g.
2303
 
            # cleaning tempdirs on Windows.
2304
 
            # XXX: Testtools 0.9.5 doesn't have the content_from_file helper
2305
 
            # detail_content = content.content_from_file(
2306
 
            #    log_file_path, buffer_now=True)
2307
 
            with open(log_file_path, 'rb') as log_file:
2308
 
                log_file_bytes = log_file.read()
2309
 
            detail_content = content.Content(
2310
 
                content.ContentType("text", "plain", {"charset": "utf8"}),
2311
 
                lambda: [log_file_bytes])
2312
 
            self.addDetail("start_bzr_subprocess-log-%d" % (count,),
2313
 
                           detail_content)
2314
 
 
2315
1955
    def _popen(self, *args, **kwargs):
2316
1956
        """Place a call to Popen.
2317
1957
 
2318
1958
        Allows tests to override this method to intercept the calls made to
2319
1959
        Popen for introspection.
2320
1960
        """
2321
 
        return subprocess.Popen(*args, **kwargs)
 
1961
        return Popen(*args, **kwargs)
2322
1962
 
2323
1963
    def get_source_path(self):
2324
 
        """Return the path of the directory containing breezy."""
2325
 
        return os.path.dirname(os.path.dirname(breezy.__file__))
 
1964
        """Return the path of the directory containing bzrlib."""
 
1965
        return os.path.dirname(os.path.dirname(bzrlib.__file__))
2326
1966
 
2327
 
    def get_brz_path(self):
2328
 
        """Return the path of the 'brz' executable for this test suite."""
2329
 
        brz_path = os.path.join(self.get_source_path(), "brz")
2330
 
        if not os.path.isfile(brz_path):
 
1967
    def get_bzr_path(self):
 
1968
        """Return the path of the 'bzr' executable for this test suite."""
 
1969
        bzr_path = self.get_source_path()+'/bzr'
 
1970
        if not os.path.isfile(bzr_path):
2331
1971
            # We are probably installed. Assume sys.argv is the right file
2332
 
            brz_path = sys.argv[0]
2333
 
        return brz_path
 
1972
            bzr_path = sys.argv[0]
 
1973
        return bzr_path
2334
1974
 
2335
1975
    def finish_bzr_subprocess(self, process, retcode=0, send_signal=None,
2336
1976
                              universal_newlines=False, process_args=None):
2348
1988
        out, err = process.communicate()
2349
1989
 
2350
1990
        if universal_newlines:
2351
 
            out = out.replace(b'\r\n', b'\n')
2352
 
            err = err.replace(b'\r\n', b'\n')
 
1991
            out = out.replace('\r\n', '\n')
 
1992
            err = err.replace('\r\n', '\n')
2353
1993
 
2354
1994
        if retcode is not None and retcode != process.returncode:
2355
1995
            if process_args is None:
2356
1996
                process_args = "(unknown args)"
2357
 
            trace.mutter('Output of brz %r:\n%s', process_args, out)
2358
 
            trace.mutter('Error for brz %r:\n%s', process_args, err)
2359
 
            self.fail('Command brz %r failed with retcode %d != %d'
 
1997
            mutter('Output of bzr %s:\n%s', process_args, out)
 
1998
            mutter('Error for bzr %s:\n%s', process_args, err)
 
1999
            self.fail('Command bzr %s failed with retcode %s != %s'
2360
2000
                      % (process_args, retcode, process.returncode))
2361
2001
        return [out, err]
2362
2002
 
2363
 
    def check_tree_shape(self, tree, shape):
2364
 
        """Compare a tree to a list of expected names.
 
2003
    def check_inventory_shape(self, inv, shape):
 
2004
        """Compare an inventory to a list of expected names.
2365
2005
 
2366
2006
        Fail if they are not precisely equal.
2367
2007
        """
2368
2008
        extras = []
2369
2009
        shape = list(shape)             # copy
2370
 
        for path, ie in tree.iter_entries_by_dir():
 
2010
        for path, ie in inv.entries():
2371
2011
            name = path.replace('\\', '/')
2372
2012
            if ie.kind == 'directory':
2373
2013
                name = name + '/'
2374
 
            if name == "/":
2375
 
                pass  # ignore root entry
2376
 
            elif name in shape:
 
2014
            if name in shape:
2377
2015
                shape.remove(name)
2378
2016
            else:
2379
2017
                extras.append(name)
2390
2028
        if not callable(a_callable):
2391
2029
            raise ValueError("a_callable must be callable.")
2392
2030
        if stdin is None:
2393
 
            stdin = BytesIO(b"")
 
2031
            stdin = StringIO("")
2394
2032
        if stdout is None:
2395
2033
            if getattr(self, "_log_file", None) is not None:
2396
2034
                stdout = self._log_file
2397
2035
            else:
2398
 
                if sys.version_info[0] == 2:
2399
 
                    stdout = BytesIO()
2400
 
                else:
2401
 
                    stdout = StringIO()
 
2036
                stdout = StringIO()
2402
2037
        if stderr is None:
2403
2038
            if getattr(self, "_log_file", None is not None):
2404
2039
                stderr = self._log_file
2405
2040
            else:
2406
 
                if sys.version_info[0] == 2:
2407
 
                    stderr = BytesIO()
2408
 
                else:
2409
 
                    stderr = StringIO()
 
2041
                stderr = StringIO()
2410
2042
        real_stdin = sys.stdin
2411
2043
        real_stdout = sys.stdout
2412
2044
        real_stderr = sys.stderr
2426
2058
 
2427
2059
        Tests that expect to provoke LockContention errors should call this.
2428
2060
        """
2429
 
        self.overrideAttr(lockdir, '_DEFAULT_TIMEOUT_SECONDS', 0)
 
2061
        self.overrideAttr(bzrlib.lockdir, '_DEFAULT_TIMEOUT_SECONDS', 0)
2430
2062
 
2431
2063
    def make_utf8_encoded_stringio(self, encoding_type=None):
2432
 
        """Return a wrapped BytesIO, that will encode text input to UTF-8."""
 
2064
        """Return a StringIOWrapper instance, that will encode Unicode
 
2065
        input to UTF-8.
 
2066
        """
2433
2067
        if encoding_type is None:
2434
2068
            encoding_type = 'strict'
2435
 
        bio = BytesIO()
 
2069
        sio = StringIO()
2436
2070
        output_encoding = 'utf-8'
2437
 
        sio = codecs.getwriter(output_encoding)(bio, errors=encoding_type)
 
2071
        sio = codecs.getwriter(output_encoding)(sio, errors=encoding_type)
2438
2072
        sio.encoding = output_encoding
2439
2073
        return sio
2440
2074
 
2441
2075
    def disable_verb(self, verb):
2442
2076
        """Disable a smart server verb for one test."""
2443
 
        from breezy.bzr.smart import request
 
2077
        from bzrlib.smart import request
2444
2078
        request_handlers = request.request_handlers
2445
2079
        orig_method = request_handlers.get(verb)
2446
 
        orig_info = request_handlers.get_info(verb)
2447
2080
        request_handlers.remove(verb)
2448
 
        self.addCleanup(request_handlers.register, verb, orig_method,
2449
 
                        info=orig_info)
2450
 
 
2451
 
    def __hash__(self):
2452
 
        return id(self)
 
2081
        self.addCleanup(request_handlers.register, verb, orig_method)
2453
2082
 
2454
2083
 
2455
2084
class CapturedCall(object):
2478
2107
class TestCaseWithMemoryTransport(TestCase):
2479
2108
    """Common test class for tests that do not need disk resources.
2480
2109
 
2481
 
    Tests that need disk resources should derive from TestCaseInTempDir
2482
 
    orTestCaseWithTransport.
2483
 
 
2484
 
    TestCaseWithMemoryTransport sets the TEST_ROOT variable for all brz tests.
2485
 
 
2486
 
    For TestCaseWithMemoryTransport the ``test_home_dir`` is set to the name of
 
2110
    Tests that need disk resources should derive from TestCaseWithTransport.
 
2111
 
 
2112
    TestCaseWithMemoryTransport sets the TEST_ROOT variable for all bzr tests.
 
2113
 
 
2114
    For TestCaseWithMemoryTransport the test_home_dir is set to the name of
2487
2115
    a directory which does not exist. This serves to help ensure test isolation
2488
 
    is preserved. ``test_dir`` is set to the TEST_ROOT, as is cwd, because they
2489
 
    must exist. However, TestCaseWithMemoryTransport does not offer local file
2490
 
    defaults for the transport in tests, nor does it obey the command line
 
2116
    is preserved. test_dir is set to the TEST_ROOT, as is cwd, because they
 
2117
    must exist. However, TestCaseWithMemoryTransport does not offer local
 
2118
    file defaults for the transport in tests, nor does it obey the command line
2491
2119
    override, so tests that accidentally write to the common directory should
2492
2120
    be rare.
2493
2121
 
2494
 
    :cvar TEST_ROOT: Directory containing all temporary directories, plus a
2495
 
        ``.bzr`` directory that stops us ascending higher into the filesystem.
 
2122
    :cvar TEST_ROOT: Directory containing all temporary directories, plus
 
2123
    a .bzr directory that stops us ascending higher into the filesystem.
2496
2124
    """
2497
2125
 
2498
2126
    TEST_ROOT = None
2508
2136
        self.transport_readonly_server = None
2509
2137
        self.__vfs_server = None
2510
2138
 
2511
 
    def setUp(self):
2512
 
        super(TestCaseWithMemoryTransport, self).setUp()
2513
 
 
2514
 
        def _add_disconnect_cleanup(transport):
2515
 
            """Schedule disconnection of given transport at test cleanup
2516
 
 
2517
 
            This needs to happen for all connected transports or leaks occur.
2518
 
 
2519
 
            Note reconnections may mean we call disconnect multiple times per
2520
 
            transport which is suboptimal but seems harmless.
2521
 
            """
2522
 
            self.addCleanup(transport.disconnect)
2523
 
 
2524
 
        _mod_transport.Transport.hooks.install_named_hook(
2525
 
            'post_connect', _add_disconnect_cleanup, None)
2526
 
 
2527
 
        self._make_test_root()
2528
 
        self.addCleanup(os.chdir, osutils.getcwd())
2529
 
        self.makeAndChdirToTestDir()
2530
 
        self.overrideEnvironmentForTesting()
2531
 
        self.__readonly_server = None
2532
 
        self.__server = None
2533
 
        self.reduceLockdirTimeout()
2534
 
        # Each test may use its own config files even if the local config files
2535
 
        # don't actually exist. They'll rightly fail if they try to create them
2536
 
        # though.
2537
 
        self.overrideAttr(config, '_shared_stores', {})
2538
 
 
2539
2139
    def get_transport(self, relpath=None):
2540
2140
        """Return a writeable transport.
2541
2141
 
2544
2144
 
2545
2145
        :param relpath: a path relative to the base url.
2546
2146
        """
2547
 
        t = _mod_transport.get_transport_from_url(self.get_url(relpath))
 
2147
        t = get_transport(self.get_url(relpath))
2548
2148
        self.assertFalse(t.is_readonly())
2549
2149
        return t
2550
2150
 
2556
2156
 
2557
2157
        :param relpath: a path relative to the base url.
2558
2158
        """
2559
 
        t = _mod_transport.get_transport_from_url(
2560
 
            self.get_readonly_url(relpath))
 
2159
        t = get_transport(self.get_readonly_url(relpath))
2561
2160
        self.assertTrue(t.is_readonly())
2562
2161
        return t
2563
2162
 
2576
2175
        if self.__readonly_server is None:
2577
2176
            if self.transport_readonly_server is None:
2578
2177
                # readonly decorator requested
2579
 
                self.__readonly_server = test_server.ReadonlyServer()
 
2178
                self.__readonly_server = ReadonlyServer()
2580
2179
            else:
2581
2180
                # explicit readonly transport.
2582
 
                self.__readonly_server = (
2583
 
                    self.create_transport_readonly_server())
 
2181
                self.__readonly_server = self.create_transport_readonly_server()
2584
2182
            self.start_server(self.__readonly_server,
2585
 
                              self.get_vfs_only_server())
 
2183
                self.get_vfs_only_server())
2586
2184
        return self.__readonly_server
2587
2185
 
2588
2186
    def get_readonly_url(self, relpath=None):
2606
2204
        is no means to override it.
2607
2205
        """
2608
2206
        if self.__vfs_server is None:
2609
 
            self.__vfs_server = memory.MemoryServer()
 
2207
            self.__vfs_server = MemoryServer()
2610
2208
            self.start_server(self.__vfs_server)
2611
2209
        return self.__vfs_server
2612
2210
 
2621
2219
        """
2622
2220
        if self.__server is None:
2623
2221
            if (self.transport_server is None or self.transport_server is
2624
 
                    self.vfs_transport_factory):
 
2222
                self.vfs_transport_factory):
2625
2223
                self.__server = self.get_vfs_only_server()
2626
2224
            else:
2627
2225
                # bring up a decorated means of access to the vfs only server.
2685
2283
        real branch.
2686
2284
        """
2687
2285
        root = TestCaseWithMemoryTransport.TEST_ROOT
2688
 
        try:
2689
 
            # Make sure we get a readable and accessible home for brz.log
2690
 
            # and/or config files, and not fallback to weird defaults (see
2691
 
            # http://pad.lv/825027).
2692
 
            self.assertIs(None, os.environ.get('BRZ_HOME', None))
2693
 
            os.environ['BRZ_HOME'] = root
2694
 
            wt = controldir.ControlDir.create_standalone_workingtree(root)
2695
 
            del os.environ['BRZ_HOME']
2696
 
        except Exception as e:
2697
 
            self.fail("Fail to initialize the safety net: %r\n" % (e,))
2698
 
        # Hack for speed: remember the raw bytes of the dirstate file so that
2699
 
        # we don't need to re-open the wt to check it hasn't changed.
2700
 
        TestCaseWithMemoryTransport._SAFETY_NET_PRISTINE_DIRSTATE = (
2701
 
            wt.control_transport.get_bytes('dirstate'))
 
2286
        bzrdir.BzrDir.create_standalone_workingtree(root)
2702
2287
 
2703
2288
    def _check_safety_net(self):
2704
2289
        """Check that the safety .bzr directory have not been touched.
2707
2292
        propagating. This method ensures than a test did not leaked.
2708
2293
        """
2709
2294
        root = TestCaseWithMemoryTransport.TEST_ROOT
2710
 
        t = _mod_transport.get_transport_from_path(root)
2711
 
        self.permit_url(t.base)
2712
 
        if (t.get_bytes('.bzr/checkout/dirstate') !=
2713
 
                TestCaseWithMemoryTransport._SAFETY_NET_PRISTINE_DIRSTATE):
 
2295
        self.permit_url(get_transport(root).base)
 
2296
        wt = workingtree.WorkingTree.open(root)
 
2297
        last_rev = wt.last_revision()
 
2298
        if last_rev != 'null:':
2714
2299
            # The current test have modified the /bzr directory, we need to
2715
2300
            # recreate a new one or all the followng tests will fail.
2716
2301
            # If you need to inspect its content uncomment the following line
2741
2326
        This must set self.test_home_dir and self.test_dir and chdir to
2742
2327
        self.test_dir.
2743
2328
 
2744
 
        For TestCaseWithMemoryTransport we chdir to the TEST_ROOT for this
2745
 
        test.
 
2329
        For TestCaseWithMemoryTransport we chdir to the TEST_ROOT for this test.
2746
2330
        """
2747
2331
        os.chdir(TestCaseWithMemoryTransport.TEST_ROOT)
2748
2332
        self.test_dir = TestCaseWithMemoryTransport.TEST_ROOT
2749
2333
        self.test_home_dir = self.test_dir + "/MemoryTransportMissingHomeDir"
2750
2334
        self.permit_dir(self.test_dir)
2751
2335
 
2752
 
    def make_branch(self, relpath, format=None, name=None):
 
2336
    def make_branch(self, relpath, format=None):
2753
2337
        """Create a branch on the transport at relpath."""
2754
2338
        repo = self.make_repository(relpath, format=format)
2755
 
        return repo.controldir.create_branch(append_revisions_only=False, name=name)
2756
 
 
2757
 
    def get_default_format(self):
2758
 
        return 'default'
2759
 
 
2760
 
    def resolve_format(self, format):
2761
 
        """Resolve an object to a ControlDir format object.
2762
 
 
2763
 
        The initial format object can either already be
2764
 
        a ControlDirFormat, None (for the default format),
2765
 
        or a string with the name of the control dir format.
2766
 
 
2767
 
        :param format: Object to resolve
2768
 
        :return A ControlDirFormat instance
2769
 
        """
2770
 
        if format is None:
2771
 
            format = self.get_default_format()
2772
 
        if isinstance(format, str):
2773
 
            format = controldir.format_registry.make_controldir(format)
2774
 
        return format
2775
 
 
2776
 
    def make_controldir(self, relpath, format=None):
 
2339
        return repo.bzrdir.create_branch()
 
2340
 
 
2341
    def make_bzrdir(self, relpath, format=None):
2777
2342
        try:
2778
2343
            # might be a relative or absolute path
2779
2344
            maybe_a_url = self.get_url(relpath)
2780
2345
            segments = maybe_a_url.rsplit('/', 1)
2781
 
            t = _mod_transport.get_transport(maybe_a_url)
 
2346
            t = get_transport(maybe_a_url)
2782
2347
            if len(segments) > 1 and segments[-1] not in ('', '.'):
2783
2348
                t.ensure_base()
2784
 
            format = self.resolve_format(format)
 
2349
            if format is None:
 
2350
                format = 'default'
 
2351
            if isinstance(format, basestring):
 
2352
                format = bzrdir.format_registry.make_bzrdir(format)
2785
2353
            return format.initialize_on_transport(t)
2786
2354
        except errors.UninitializableFormat:
2787
2355
            raise TestSkipped("Format %s is not initializable." % format)
2788
2356
 
2789
 
    def make_repository(self, relpath, shared=None, format=None):
 
2357
    def make_repository(self, relpath, shared=False, format=None):
2790
2358
        """Create a repository on our default transport at relpath.
2791
2359
 
2792
2360
        Note that relpath must be a relative path, not a full url.
2795
2363
        # real format, which is incorrect.  Actually we should make sure that
2796
2364
        # RemoteBzrDir returns a RemoteRepository.
2797
2365
        # maybe  mbp 20070410
2798
 
        made_control = self.make_controldir(relpath, format=format)
 
2366
        made_control = self.make_bzrdir(relpath, format=format)
2799
2367
        return made_control.create_repository(shared=shared)
2800
2368
 
2801
 
    def make_smart_server(self, path, backing_server=None):
2802
 
        if backing_server is None:
2803
 
            backing_server = self.get_server()
2804
 
        smart_server = test_server.SmartTCPServer_for_testing()
2805
 
        self.start_server(smart_server, backing_server)
2806
 
        remote_transport = _mod_transport.get_transport_from_url(smart_server.get_url()
2807
 
                                                                 ).clone(path)
 
2369
    def make_smart_server(self, path):
 
2370
        smart_server = server.SmartTCPServer_for_testing()
 
2371
        self.start_server(smart_server, self.get_server())
 
2372
        remote_transport = get_transport(smart_server.get_url()).clone(path)
2808
2373
        return remote_transport
2809
2374
 
2810
2375
    def make_branch_and_memory_tree(self, relpath, format=None):
2811
2376
        """Create a branch on the default transport and a MemoryTree for it."""
2812
2377
        b = self.make_branch(relpath, format=format)
2813
 
        return b.create_memorytree()
 
2378
        return memorytree.MemoryTree.create_on_branch(b)
2814
2379
 
2815
2380
    def make_branch_builder(self, relpath, format=None):
2816
2381
        branch = self.make_branch(relpath, format=format)
2818
2383
 
2819
2384
    def overrideEnvironmentForTesting(self):
2820
2385
        test_home_dir = self.test_home_dir
2821
 
        if not PY3 and isinstance(test_home_dir, text_type):
 
2386
        if isinstance(test_home_dir, unicode):
2822
2387
            test_home_dir = test_home_dir.encode(sys.getfilesystemencoding())
2823
 
        self.overrideEnv('HOME', test_home_dir)
2824
 
        self.overrideEnv('BRZ_HOME', test_home_dir)
2825
 
        self.overrideEnv('GNUPGHOME', os.path.join(test_home_dir, '.gnupg'))
 
2388
        os.environ['HOME'] = test_home_dir
 
2389
        os.environ['BZR_HOME'] = test_home_dir
 
2390
 
 
2391
    def setUp(self):
 
2392
        super(TestCaseWithMemoryTransport, self).setUp()
 
2393
        self._make_test_root()
 
2394
        self.addCleanup(os.chdir, os.getcwdu())
 
2395
        self.makeAndChdirToTestDir()
 
2396
        self.overrideEnvironmentForTesting()
 
2397
        self.__readonly_server = None
 
2398
        self.__server = None
 
2399
        self.reduceLockdirTimeout()
2826
2400
 
2827
2401
    def setup_smart_server_with_call_log(self):
2828
2402
        """Sets up a smart server as the transport server with a call log."""
2829
 
        self.transport_server = test_server.SmartTCPServer_for_testing
2830
 
        self.hpss_connections = []
 
2403
        self.transport_server = server.SmartTCPServer_for_testing
2831
2404
        self.hpss_calls = []
2832
2405
        import traceback
2833
2406
        # Skip the current stack down to the caller of
2834
2407
        # setup_smart_server_with_call_log
2835
2408
        prefix_length = len(traceback.extract_stack()) - 2
2836
 
 
2837
2409
        def capture_hpss_call(params):
2838
2410
            self.hpss_calls.append(
2839
2411
                CapturedCall(params, prefix_length))
2840
 
 
2841
 
        def capture_connect(transport):
2842
 
            self.hpss_connections.append(transport)
2843
2412
        client._SmartClient.hooks.install_named_hook(
2844
2413
            'call', capture_hpss_call, None)
2845
 
        _mod_transport.Transport.hooks.install_named_hook(
2846
 
            'post_connect', capture_connect, None)
2847
2414
 
2848
2415
    def reset_smart_call_log(self):
2849
2416
        self.hpss_calls = []
2850
 
        self.hpss_connections = []
2851
2417
 
2852
2418
 
2853
2419
class TestCaseInTempDir(TestCaseWithMemoryTransport):
2872
2438
 
2873
2439
    OVERRIDE_PYTHON = 'python'
2874
2440
 
2875
 
    def setUp(self):
2876
 
        super(TestCaseInTempDir, self).setUp()
2877
 
        # Remove the protection set in isolated_environ, we have a proper
2878
 
        # access to disk resources now.
2879
 
        self.overrideEnv('BRZ_LOG', None)
2880
 
 
2881
2441
    def check_file_contents(self, filename, expect):
2882
2442
        self.log("check contents of file %s" % filename)
2883
 
        with open(filename, 'rb') as f:
2884
 
            contents = f.read()
 
2443
        contents = file(filename, 'r').read()
2885
2444
        if contents != expect:
2886
2445
            self.log("expected: %r" % expect)
2887
2446
            self.log("actually: %r" % contents)
2904
2463
        name and then create two subdirs - test and home under it.
2905
2464
        """
2906
2465
        name_prefix = osutils.pathjoin(TestCaseWithMemoryTransport.TEST_ROOT,
2907
 
                                       self._getTestDirPrefix())
 
2466
            self._getTestDirPrefix())
2908
2467
        name = name_prefix
2909
2468
        for i in range(100):
2910
2469
            if os.path.exists(name):
2920
2479
        # stacking policy to honour; create a bzr dir with an unshared
2921
2480
        # repository (but not a branch - our code would be trying to escape
2922
2481
        # then!) to stop them, and permit it to be read.
2923
 
        # control = controldir.ControlDir.create(self.test_base_dir)
 
2482
        # control = bzrdir.BzrDir.create(self.test_base_dir)
2924
2483
        # control.create_repository()
2925
2484
        self.test_home_dir = self.test_base_dir + '/home'
2926
2485
        os.mkdir(self.test_home_dir)
2928
2487
        os.mkdir(self.test_dir)
2929
2488
        os.chdir(self.test_dir)
2930
2489
        # put name of test inside
2931
 
        with open(self.test_base_dir + '/name', 'w') as f:
 
2490
        f = file(self.test_base_dir + '/name', 'w')
 
2491
        try:
2932
2492
            f.write(self.id())
 
2493
        finally:
 
2494
            f.close()
2933
2495
 
2934
2496
    def deleteTestDir(self):
2935
2497
        os.chdir(TestCaseWithMemoryTransport.TEST_ROOT)
2955
2517
        """
2956
2518
        if type(shape) not in (list, tuple):
2957
2519
            raise AssertionError("Parameter 'shape' should be "
2958
 
                                 "a list or a tuple. Got %r instead" % (shape,))
 
2520
                "a list or a tuple. Got %r instead" % (shape,))
2959
2521
        # It's OK to just create them using forward slashes on windows.
2960
2522
        if transport is None or transport.is_readonly():
2961
 
            transport = _mod_transport.get_transport_from_path(".")
 
2523
            transport = get_transport(".")
2962
2524
        for name in shape:
2963
 
            self.assertIsInstance(name, (str, text_type))
 
2525
            self.assertIsInstance(name, basestring)
2964
2526
            if name[-1] == '/':
2965
2527
                transport.mkdir(urlutils.escape(name[:-1]))
2966
2528
            else:
2967
2529
                if line_endings == 'binary':
2968
 
                    end = b'\n'
 
2530
                    end = '\n'
2969
2531
                elif line_endings == 'native':
2970
 
                    end = os.linesep.encode('ascii')
 
2532
                    end = os.linesep
2971
2533
                else:
2972
2534
                    raise errors.BzrError(
2973
2535
                        'Invalid line ending request %r' % line_endings)
2974
 
                content = b"contents of %s%s" % (name.encode('utf-8'), end)
 
2536
                content = "contents of %s%s" % (name.encode('utf-8'), end)
2975
2537
                transport.put_bytes_non_atomic(urlutils.escape(name), content)
2976
2538
 
2977
 
    build_tree_contents = staticmethod(treeshape.build_tree_contents)
 
2539
    def build_tree_contents(self, shape):
 
2540
        build_tree_contents(shape)
2978
2541
 
2979
2542
    def assertInWorkingTree(self, path, root_path='.', tree=None):
2980
2543
        """Assert whether path or paths are in the WorkingTree"""
2981
2544
        if tree is None:
2982
2545
            tree = workingtree.WorkingTree.open(root_path)
2983
 
        if not isinstance(path, (str, text_type)):
 
2546
        if not isinstance(path, basestring):
2984
2547
            for p in path:
2985
2548
                self.assertInWorkingTree(p, tree=tree)
2986
2549
        else:
2987
 
            self.assertTrue(tree.is_versioned(path),
2988
 
                            path + ' not in working tree.')
 
2550
            self.assertIsNot(tree.path2id(path), None,
 
2551
                path+' not in working tree.')
2989
2552
 
2990
2553
    def assertNotInWorkingTree(self, path, root_path='.', tree=None):
2991
2554
        """Assert whether path or paths are not in the WorkingTree"""
2992
2555
        if tree is None:
2993
2556
            tree = workingtree.WorkingTree.open(root_path)
2994
 
        if not isinstance(path, (str, text_type)):
 
2557
        if not isinstance(path, basestring):
2995
2558
            for p in path:
2996
 
                self.assertNotInWorkingTree(p, tree=tree)
 
2559
                self.assertNotInWorkingTree(p,tree=tree)
2997
2560
        else:
2998
 
            self.assertFalse(tree.is_versioned(
2999
 
                path), path + ' in working tree.')
 
2561
            self.assertIs(tree.path2id(path), None, path+' in working tree.')
3000
2562
 
3001
2563
 
3002
2564
class TestCaseWithTransport(TestCaseInTempDir):
3013
2575
    readwrite one must both define get_url() as resolving to os.getcwd().
3014
2576
    """
3015
2577
 
3016
 
    def setUp(self):
3017
 
        super(TestCaseWithTransport, self).setUp()
3018
 
        self.__vfs_server = None
3019
 
 
3020
2578
    def get_vfs_only_server(self):
3021
2579
        """See TestCaseWithMemoryTransport.
3022
2580
 
3054
2612
        # this obviously requires a format that supports branch references
3055
2613
        # so check for that by checking bzrdir.BzrDirFormat.get_default_format()
3056
2614
        # RBC 20060208
3057
 
        format = self.resolve_format(format=format)
3058
 
        if not format.supports_workingtrees:
3059
 
            b = self.make_branch(relpath + '.branch', format=format)
3060
 
            return b.create_checkout(relpath, lightweight=True)
3061
2615
        b = self.make_branch(relpath, format=format)
3062
2616
        try:
3063
 
            return b.controldir.create_workingtree()
 
2617
            return b.bzrdir.create_workingtree()
3064
2618
        except errors.NotLocalUrl:
3065
2619
            # We can only make working trees locally at the moment.  If the
3066
2620
            # transport can't support them, then we keep the non-disk-backed
3067
2621
            # branch and create a local checkout.
3068
 
            if self.vfs_transport_factory is test_server.LocalURLServer:
 
2622
            if self.vfs_transport_factory is LocalURLServer:
3069
2623
                # the branch is colocated on disk, we cannot create a checkout.
3070
2624
                # hopefully callers will expect this.
3071
 
                local_controldir = controldir.ControlDir.open(
3072
 
                    self.get_vfs_only_url(relpath))
 
2625
                local_controldir= bzrdir.BzrDir.open(self.get_vfs_only_url(relpath))
3073
2626
                wt = local_controldir.create_workingtree()
3074
2627
                if wt.branch._format != b._format:
3075
2628
                    wt._branch = b
3103
2656
        self.assertEqual(left.get_parent_ids(), right.get_parent_ids())
3104
2657
        differences = left.changes_from(right)
3105
2658
        self.assertFalse(differences.has_changed(),
3106
 
                         "Trees %r and %r are different: %r" % (left, right, differences))
 
2659
            "Trees %r and %r are different: %r" % (left, right, differences))
 
2660
 
 
2661
    def setUp(self):
 
2662
        super(TestCaseWithTransport, self).setUp()
 
2663
        self.__vfs_server = None
3107
2664
 
3108
2665
    def disable_missing_extensions_warning(self):
3109
2666
        """Some tests expect a precise stderr content.
3111
2668
        There is no point in forcing them to duplicate the extension related
3112
2669
        warning.
3113
2670
        """
3114
 
        config.GlobalConfig().set_user_option(
3115
 
            'suppress_warnings', 'missing_extensions')
 
2671
        config.GlobalConfig().set_user_option('ignore_missing_extensions', True)
3116
2672
 
3117
2673
 
3118
2674
class ChrootedTestCase(TestCaseWithTransport):
3128
2684
    """
3129
2685
 
3130
2686
    def setUp(self):
3131
 
        from breezy.tests import http_server
3132
2687
        super(ChrootedTestCase, self).setUp()
3133
 
        if not self.vfs_transport_factory == memory.MemoryServer:
3134
 
            self.transport_readonly_server = http_server.HttpServer
 
2688
        if not self.vfs_transport_factory == MemoryServer:
 
2689
            self.transport_readonly_server = HttpServer
3135
2690
 
3136
2691
 
3137
2692
def condition_id_re(pattern):
3140
2695
    :param pattern: A regular expression string.
3141
2696
    :return: A callable that returns True if the re matches.
3142
2697
    """
3143
 
    filter_re = re.compile(pattern, 0)
3144
 
 
 
2698
    filter_re = osutils.re_compile_checked(pattern, 0,
 
2699
        'test filter')
3145
2700
    def condition(test):
3146
2701
        test_id = test.id()
3147
2702
        return filter_re.search(test_id)
3337
2892
              stream=None,
3338
2893
              result_decorators=None,
3339
2894
              ):
3340
 
    """Run a test suite for brz selftest.
 
2895
    """Run a test suite for bzr selftest.
3341
2896
 
3342
2897
    :param runner_class: The class of runner to use. Must support the
3343
2898
        constructor arguments passed by run_suite which are more than standard
3354
2909
    if stream is None:
3355
2910
        stream = sys.stdout
3356
2911
    runner = runner_class(stream=stream,
3357
 
                          descriptions=0,
3358
 
                          verbosity=verbosity,
3359
 
                          bench_history=bench_history,
3360
 
                          strict=strict,
3361
 
                          result_decorators=result_decorators,
3362
 
                          )
3363
 
    runner.stop_on_failure = stop_on_failure
3364
 
    if isinstance(suite, unittest.TestSuite):
3365
 
        # Empty out _tests list of passed suite and populate new TestSuite
3366
 
        suite._tests[:], suite = [], TestSuite(suite)
 
2912
                            descriptions=0,
 
2913
                            verbosity=verbosity,
 
2914
                            bench_history=bench_history,
 
2915
                            strict=strict,
 
2916
                            result_decorators=result_decorators,
 
2917
                            )
 
2918
    runner.stop_on_failure=stop_on_failure
3367
2919
    # built in decorator factories:
3368
2920
    decorators = [
3369
2921
        random_order(random_seed, runner),
3387
2939
        # to take effect, though that is of marginal benefit.
3388
2940
        if verbosity >= 2:
3389
2941
            stream.write("Listing tests only ...\n")
3390
 
        if getattr(runner, 'list', None) is not None:
3391
 
            runner.list(suite)
3392
 
        else:
3393
 
            for t in iter_suite_tests(suite):
3394
 
                stream.write("%s\n" % (t.id()))
 
2942
        for t in iter_suite_tests(suite):
 
2943
            stream.write("%s\n" % (t.id()))
3395
2944
        return True
3396
2945
    result = runner.run(suite)
3397
 
    if strict and getattr(result, 'wasStrictlySuccessful', False):
 
2946
    if strict:
3398
2947
        return result.wasStrictlySuccessful()
3399
2948
    else:
3400
2949
        return result.wasSuccessful()
3405
2954
 
3406
2955
 
3407
2956
def fork_decorator(suite):
3408
 
    if getattr(os, "fork", None) is None:
3409
 
        raise errors.BzrCommandError("platform does not support fork,"
3410
 
                                     " try --parallel=subprocess instead.")
3411
2957
    concurrency = osutils.local_concurrency()
3412
2958
    if concurrency == 1:
3413
2959
        return suite
3414
2960
    from testtools import ConcurrentTestSuite
3415
2961
    return ConcurrentTestSuite(suite, fork_for_tests)
3416
 
 
3417
 
 
3418
2962
parallel_registry.register('fork', fork_decorator)
3419
2963
 
3420
2964
 
3424
2968
        return suite
3425
2969
    from testtools import ConcurrentTestSuite
3426
2970
    return ConcurrentTestSuite(suite, reinvoke_for_tests)
3427
 
 
3428
 
 
3429
2971
parallel_registry.register('subprocess', subprocess_decorator)
3430
2972
 
3431
2973
 
3433
2975
    """Return a test suite decorator that excludes tests."""
3434
2976
    if exclude_pattern is None:
3435
2977
        return identity_decorator
3436
 
 
3437
2978
    def decorator(suite):
3438
2979
        return ExcludeDecorator(suite, exclude_pattern)
3439
2980
    return decorator
3442
2983
def filter_tests(pattern):
3443
2984
    if pattern == '.*':
3444
2985
        return identity_decorator
3445
 
 
3446
2986
    def decorator(suite):
3447
2987
        return FilterTestsDecorator(suite, pattern)
3448
2988
    return decorator
3450
2990
 
3451
2991
def random_order(random_seed, runner):
3452
2992
    """Return a test suite decorator factory for randomising tests order.
3453
 
 
3454
 
    :param random_seed: now, a string which casts to an integer, or an integer.
 
2993
    
 
2994
    :param random_seed: now, a string which casts to a long, or a long.
3455
2995
    :param runner: A test runner with a stream attribute to report on.
3456
2996
    """
3457
2997
    if random_seed is None:
3458
2998
        return identity_decorator
3459
 
 
3460
2999
    def decorator(suite):
3461
3000
        return RandomDecorator(suite, random_seed, runner.stream)
3462
3001
    return decorator
3465
3004
def tests_first(pattern):
3466
3005
    if pattern == '.*':
3467
3006
        return identity_decorator
3468
 
 
3469
3007
    def decorator(suite):
3470
3008
        return TestFirstDecorator(suite, pattern)
3471
3009
    return decorator
3476
3014
    return suite
3477
3015
 
3478
3016
 
3479
 
class TestDecorator(TestUtil.TestSuite):
 
3017
class TestDecorator(TestSuite):
3480
3018
    """A decorator for TestCase/TestSuite objects.
3481
 
 
3482
 
    Contains rather than flattening suite passed on construction
 
3019
    
 
3020
    Usually, subclasses should override __iter__(used when flattening test
 
3021
    suites), which we do to filter, reorder, parallelise and so on, run() and
 
3022
    debug().
3483
3023
    """
3484
3024
 
3485
 
    def __init__(self, suite=None):
3486
 
        super(TestDecorator, self).__init__()
3487
 
        if suite is not None:
3488
 
            self.addTest(suite)
3489
 
 
3490
 
    # Don't need subclass run method with suite emptying
3491
 
    run = unittest.TestSuite.run
 
3025
    def __init__(self, suite):
 
3026
        TestSuite.__init__(self)
 
3027
        self.addTest(suite)
 
3028
 
 
3029
    def countTestCases(self):
 
3030
        cases = 0
 
3031
        for test in self:
 
3032
            cases += test.countTestCases()
 
3033
        return cases
 
3034
 
 
3035
    def debug(self):
 
3036
        for test in self:
 
3037
            test.debug()
 
3038
 
 
3039
    def run(self, result):
 
3040
        # Use iteration on self, not self._tests, to allow subclasses to hook
 
3041
        # into __iter__.
 
3042
        for test in self:
 
3043
            if result.shouldStop:
 
3044
                break
 
3045
            test.run(result)
 
3046
        return result
3492
3047
 
3493
3048
 
3494
3049
class CountingDecorator(TestDecorator):
3505
3060
    """A decorator which excludes test matching an exclude pattern."""
3506
3061
 
3507
3062
    def __init__(self, suite, exclude_pattern):
3508
 
        super(ExcludeDecorator, self).__init__(
3509
 
            exclude_tests_by_re(suite, exclude_pattern))
 
3063
        TestDecorator.__init__(self, suite)
 
3064
        self.exclude_pattern = exclude_pattern
 
3065
        self.excluded = False
 
3066
 
 
3067
    def __iter__(self):
 
3068
        if self.excluded:
 
3069
            return iter(self._tests)
 
3070
        self.excluded = True
 
3071
        suite = exclude_tests_by_re(self, self.exclude_pattern)
 
3072
        del self._tests[:]
 
3073
        self.addTests(suite)
 
3074
        return iter(self._tests)
3510
3075
 
3511
3076
 
3512
3077
class FilterTestsDecorator(TestDecorator):
3513
3078
    """A decorator which filters tests to those matching a pattern."""
3514
3079
 
3515
3080
    def __init__(self, suite, pattern):
3516
 
        super(FilterTestsDecorator, self).__init__(
3517
 
            filter_suite_by_re(suite, pattern))
 
3081
        TestDecorator.__init__(self, suite)
 
3082
        self.pattern = pattern
 
3083
        self.filtered = False
 
3084
 
 
3085
    def __iter__(self):
 
3086
        if self.filtered:
 
3087
            return iter(self._tests)
 
3088
        self.filtered = True
 
3089
        suite = filter_suite_by_re(self, self.pattern)
 
3090
        del self._tests[:]
 
3091
        self.addTests(suite)
 
3092
        return iter(self._tests)
3518
3093
 
3519
3094
 
3520
3095
class RandomDecorator(TestDecorator):
3521
3096
    """A decorator which randomises the order of its tests."""
3522
3097
 
3523
3098
    def __init__(self, suite, random_seed, stream):
3524
 
        random_seed = self.actual_seed(random_seed)
3525
 
        stream.write("Randomizing test order using seed %s\n\n" %
3526
 
                     (random_seed,))
 
3099
        TestDecorator.__init__(self, suite)
 
3100
        self.random_seed = random_seed
 
3101
        self.randomised = False
 
3102
        self.stream = stream
 
3103
 
 
3104
    def __iter__(self):
 
3105
        if self.randomised:
 
3106
            return iter(self._tests)
 
3107
        self.randomised = True
 
3108
        self.stream.write("Randomizing test order using seed %s\n\n" %
 
3109
            (self.actual_seed()))
3527
3110
        # Initialise the random number generator.
3528
 
        random.seed(random_seed)
3529
 
        super(RandomDecorator, self).__init__(randomize_suite(suite))
 
3111
        random.seed(self.actual_seed())
 
3112
        suite = randomize_suite(self)
 
3113
        del self._tests[:]
 
3114
        self.addTests(suite)
 
3115
        return iter(self._tests)
3530
3116
 
3531
 
    @staticmethod
3532
 
    def actual_seed(seed):
3533
 
        if seed == "now":
3534
 
            # We convert the seed to an integer to make it reuseable across
 
3117
    def actual_seed(self):
 
3118
        if self.random_seed == "now":
 
3119
            # We convert the seed to a long to make it reuseable across
3535
3120
            # invocations (because the user can reenter it).
3536
 
            return int(time.time())
 
3121
            self.random_seed = long(time.time())
3537
3122
        else:
3538
 
            # Convert the seed to an integer if we can
 
3123
            # Convert the seed to a long if we can
3539
3124
            try:
3540
 
                return int(seed)
3541
 
            except (TypeError, ValueError):
 
3125
                self.random_seed = long(self.random_seed)
 
3126
            except:
3542
3127
                pass
3543
 
        return seed
 
3128
        return self.random_seed
3544
3129
 
3545
3130
 
3546
3131
class TestFirstDecorator(TestDecorator):
3547
3132
    """A decorator which moves named tests to the front."""
3548
3133
 
3549
3134
    def __init__(self, suite, pattern):
3550
 
        super(TestFirstDecorator, self).__init__()
3551
 
        self.addTests(split_suite_by_re(suite, pattern))
 
3135
        TestDecorator.__init__(self, suite)
 
3136
        self.pattern = pattern
 
3137
        self.filtered = False
 
3138
 
 
3139
    def __iter__(self):
 
3140
        if self.filtered:
 
3141
            return iter(self._tests)
 
3142
        self.filtered = True
 
3143
        suites = split_suite_by_re(self, self.pattern)
 
3144
        del self._tests[:]
 
3145
        self.addTests(suites)
 
3146
        return iter(self._tests)
3552
3147
 
3553
3148
 
3554
3149
def partition_tests(suite, count):
3555
3150
    """Partition suite into count lists of tests."""
3556
 
    # This just assigns tests in a round-robin fashion.  On one hand this
3557
 
    # splits up blocks of related tests that might run faster if they shared
3558
 
    # resources, but on the other it avoids assigning blocks of slow tests to
3559
 
    # just one partition.  So the slowest partition shouldn't be much slower
3560
 
    # than the fastest.
3561
 
    partitions = [list() for i in range(count)]
3562
 
    tests = iter_suite_tests(suite)
3563
 
    for partition, test in zip(itertools.cycle(partitions), tests):
3564
 
        partition.append(test)
3565
 
    return partitions
3566
 
 
3567
 
 
3568
 
def workaround_zealous_crypto_random():
3569
 
    """Crypto.Random want to help us being secure, but we don't care here.
3570
 
 
3571
 
    This workaround some test failure related to the sftp server. Once paramiko
3572
 
    stop using the controversial API in Crypto.Random, we may get rid of it.
3573
 
    """
3574
 
    try:
3575
 
        from Crypto.Random import atfork
3576
 
        atfork()
3577
 
    except ImportError:
3578
 
        pass
 
3151
    result = []
 
3152
    tests = list(iter_suite_tests(suite))
 
3153
    tests_per_process = int(math.ceil(float(len(tests)) / count))
 
3154
    for block in range(count):
 
3155
        low_test = block * tests_per_process
 
3156
        high_test = low_test + tests_per_process
 
3157
        process_tests = tests[low_test:high_test]
 
3158
        result.append(process_tests)
 
3159
    return result
3579
3160
 
3580
3161
 
3581
3162
def fork_for_tests(suite):
3586
3167
    """
3587
3168
    concurrency = osutils.local_concurrency()
3588
3169
    result = []
3589
 
    from subunit import ProtocolTestCase
 
3170
    from subunit import TestProtocolClient, ProtocolTestCase
3590
3171
    from subunit.test_results import AutoTimingTestResultDecorator
3591
 
 
3592
3172
    class TestInOtherProcess(ProtocolTestCase):
3593
3173
        # Should be in subunit, I think. RBC.
3594
3174
        def __init__(self, stream, pid):
3599
3179
            try:
3600
3180
                ProtocolTestCase.run(self, result)
3601
3181
            finally:
3602
 
                pid, status = os.waitpid(self.pid, 0)
3603
 
            # GZ 2011-10-18: If status is nonzero, should report to the result
3604
 
            #                that something went wrong.
 
3182
                os.waitpid(self.pid, os.WNOHANG)
3605
3183
 
3606
3184
    test_blocks = partition_tests(suite, concurrency)
3607
 
    # Clear the tests from the original suite so it doesn't keep them alive
3608
 
    suite._tests[:] = []
3609
3185
    for process_tests in test_blocks:
3610
 
        process_suite = TestUtil.TestSuite(process_tests)
3611
 
        # Also clear each split list so new suite has only reference
3612
 
        process_tests[:] = []
 
3186
        process_suite = TestSuite()
 
3187
        process_suite.addTests(process_tests)
3613
3188
        c2pread, c2pwrite = os.pipe()
3614
3189
        pid = os.fork()
3615
3190
        if pid == 0:
3616
3191
            try:
3617
 
                stream = os.fdopen(c2pwrite, 'wb', 0)
3618
 
                workaround_zealous_crypto_random()
3619
 
                try:
3620
 
                    import coverage
3621
 
                except ImportError:
3622
 
                    pass
3623
 
                else:
3624
 
                    coverage.process_startup()
3625
3192
                os.close(c2pread)
3626
3193
                # Leave stderr and stdout open so we can see test noise
3627
3194
                # Close stdin so that the child goes away if it decides to
3628
3195
                # read from stdin (otherwise its a roulette to see what
3629
3196
                # child actually gets keystrokes for pdb etc).
3630
3197
                sys.stdin.close()
 
3198
                sys.stdin = None
 
3199
                stream = os.fdopen(c2pwrite, 'wb', 1)
3631
3200
                subunit_result = AutoTimingTestResultDecorator(
3632
 
                    SubUnitBzrProtocolClientv1(stream))
 
3201
                    TestProtocolClient(stream))
3633
3202
                process_suite.run(subunit_result)
3634
 
            except:
3635
 
                # Try and report traceback on stream, but exit with error even
3636
 
                # if stream couldn't be created or something else goes wrong.
3637
 
                # The traceback is formatted to a string and written in one go
3638
 
                # to avoid interleaving lines from multiple failing children.
3639
 
                tb = traceback.format_exc()
3640
 
                if isinstance(tb, text_type):
3641
 
                    tb = tb.encode('utf-8')
3642
 
                try:
3643
 
                    stream.write(tb)
3644
 
                finally:
3645
 
                    stream.flush()
3646
 
                    os._exit(1)
3647
 
            os._exit(0)
 
3203
            finally:
 
3204
                os._exit(0)
3648
3205
        else:
3649
3206
            os.close(c2pwrite)
3650
 
            stream = os.fdopen(c2pread, 'rb', 0)
 
3207
            stream = os.fdopen(c2pread, 'rb', 1)
3651
3208
            test = TestInOtherProcess(stream, pid)
3652
3209
            result.append(test)
3653
3210
    return result
3662
3219
    concurrency = osutils.local_concurrency()
3663
3220
    result = []
3664
3221
    from subunit import ProtocolTestCase
3665
 
 
3666
3222
    class TestInSubprocess(ProtocolTestCase):
3667
3223
        def __init__(self, process, name):
3668
3224
            ProtocolTestCase.__init__(self, process.stdout)
3680
3236
    test_blocks = partition_tests(suite, concurrency)
3681
3237
    for process_tests in test_blocks:
3682
3238
        # ugly; currently reimplement rather than reuses TestCase methods.
3683
 
        bzr_path = os.path.dirname(os.path.dirname(breezy.__file__)) + '/bzr'
 
3239
        bzr_path = os.path.dirname(os.path.dirname(bzrlib.__file__))+'/bzr'
3684
3240
        if not os.path.isfile(bzr_path):
3685
3241
            # We are probably installed. Assume sys.argv is the right file
3686
3242
            bzr_path = sys.argv[0]
3695
3251
        test_list_file.close()
3696
3252
        try:
3697
3253
            argv = bzr_path + ['selftest', '--load-list', test_list_file_name,
3698
 
                               '--subunit']
 
3254
                '--subunit']
3699
3255
            if '--no-plugins' in sys.argv:
3700
3256
                argv.append('--no-plugins')
3701
 
            # stderr=subprocess.STDOUT would be ideal, but until we prevent
3702
 
            # noise on stderr it can interrupt the subunit protocol.
3703
 
            process = subprocess.Popen(argv, stdin=subprocess.PIPE,
3704
 
                                       stdout=subprocess.PIPE,
3705
 
                                       stderr=subprocess.PIPE,
3706
 
                                       bufsize=1)
 
3257
            # stderr=STDOUT would be ideal, but until we prevent noise on
 
3258
            # stderr it can interrupt the subunit protocol.
 
3259
            process = Popen(argv, stdin=PIPE, stdout=PIPE, stderr=PIPE,
 
3260
                bufsize=1)
3707
3261
            test = TestInSubprocess(process, test_list_file_name)
3708
3262
            result.append(test)
3709
3263
        except:
3712
3266
    return result
3713
3267
 
3714
3268
 
3715
 
class ProfileResult(testtools.ExtendedToOriginalDecorator):
 
3269
class ForwardingResult(unittest.TestResult):
 
3270
 
 
3271
    def __init__(self, target):
 
3272
        unittest.TestResult.__init__(self)
 
3273
        self.result = target
 
3274
 
 
3275
    def startTest(self, test):
 
3276
        self.result.startTest(test)
 
3277
 
 
3278
    def stopTest(self, test):
 
3279
        self.result.stopTest(test)
 
3280
 
 
3281
    def startTestRun(self):
 
3282
        self.result.startTestRun()
 
3283
 
 
3284
    def stopTestRun(self):
 
3285
        self.result.stopTestRun()
 
3286
 
 
3287
    def addSkip(self, test, reason):
 
3288
        self.result.addSkip(test, reason)
 
3289
 
 
3290
    def addSuccess(self, test):
 
3291
        self.result.addSuccess(test)
 
3292
 
 
3293
    def addError(self, test, err):
 
3294
        self.result.addError(test, err)
 
3295
 
 
3296
    def addFailure(self, test, err):
 
3297
        self.result.addFailure(test, err)
 
3298
ForwardingResult = testtools.ExtendedToOriginalDecorator
 
3299
 
 
3300
 
 
3301
class ProfileResult(ForwardingResult):
3716
3302
    """Generate profiling data for all activity between start and success.
3717
 
 
 
3303
    
3718
3304
    The profile data is appended to the test's _benchcalls attribute and can
3719
3305
    be accessed by the forwarded-to TestResult.
3720
3306
 
3725
3311
    """
3726
3312
 
3727
3313
    def startTest(self, test):
3728
 
        self.profiler = breezy.lsprof.BzrProfiler()
3729
 
        # Prevent deadlocks in tests that use lsprof: those tests will
3730
 
        # unavoidably fail.
3731
 
        breezy.lsprof.BzrProfiler.profiler_block = 0
 
3314
        self.profiler = bzrlib.lsprof.BzrProfiler()
3732
3315
        self.profiler.start()
3733
 
        testtools.ExtendedToOriginalDecorator.startTest(self, test)
 
3316
        ForwardingResult.startTest(self, test)
3734
3317
 
3735
3318
    def addSuccess(self, test):
3736
3319
        stats = self.profiler.stop()
3740
3323
            test._benchcalls = []
3741
3324
            calls = test._benchcalls
3742
3325
        calls.append(((test.id(), "", ""), stats))
3743
 
        testtools.ExtendedToOriginalDecorator.addSuccess(self, test)
 
3326
        ForwardingResult.addSuccess(self, test)
3744
3327
 
3745
3328
    def stopTest(self, test):
3746
 
        testtools.ExtendedToOriginalDecorator.stopTest(self, test)
 
3329
        ForwardingResult.stopTest(self, test)
3747
3330
        self.profiler = None
3748
3331
 
3749
3332
 
3750
 
# Controlled by "brz selftest -E=..." option
 
3333
# Controlled by "bzr selftest -E=..." option
3751
3334
# Currently supported:
3752
3335
#   -Eallow_debug           Will no longer clear debug.debug_flags() so it
3753
3336
#                           preserves any flags supplied at the command line.
3755
3338
#                           rather than failing tests. And no longer raise
3756
3339
#                           LockContention when fctnl locks are not being used
3757
3340
#                           with proper exclusion rules.
3758
 
#   -Ethreads               Will display thread ident at creation/join time to
3759
 
#                           help track thread leaks
3760
 
#   -Euncollected_cases     Display the identity of any test cases that weren't
3761
 
#                           deallocated after being completed.
3762
 
#   -Econfig_stats          Will collect statistics using addDetail
3763
3341
selftest_debug_flags = set()
3764
3342
 
3765
3343
 
3785
3363
    # XXX: Very ugly way to do this...
3786
3364
    # Disable warning about old formats because we don't want it to disturb
3787
3365
    # any blackbox tests.
3788
 
    from breezy import repository
 
3366
    from bzrlib import repository
3789
3367
    repository._deprecation_warning_done = True
3790
3368
 
3791
3369
    global default_transport
3805
3383
        if starting_with:
3806
3384
            starting_with = [test_prefix_alias_registry.resolve_alias(start)
3807
3385
                             for start in starting_with]
3808
 
            # Always consider 'unittest' an interesting name so that failed
3809
 
            # suites wrapped as test cases appear in the output.
3810
 
            starting_with.append('unittest')
3811
3386
        if test_suite_factory is None:
3812
3387
            # Reduce loading time by loading modules based on the starting_with
3813
3388
            # patterns.
3821
3396
        if lsprof_tests:
3822
3397
            result_decorators.append(ProfileResult)
3823
3398
        return run_suite(suite, 'testbzr', verbose=verbose, pattern=pattern,
3824
 
                         stop_on_failure=stop_on_failure,
3825
 
                         transport=transport,
3826
 
                         lsprof_timed=lsprof_timed,
3827
 
                         bench_history=bench_history,
3828
 
                         matching_tests_first=matching_tests_first,
3829
 
                         list_only=list_only,
3830
 
                         random_seed=random_seed,
3831
 
                         exclude_pattern=exclude_pattern,
3832
 
                         strict=strict,
3833
 
                         runner_class=runner_class,
3834
 
                         suite_decorators=suite_decorators,
3835
 
                         stream=stream,
3836
 
                         result_decorators=result_decorators,
3837
 
                         )
 
3399
                     stop_on_failure=stop_on_failure,
 
3400
                     transport=transport,
 
3401
                     lsprof_timed=lsprof_timed,
 
3402
                     bench_history=bench_history,
 
3403
                     matching_tests_first=matching_tests_first,
 
3404
                     list_only=list_only,
 
3405
                     random_seed=random_seed,
 
3406
                     exclude_pattern=exclude_pattern,
 
3407
                     strict=strict,
 
3408
                     runner_class=runner_class,
 
3409
                     suite_decorators=suite_decorators,
 
3410
                     stream=stream,
 
3411
                     result_decorators=result_decorators,
 
3412
                     )
3838
3413
    finally:
3839
3414
        default_transport = old_transport
3840
3415
        selftest_debug_flags = old_debug_flags
3851
3426
    test_list = []
3852
3427
    try:
3853
3428
        ftest = open(file_name, 'rt')
3854
 
    except IOError as e:
 
3429
    except IOError, e:
3855
3430
        if e.errno != errno.ENOENT:
3856
3431
            raise
3857
3432
        else:
3872
3447
 
3873
3448
    :return: (absents, duplicates) absents is a list containing the test found
3874
3449
        in id_list but not in test_suite, duplicates is a list containing the
3875
 
        tests found multiple times in test_suite.
 
3450
        test found multiple times in test_suite.
3876
3451
 
3877
3452
    When using a prefined test id list, it may occurs that some tests do not
3878
3453
    exist anymore or that some tests use the same id. This function warns the
3936
3511
 
3937
3512
    def refers_to(self, module_name):
3938
3513
        """Is there tests for the module or one of its sub modules."""
3939
 
        return module_name in self.modules
 
3514
        return self.modules.has_key(module_name)
3940
3515
 
3941
3516
    def includes(self, test_id):
3942
 
        return test_id in self.tests
 
3517
        return self.tests.has_key(test_id)
3943
3518
 
3944
3519
 
3945
3520
class TestPrefixAliasRegistry(registry.Registry):
3962
3537
                key, obj, help=help, info=info, override_existing=False)
3963
3538
        except KeyError:
3964
3539
            actual = self.get(key)
3965
 
            trace.note(
3966
 
                'Test prefix alias %s is already used for %s, ignoring %s'
3967
 
                % (key, actual, obj))
 
3540
            note('Test prefix alias %s is already used for %s, ignoring %s'
 
3541
                 % (key, actual, obj))
3968
3542
 
3969
3543
    def resolve_alias(self, id_start):
3970
3544
        """Replace the alias by the prefix in the given string.
3985
3559
 
3986
3560
 
3987
3561
# This alias allows to detect typos ('bzrlin.') by making all valid test ids
3988
 
# appear prefixed ('breezy.' is "replaced" by 'breezy.').
3989
 
test_prefix_alias_registry.register('breezy', 'breezy')
 
3562
# appear prefixed ('bzrlib.' is "replaced" by 'bzrlib.').
 
3563
test_prefix_alias_registry.register('bzrlib', 'bzrlib')
3990
3564
 
3991
3565
# Obvious highest levels prefixes, feel free to add your own via a plugin
3992
 
test_prefix_alias_registry.register('bd', 'breezy.doc')
3993
 
test_prefix_alias_registry.register('bu', 'breezy.utils')
3994
 
test_prefix_alias_registry.register('bt', 'breezy.tests')
3995
 
test_prefix_alias_registry.register('bgt', 'breezy.git.tests')
3996
 
test_prefix_alias_registry.register('bb', 'breezy.tests.blackbox')
3997
 
test_prefix_alias_registry.register('bp', 'breezy.plugins')
 
3566
test_prefix_alias_registry.register('bd', 'bzrlib.doc')
 
3567
test_prefix_alias_registry.register('bu', 'bzrlib.utils')
 
3568
test_prefix_alias_registry.register('bt', 'bzrlib.tests')
 
3569
test_prefix_alias_registry.register('bb', 'bzrlib.tests.blackbox')
 
3570
test_prefix_alias_registry.register('bp', 'bzrlib.plugins')
3998
3571
 
3999
3572
 
4000
3573
def _test_suite_testmod_names():
4001
3574
    """Return the standard list of test module names to test."""
4002
3575
    return [
4003
 
        'breezy.git.tests.test_blackbox',
4004
 
        'breezy.git.tests.test_builder',
4005
 
        'breezy.git.tests.test_branch',
4006
 
        'breezy.git.tests.test_cache',
4007
 
        'breezy.git.tests.test_dir',
4008
 
        'breezy.git.tests.test_fetch',
4009
 
        'breezy.git.tests.test_git_remote_helper',
4010
 
        'breezy.git.tests.test_mapping',
4011
 
        'breezy.git.tests.test_memorytree',
4012
 
        'breezy.git.tests.test_object_store',
4013
 
        'breezy.git.tests.test_pristine_tar',
4014
 
        'breezy.git.tests.test_push',
4015
 
        'breezy.git.tests.test_remote',
4016
 
        'breezy.git.tests.test_repository',
4017
 
        'breezy.git.tests.test_refs',
4018
 
        'breezy.git.tests.test_revspec',
4019
 
        'breezy.git.tests.test_roundtrip',
4020
 
        'breezy.git.tests.test_server',
4021
 
        'breezy.git.tests.test_transportgit',
4022
 
        'breezy.git.tests.test_unpeel_map',
4023
 
        'breezy.git.tests.test_urls',
4024
 
        'breezy.git.tests.test_workingtree',
4025
 
        'breezy.tests.blackbox',
4026
 
        'breezy.tests.commands',
4027
 
        'breezy.tests.per_branch',
4028
 
        'breezy.tests.per_bzrdir',
4029
 
        'breezy.tests.per_controldir',
4030
 
        'breezy.tests.per_controldir_colo',
4031
 
        'breezy.tests.per_foreign_vcs',
4032
 
        'breezy.tests.per_interrepository',
4033
 
        'breezy.tests.per_intertree',
4034
 
        'breezy.tests.per_inventory',
4035
 
        'breezy.tests.per_interbranch',
4036
 
        'breezy.tests.per_lock',
4037
 
        'breezy.tests.per_merger',
4038
 
        'breezy.tests.per_transport',
4039
 
        'breezy.tests.per_tree',
4040
 
        'breezy.tests.per_pack_repository',
4041
 
        'breezy.tests.per_repository',
4042
 
        'breezy.tests.per_repository_chk',
4043
 
        'breezy.tests.per_repository_reference',
4044
 
        'breezy.tests.per_repository_vf',
4045
 
        'breezy.tests.per_uifactory',
4046
 
        'breezy.tests.per_versionedfile',
4047
 
        'breezy.tests.per_workingtree',
4048
 
        'breezy.tests.test__annotator',
4049
 
        'breezy.tests.test__bencode',
4050
 
        'breezy.tests.test__btree_serializer',
4051
 
        'breezy.tests.test__chk_map',
4052
 
        'breezy.tests.test__dirstate_helpers',
4053
 
        'breezy.tests.test__groupcompress',
4054
 
        'breezy.tests.test__known_graph',
4055
 
        'breezy.tests.test__rio',
4056
 
        'breezy.tests.test__simple_set',
4057
 
        'breezy.tests.test__static_tuple',
4058
 
        'breezy.tests.test__walkdirs_win32',
4059
 
        'breezy.tests.test_ancestry',
4060
 
        'breezy.tests.test_annotate',
4061
 
        'breezy.tests.test_atomicfile',
4062
 
        'breezy.tests.test_bad_files',
4063
 
        'breezy.tests.test_bisect',
4064
 
        'breezy.tests.test_bisect_multi',
4065
 
        'breezy.tests.test_branch',
4066
 
        'breezy.tests.test_branchbuilder',
4067
 
        'breezy.tests.test_btree_index',
4068
 
        'breezy.tests.test_bugtracker',
4069
 
        'breezy.tests.test_bundle',
4070
 
        'breezy.tests.test_bzrdir',
4071
 
        'breezy.tests.test__chunks_to_lines',
4072
 
        'breezy.tests.test_cache_utf8',
4073
 
        'breezy.tests.test_chk_map',
4074
 
        'breezy.tests.test_chk_serializer',
4075
 
        'breezy.tests.test_chunk_writer',
4076
 
        'breezy.tests.test_clean_tree',
4077
 
        'breezy.tests.test_cleanup',
4078
 
        'breezy.tests.test_cmdline',
4079
 
        'breezy.tests.test_commands',
4080
 
        'breezy.tests.test_commit',
4081
 
        'breezy.tests.test_commit_merge',
4082
 
        'breezy.tests.test_config',
4083
 
        'breezy.tests.test_bedding',
4084
 
        'breezy.tests.test_conflicts',
4085
 
        'breezy.tests.test_controldir',
4086
 
        'breezy.tests.test_counted_lock',
4087
 
        'breezy.tests.test_crash',
4088
 
        'breezy.tests.test_decorators',
4089
 
        'breezy.tests.test_delta',
4090
 
        'breezy.tests.test_debug',
4091
 
        'breezy.tests.test_diff',
4092
 
        'breezy.tests.test_directory_service',
4093
 
        'breezy.tests.test_dirstate',
4094
 
        'breezy.tests.test_email_message',
4095
 
        'breezy.tests.test_eol_filters',
4096
 
        'breezy.tests.test_errors',
4097
 
        'breezy.tests.test_estimate_compressed_size',
4098
 
        'breezy.tests.test_export',
4099
 
        'breezy.tests.test_export_pot',
4100
 
        'breezy.tests.test_extract',
4101
 
        'breezy.tests.test_features',
4102
 
        'breezy.tests.test_fetch',
4103
 
        'breezy.tests.test_fetch_ghosts',
4104
 
        'breezy.tests.test_fixtures',
4105
 
        'breezy.tests.test_fifo_cache',
4106
 
        'breezy.tests.test_filters',
4107
 
        'breezy.tests.test_filter_tree',
4108
 
        'breezy.tests.test_foreign',
4109
 
        'breezy.tests.test_generate_docs',
4110
 
        'breezy.tests.test_generate_ids',
4111
 
        'breezy.tests.test_globbing',
4112
 
        'breezy.tests.test_gpg',
4113
 
        'breezy.tests.test_graph',
4114
 
        'breezy.tests.test_grep',
4115
 
        'breezy.tests.test_groupcompress',
4116
 
        'breezy.tests.test_hashcache',
4117
 
        'breezy.tests.test_help',
4118
 
        'breezy.tests.test_hooks',
4119
 
        'breezy.tests.test_http',
4120
 
        'breezy.tests.test_http_response',
4121
 
        'breezy.tests.test_https_ca_bundle',
4122
 
        'breezy.tests.test_https_urllib',
4123
 
        'breezy.tests.test_i18n',
4124
 
        'breezy.tests.test_identitymap',
4125
 
        'breezy.tests.test_ignores',
4126
 
        'breezy.tests.test_index',
4127
 
        'breezy.tests.test_import_tariff',
4128
 
        'breezy.tests.test_info',
4129
 
        'breezy.tests.test_inv',
4130
 
        'breezy.tests.test_inventory_delta',
4131
 
        'breezy.tests.test_knit',
4132
 
        'breezy.tests.test_lazy_import',
4133
 
        'breezy.tests.test_lazy_regex',
4134
 
        'breezy.tests.test_library_state',
4135
 
        'breezy.tests.test_location',
4136
 
        'breezy.tests.test_lock',
4137
 
        'breezy.tests.test_lockable_files',
4138
 
        'breezy.tests.test_lockdir',
4139
 
        'breezy.tests.test_log',
4140
 
        'breezy.tests.test_lru_cache',
4141
 
        'breezy.tests.test_lsprof',
4142
 
        'breezy.tests.test_mail_client',
4143
 
        'breezy.tests.test_matchers',
4144
 
        'breezy.tests.test_memorytree',
4145
 
        'breezy.tests.test_merge',
4146
 
        'breezy.tests.test_merge3',
4147
 
        'breezy.tests.test_mergeable',
4148
 
        'breezy.tests.test_merge_core',
4149
 
        'breezy.tests.test_merge_directive',
4150
 
        'breezy.tests.test_mergetools',
4151
 
        'breezy.tests.test_missing',
4152
 
        'breezy.tests.test_msgeditor',
4153
 
        'breezy.tests.test_multiparent',
4154
 
        'breezy.tests.test_multiwalker',
4155
 
        'breezy.tests.test_mutabletree',
4156
 
        'breezy.tests.test_nonascii',
4157
 
        'breezy.tests.test_options',
4158
 
        'breezy.tests.test_osutils',
4159
 
        'breezy.tests.test_osutils_encodings',
4160
 
        'breezy.tests.test_pack',
4161
 
        'breezy.tests.test_patch',
4162
 
        'breezy.tests.test_patches',
4163
 
        'breezy.tests.test_permissions',
4164
 
        'breezy.tests.test_plugins',
4165
 
        'breezy.tests.test_progress',
4166
 
        'breezy.tests.test_propose',
4167
 
        'breezy.tests.test_pyutils',
4168
 
        'breezy.tests.test_read_bundle',
4169
 
        'breezy.tests.test_reconcile',
4170
 
        'breezy.tests.test_reconfigure',
4171
 
        'breezy.tests.test_registry',
4172
 
        'breezy.tests.test_remote',
4173
 
        'breezy.tests.test_rename_map',
4174
 
        'breezy.tests.test_repository',
4175
 
        'breezy.tests.test_revert',
4176
 
        'breezy.tests.test_revision',
4177
 
        'breezy.tests.test_revisionspec',
4178
 
        'breezy.tests.test_revisiontree',
4179
 
        'breezy.tests.test_rio',
4180
 
        'breezy.tests.test_rules',
4181
 
        'breezy.tests.test_url_policy_open',
4182
 
        'breezy.tests.test_sampler',
4183
 
        'breezy.tests.test_scenarios',
4184
 
        'breezy.tests.test_script',
4185
 
        'breezy.tests.test_selftest',
4186
 
        'breezy.tests.test_serializer',
4187
 
        'breezy.tests.test_setup',
4188
 
        'breezy.tests.test_sftp_transport',
4189
 
        'breezy.tests.test_shelf',
4190
 
        'breezy.tests.test_shelf_ui',
4191
 
        'breezy.tests.test_smart',
4192
 
        'breezy.tests.test_smart_add',
4193
 
        'breezy.tests.test_smart_request',
4194
 
        'breezy.tests.test_smart_signals',
4195
 
        'breezy.tests.test_smart_transport',
4196
 
        'breezy.tests.test_smtp_connection',
4197
 
        'breezy.tests.test_source',
4198
 
        'breezy.tests.test_ssh_transport',
4199
 
        'breezy.tests.test_status',
4200
 
        'breezy.tests.test_strace',
4201
 
        'breezy.tests.test_subsume',
4202
 
        'breezy.tests.test_switch',
4203
 
        'breezy.tests.test_symbol_versioning',
4204
 
        'breezy.tests.test_tag',
4205
 
        'breezy.tests.test_test_server',
4206
 
        'breezy.tests.test_testament',
4207
 
        'breezy.tests.test_textfile',
4208
 
        'breezy.tests.test_textmerge',
4209
 
        'breezy.tests.test_cethread',
4210
 
        'breezy.tests.test_timestamp',
4211
 
        'breezy.tests.test_trace',
4212
 
        'breezy.tests.test_transactions',
4213
 
        'breezy.tests.test_transform',
4214
 
        'breezy.tests.test_transport',
4215
 
        'breezy.tests.test_transport_log',
4216
 
        'breezy.tests.test_tree',
4217
 
        'breezy.tests.test_treebuilder',
4218
 
        'breezy.tests.test_treeshape',
4219
 
        'breezy.tests.test_tsort',
4220
 
        'breezy.tests.test_tuned_gzip',
4221
 
        'breezy.tests.test_ui',
4222
 
        'breezy.tests.test_uncommit',
4223
 
        'breezy.tests.test_upgrade',
4224
 
        'breezy.tests.test_upgrade_stacked',
4225
 
        'breezy.tests.test_upstream_import',
4226
 
        'breezy.tests.test_urlutils',
4227
 
        'breezy.tests.test_utextwrap',
4228
 
        'breezy.tests.test_version',
4229
 
        'breezy.tests.test_version_info',
4230
 
        'breezy.tests.test_versionedfile',
4231
 
        'breezy.tests.test_vf_search',
4232
 
        'breezy.tests.test_views',
4233
 
        'breezy.tests.test_weave',
4234
 
        'breezy.tests.test_whitebox',
4235
 
        'breezy.tests.test_win32utils',
4236
 
        'breezy.tests.test_workingtree',
4237
 
        'breezy.tests.test_workingtree_4',
4238
 
        'breezy.tests.test_wsgi',
4239
 
        'breezy.tests.test_xml',
 
3576
        'bzrlib.doc',
 
3577
        'bzrlib.tests.blackbox',
 
3578
        'bzrlib.tests.commands',
 
3579
        'bzrlib.tests.per_branch',
 
3580
        'bzrlib.tests.per_bzrdir',
 
3581
        'bzrlib.tests.per_foreign_vcs',
 
3582
        'bzrlib.tests.per_interrepository',
 
3583
        'bzrlib.tests.per_intertree',
 
3584
        'bzrlib.tests.per_inventory',
 
3585
        'bzrlib.tests.per_interbranch',
 
3586
        'bzrlib.tests.per_lock',
 
3587
        'bzrlib.tests.per_merger',
 
3588
        'bzrlib.tests.per_transport',
 
3589
        'bzrlib.tests.per_tree',
 
3590
        'bzrlib.tests.per_pack_repository',
 
3591
        'bzrlib.tests.per_repository',
 
3592
        'bzrlib.tests.per_repository_chk',
 
3593
        'bzrlib.tests.per_repository_reference',
 
3594
        'bzrlib.tests.per_uifactory',
 
3595
        'bzrlib.tests.per_versionedfile',
 
3596
        'bzrlib.tests.per_workingtree',
 
3597
        'bzrlib.tests.test__annotator',
 
3598
        'bzrlib.tests.test__bencode',
 
3599
        'bzrlib.tests.test__chk_map',
 
3600
        'bzrlib.tests.test__dirstate_helpers',
 
3601
        'bzrlib.tests.test__groupcompress',
 
3602
        'bzrlib.tests.test__known_graph',
 
3603
        'bzrlib.tests.test__rio',
 
3604
        'bzrlib.tests.test__simple_set',
 
3605
        'bzrlib.tests.test__static_tuple',
 
3606
        'bzrlib.tests.test__walkdirs_win32',
 
3607
        'bzrlib.tests.test_ancestry',
 
3608
        'bzrlib.tests.test_annotate',
 
3609
        'bzrlib.tests.test_api',
 
3610
        'bzrlib.tests.test_atomicfile',
 
3611
        'bzrlib.tests.test_bad_files',
 
3612
        'bzrlib.tests.test_bisect_multi',
 
3613
        'bzrlib.tests.test_branch',
 
3614
        'bzrlib.tests.test_branchbuilder',
 
3615
        'bzrlib.tests.test_btree_index',
 
3616
        'bzrlib.tests.test_bugtracker',
 
3617
        'bzrlib.tests.test_bundle',
 
3618
        'bzrlib.tests.test_bzrdir',
 
3619
        'bzrlib.tests.test__chunks_to_lines',
 
3620
        'bzrlib.tests.test_cache_utf8',
 
3621
        'bzrlib.tests.test_chk_map',
 
3622
        'bzrlib.tests.test_chk_serializer',
 
3623
        'bzrlib.tests.test_chunk_writer',
 
3624
        'bzrlib.tests.test_clean_tree',
 
3625
        'bzrlib.tests.test_cleanup',
 
3626
        'bzrlib.tests.test_commands',
 
3627
        'bzrlib.tests.test_commit',
 
3628
        'bzrlib.tests.test_commit_merge',
 
3629
        'bzrlib.tests.test_config',
 
3630
        'bzrlib.tests.test_conflicts',
 
3631
        'bzrlib.tests.test_counted_lock',
 
3632
        'bzrlib.tests.test_crash',
 
3633
        'bzrlib.tests.test_decorators',
 
3634
        'bzrlib.tests.test_delta',
 
3635
        'bzrlib.tests.test_debug',
 
3636
        'bzrlib.tests.test_deprecated_graph',
 
3637
        'bzrlib.tests.test_diff',
 
3638
        'bzrlib.tests.test_directory_service',
 
3639
        'bzrlib.tests.test_dirstate',
 
3640
        'bzrlib.tests.test_email_message',
 
3641
        'bzrlib.tests.test_eol_filters',
 
3642
        'bzrlib.tests.test_errors',
 
3643
        'bzrlib.tests.test_export',
 
3644
        'bzrlib.tests.test_extract',
 
3645
        'bzrlib.tests.test_fetch',
 
3646
        'bzrlib.tests.test_fifo_cache',
 
3647
        'bzrlib.tests.test_filters',
 
3648
        'bzrlib.tests.test_ftp_transport',
 
3649
        'bzrlib.tests.test_foreign',
 
3650
        'bzrlib.tests.test_generate_docs',
 
3651
        'bzrlib.tests.test_generate_ids',
 
3652
        'bzrlib.tests.test_globbing',
 
3653
        'bzrlib.tests.test_gpg',
 
3654
        'bzrlib.tests.test_graph',
 
3655
        'bzrlib.tests.test_groupcompress',
 
3656
        'bzrlib.tests.test_hashcache',
 
3657
        'bzrlib.tests.test_help',
 
3658
        'bzrlib.tests.test_hooks',
 
3659
        'bzrlib.tests.test_http',
 
3660
        'bzrlib.tests.test_http_response',
 
3661
        'bzrlib.tests.test_https_ca_bundle',
 
3662
        'bzrlib.tests.test_identitymap',
 
3663
        'bzrlib.tests.test_ignores',
 
3664
        'bzrlib.tests.test_index',
 
3665
        'bzrlib.tests.test_import_tariff',
 
3666
        'bzrlib.tests.test_info',
 
3667
        'bzrlib.tests.test_inv',
 
3668
        'bzrlib.tests.test_inventory_delta',
 
3669
        'bzrlib.tests.test_knit',
 
3670
        'bzrlib.tests.test_lazy_import',
 
3671
        'bzrlib.tests.test_lazy_regex',
 
3672
        'bzrlib.tests.test_lock',
 
3673
        'bzrlib.tests.test_lockable_files',
 
3674
        'bzrlib.tests.test_lockdir',
 
3675
        'bzrlib.tests.test_log',
 
3676
        'bzrlib.tests.test_lru_cache',
 
3677
        'bzrlib.tests.test_lsprof',
 
3678
        'bzrlib.tests.test_mail_client',
 
3679
        'bzrlib.tests.test_memorytree',
 
3680
        'bzrlib.tests.test_merge',
 
3681
        'bzrlib.tests.test_merge3',
 
3682
        'bzrlib.tests.test_merge_core',
 
3683
        'bzrlib.tests.test_merge_directive',
 
3684
        'bzrlib.tests.test_missing',
 
3685
        'bzrlib.tests.test_msgeditor',
 
3686
        'bzrlib.tests.test_multiparent',
 
3687
        'bzrlib.tests.test_mutabletree',
 
3688
        'bzrlib.tests.test_nonascii',
 
3689
        'bzrlib.tests.test_options',
 
3690
        'bzrlib.tests.test_osutils',
 
3691
        'bzrlib.tests.test_osutils_encodings',
 
3692
        'bzrlib.tests.test_pack',
 
3693
        'bzrlib.tests.test_patch',
 
3694
        'bzrlib.tests.test_patches',
 
3695
        'bzrlib.tests.test_permissions',
 
3696
        'bzrlib.tests.test_plugins',
 
3697
        'bzrlib.tests.test_progress',
 
3698
        'bzrlib.tests.test_read_bundle',
 
3699
        'bzrlib.tests.test_reconcile',
 
3700
        'bzrlib.tests.test_reconfigure',
 
3701
        'bzrlib.tests.test_registry',
 
3702
        'bzrlib.tests.test_remote',
 
3703
        'bzrlib.tests.test_rename_map',
 
3704
        'bzrlib.tests.test_repository',
 
3705
        'bzrlib.tests.test_revert',
 
3706
        'bzrlib.tests.test_revision',
 
3707
        'bzrlib.tests.test_revisionspec',
 
3708
        'bzrlib.tests.test_revisiontree',
 
3709
        'bzrlib.tests.test_rio',
 
3710
        'bzrlib.tests.test_rules',
 
3711
        'bzrlib.tests.test_sampler',
 
3712
        'bzrlib.tests.test_script',
 
3713
        'bzrlib.tests.test_selftest',
 
3714
        'bzrlib.tests.test_serializer',
 
3715
        'bzrlib.tests.test_setup',
 
3716
        'bzrlib.tests.test_sftp_transport',
 
3717
        'bzrlib.tests.test_shelf',
 
3718
        'bzrlib.tests.test_shelf_ui',
 
3719
        'bzrlib.tests.test_smart',
 
3720
        'bzrlib.tests.test_smart_add',
 
3721
        'bzrlib.tests.test_smart_request',
 
3722
        'bzrlib.tests.test_smart_transport',
 
3723
        'bzrlib.tests.test_smtp_connection',
 
3724
        'bzrlib.tests.test_source',
 
3725
        'bzrlib.tests.test_ssh_transport',
 
3726
        'bzrlib.tests.test_status',
 
3727
        'bzrlib.tests.test_store',
 
3728
        'bzrlib.tests.test_strace',
 
3729
        'bzrlib.tests.test_subsume',
 
3730
        'bzrlib.tests.test_switch',
 
3731
        'bzrlib.tests.test_symbol_versioning',
 
3732
        'bzrlib.tests.test_tag',
 
3733
        'bzrlib.tests.test_testament',
 
3734
        'bzrlib.tests.test_textfile',
 
3735
        'bzrlib.tests.test_textmerge',
 
3736
        'bzrlib.tests.test_timestamp',
 
3737
        'bzrlib.tests.test_trace',
 
3738
        'bzrlib.tests.test_transactions',
 
3739
        'bzrlib.tests.test_transform',
 
3740
        'bzrlib.tests.test_transport',
 
3741
        'bzrlib.tests.test_transport_log',
 
3742
        'bzrlib.tests.test_tree',
 
3743
        'bzrlib.tests.test_treebuilder',
 
3744
        'bzrlib.tests.test_tsort',
 
3745
        'bzrlib.tests.test_tuned_gzip',
 
3746
        'bzrlib.tests.test_ui',
 
3747
        'bzrlib.tests.test_uncommit',
 
3748
        'bzrlib.tests.test_upgrade',
 
3749
        'bzrlib.tests.test_upgrade_stacked',
 
3750
        'bzrlib.tests.test_urlutils',
 
3751
        'bzrlib.tests.test_version',
 
3752
        'bzrlib.tests.test_version_info',
 
3753
        'bzrlib.tests.test_weave',
 
3754
        'bzrlib.tests.test_whitebox',
 
3755
        'bzrlib.tests.test_win32utils',
 
3756
        'bzrlib.tests.test_workingtree',
 
3757
        'bzrlib.tests.test_workingtree_4',
 
3758
        'bzrlib.tests.test_wsgi',
 
3759
        'bzrlib.tests.test_xml',
4240
3760
        ]
4241
3761
 
4242
3762
 
4243
3763
def _test_suite_modules_to_doctest():
4244
 
    """Return the list of modules to doctest."""
4245
 
    if __doc__ is None:
4246
 
        # GZ 2009-03-31: No docstrings with -OO so there's nothing to doctest
4247
 
        return []
 
3764
    """Return the list of modules to doctest."""   
4248
3765
    return [
4249
 
        'breezy',
4250
 
        'breezy.branchbuilder',
4251
 
        'breezy.bzr.inventory',
4252
 
        'breezy.decorators',
4253
 
        'breezy.iterablefile',
4254
 
        'breezy.lockdir',
4255
 
        'breezy.merge3',
4256
 
        'breezy.option',
4257
 
        'breezy.pyutils',
4258
 
        'breezy.symbol_versioning',
4259
 
        'breezy.tests',
4260
 
        'breezy.tests.fixtures',
4261
 
        'breezy.timestamp',
4262
 
        'breezy.transport.http',
4263
 
        'breezy.version_info_formats.format_custom',
 
3766
        'bzrlib',
 
3767
        'bzrlib.branchbuilder',
 
3768
        'bzrlib.decorators',
 
3769
        'bzrlib.export',
 
3770
        'bzrlib.inventory',
 
3771
        'bzrlib.iterablefile',
 
3772
        'bzrlib.lockdir',
 
3773
        'bzrlib.merge3',
 
3774
        'bzrlib.option',
 
3775
        'bzrlib.symbol_versioning',
 
3776
        'bzrlib.tests',
 
3777
        'bzrlib.timestamp',
 
3778
        'bzrlib.version_info_formats.format_custom',
4264
3779
        ]
4265
3780
 
4266
3781
 
4267
3782
def test_suite(keep_only=None, starting_with=None):
4268
 
    """Build and return TestSuite for the whole of breezy.
 
3783
    """Build and return TestSuite for the whole of bzrlib.
4269
3784
 
4270
3785
    :param keep_only: A list of test ids limiting the suite returned.
4271
3786
 
4285
3800
        # both options means we will load less tests for the same final result.
4286
3801
        def interesting_module(name):
4287
3802
            for start in starting_with:
4288
 
                # Either the module name starts with the specified string
4289
 
                # or it may contain tests starting with the specified string
4290
 
                if name.startswith(start) or start.startswith(name):
 
3803
                if (
 
3804
                    # Either the module name starts with the specified string
 
3805
                    name.startswith(start)
 
3806
                    # or it may contain tests starting with the specified string
 
3807
                    or start.startswith(name)
 
3808
                    ):
4291
3809
                    return True
4292
3810
            return False
4293
3811
        loader = TestUtil.FilteredByModuleTestLoader(interesting_module)
4294
3812
 
4295
3813
    elif keep_only is not None:
4296
3814
        loader = TestUtil.FilteredByModuleTestLoader(id_filter.refers_to)
4297
 
 
4298
3815
        def interesting_module(name):
4299
3816
            return id_filter.refers_to(name)
4300
3817
 
4301
3818
    else:
4302
3819
        loader = TestUtil.TestLoader()
4303
 
 
4304
3820
        def interesting_module(name):
4305
3821
            # No filtering, all modules are interesting
4306
3822
            return True
4310
3826
    # modules building their suite with loadTestsFromModuleNames
4311
3827
    suite.addTest(loader.loadTestsFromModuleNames(_test_suite_testmod_names()))
4312
3828
 
4313
 
    if not PY3:
4314
 
        suite.addTest(loader.loadTestsFromModuleNames(['breezy.doc']))
4315
 
 
4316
 
        # It's pretty much impossible to write readable doctests that work on
4317
 
        # both Python 2 and Python 3 because of their overreliance on
4318
 
        # consistent repr() return values.
4319
 
        # For now, just run doctests on Python 2 so we now they haven't broken.
4320
 
        for mod in _test_suite_modules_to_doctest():
4321
 
            if not interesting_module(mod):
4322
 
                # No tests to keep here, move along
4323
 
                continue
4324
 
            try:
4325
 
                # note that this really does mean "report only" -- doctest
4326
 
                # still runs the rest of the examples
4327
 
                doc_suite = IsolatedDocTestSuite(
4328
 
                    mod, optionflags=doctest.REPORT_ONLY_FIRST_FAILURE)
4329
 
            except ValueError as e:
4330
 
                print('**failed to get doctest for: %s\n%s' % (mod, e))
4331
 
                raise
4332
 
            if len(doc_suite._tests) == 0:
4333
 
                raise errors.BzrError("no doctests found in %s" % (mod,))
4334
 
            suite.addTest(doc_suite)
 
3829
    for mod in _test_suite_modules_to_doctest():
 
3830
        if not interesting_module(mod):
 
3831
            # No tests to keep here, move along
 
3832
            continue
 
3833
        try:
 
3834
            # note that this really does mean "report only" -- doctest
 
3835
            # still runs the rest of the examples
 
3836
            doc_suite = doctest.DocTestSuite(mod,
 
3837
                optionflags=doctest.REPORT_ONLY_FIRST_FAILURE)
 
3838
        except ValueError, e:
 
3839
            print '**failed to get doctest for: %s\n%s' % (mod, e)
 
3840
            raise
 
3841
        if len(doc_suite._tests) == 0:
 
3842
            raise errors.BzrError("no doctests found in %s" % (mod,))
 
3843
        suite.addTest(doc_suite)
4335
3844
 
4336
3845
    default_encoding = sys.getdefaultencoding()
4337
 
    for name, plugin in _mod_plugin.plugins().items():
 
3846
    for name, plugin in bzrlib.plugin.plugins().items():
4338
3847
        if not interesting_module(plugin.module.__name__):
4339
3848
            continue
4340
3849
        plugin_suite = plugin.test_suite()
4346
3855
        if plugin_suite is not None:
4347
3856
            suite.addTest(plugin_suite)
4348
3857
        if default_encoding != sys.getdefaultencoding():
4349
 
            trace.warning(
 
3858
            bzrlib.trace.warning(
4350
3859
                'Plugin "%s" tried to reset default encoding to: %s', name,
4351
3860
                sys.getdefaultencoding())
4352
3861
            reload(sys)
4367
3876
            # Some tests mentioned in the list are not in the test suite. The
4368
3877
            # list may be out of date, report to the tester.
4369
3878
            for id in not_found:
4370
 
                trace.warning('"%s" not found in the test suite', id)
 
3879
                bzrlib.trace.warning('"%s" not found in the test suite', id)
4371
3880
        for id in duplicates:
4372
 
            trace.warning('"%s" is used as an id by several tests', id)
 
3881
            bzrlib.trace.warning('"%s" is used as an id by several tests', id)
4373
3882
 
4374
3883
    return suite
4375
3884
 
4376
3885
 
4377
 
def multiply_scenarios(*scenarios):
4378
 
    """Multiply two or more iterables of scenarios.
4379
 
 
4380
 
    It is safe to pass scenario generators or iterators.
4381
 
 
4382
 
    :returns: A list of compound scenarios: the cross-product of all
4383
 
        scenarios, with the names concatenated and the parameters
4384
 
        merged together.
4385
 
    """
4386
 
    return functools.reduce(_multiply_two_scenarios, map(list, scenarios))
4387
 
 
4388
 
 
4389
 
def _multiply_two_scenarios(scenarios_left, scenarios_right):
 
3886
def multiply_scenarios(scenarios_left, scenarios_right):
4390
3887
    """Multiply two sets of scenarios.
4391
3888
 
4392
3889
    :returns: the cartesian product of the two sets of scenarios, that is
4395
3892
    """
4396
3893
    return [
4397
3894
        ('%s,%s' % (left_name, right_name),
4398
 
         dict(left_dict, **right_dict))
 
3895
         dict(left_dict.items() + right_dict.items()))
4399
3896
        for left_name, left_dict in scenarios_left
4400
3897
        for right_name, right_dict in scenarios_right]
4401
3898
 
4418
3915
    the scenario name at the end of its id(), and updating the test object's
4419
3916
    __dict__ with the scenario_param_dict.
4420
3917
 
4421
 
    >>> import breezy.tests.test_sampler
 
3918
    >>> import bzrlib.tests.test_sampler
4422
3919
    >>> r = multiply_tests(
4423
 
    ...     breezy.tests.test_sampler.DemoTest('test_nothing'),
 
3920
    ...     bzrlib.tests.test_sampler.DemoTest('test_nothing'),
4424
3921
    ...     [('one', dict(param=1)),
4425
3922
    ...      ('two', dict(param=2))],
4426
 
    ...     TestUtil.TestSuite())
 
3923
    ...     TestSuite())
4427
3924
    >>> tests = list(iter_suite_tests(r))
4428
3925
    >>> len(tests)
4429
3926
    2
4430
3927
    >>> tests[0].id()
4431
 
    'breezy.tests.test_sampler.DemoTest.test_nothing(one)'
 
3928
    'bzrlib.tests.test_sampler.DemoTest.test_nothing(one)'
4432
3929
    >>> tests[0].param
4433
3930
    1
4434
3931
    >>> tests[1].param
4456
3953
    """Copy test and apply scenario to it.
4457
3954
 
4458
3955
    :param test: A test to adapt.
4459
 
    :param scenario: A tuple describing the scenario.
 
3956
    :param scenario: A tuple describing the scenarion.
4460
3957
        The first element of the tuple is the new test id.
4461
3958
        The second element is a dict containing attributes to set on the
4462
3959
        test.
4476
3973
    :param new_id: The id to assign to it.
4477
3974
    :return: The new test.
4478
3975
    """
4479
 
    new_test = copy.copy(test)
 
3976
    new_test = copy(test)
4480
3977
    new_test.id = lambda: new_id
4481
 
    # XXX: Workaround <https://bugs.launchpad.net/testtools/+bug/637725>, which
4482
 
    # causes cloned tests to share the 'details' dict.  This makes it hard to
4483
 
    # read the test output for parameterized tests, because tracebacks will be
4484
 
    # associated with irrelevant tests.
4485
 
    try:
4486
 
        details = new_test._TestCase__details
4487
 
    except AttributeError:
4488
 
        # must be a different version of testtools than expected.  Do nothing.
4489
 
        pass
4490
 
    else:
4491
 
        # Reset the '__details' dict.
4492
 
        new_test._TestCase__details = {}
4493
3978
    return new_test
4494
3979
 
4495
3980
 
4500
3985
    This is meant to be used inside a modules 'load_tests()' function. It will
4501
3986
    create 2 scenarios, and cause all tests in the 'standard_tests' to be run
4502
3987
    against both implementations. Setting 'test.module' to the appropriate
4503
 
    module. See breezy.tests.test__chk_map.load_tests as an example.
 
3988
    module. See bzrlib.tests.test__chk_map.load_tests as an example.
4504
3989
 
4505
3990
    :param standard_tests: A test suite to permute
4506
3991
    :param loader: A TestLoader
4507
3992
    :param py_module_name: The python path to a python module that can always
4508
3993
        be loaded, and will be considered the 'python' implementation. (eg
4509
 
        'breezy._chk_map_py')
 
3994
        'bzrlib._chk_map_py')
4510
3995
    :param ext_module_name: The python path to an extension module. If the
4511
3996
        module cannot be loaded, a single test will be added, which notes that
4512
3997
        the module is not available. If it can be loaded, all standard_tests
4516
4001
        the module is available.
4517
4002
    """
4518
4003
 
4519
 
    from .features import ModuleAvailableFeature
4520
 
    py_module = pyutils.get_named_object(py_module_name)
 
4004
    py_module = __import__(py_module_name, {}, {}, ['NO_SUCH_ATTRIB'])
4521
4005
    scenarios = [
4522
4006
        ('python', {'module': py_module}),
4523
4007
    ]
4542
4026
    # except on win32, where rmtree(str) will fail
4543
4027
    # since it doesn't have the property of byte-stream paths
4544
4028
    # (they are either ascii or mbcs)
4545
 
    if sys.platform == 'win32' and isinstance(dirname, bytes):
 
4029
    if sys.platform == 'win32':
4546
4030
        # make sure we are using the unicode win32 api
4547
 
        dirname = dirname.decode('mbcs')
 
4031
        dirname = unicode(dirname)
4548
4032
    else:
4549
4033
        dirname = dirname.encode(sys.getfilesystemencoding())
4550
4034
    try:
4551
4035
        osutils.rmtree(dirname)
4552
 
    except OSError as e:
 
4036
    except OSError, e:
4553
4037
        # We don't want to fail here because some useful display will be lost
4554
4038
        # otherwise. Polluting the tmp dir is bad, but not giving all the
4555
4039
        # possible info to the test runner is even worse.
4556
 
        if test_id is not None:
 
4040
        if test_id != None:
4557
4041
            ui.ui_factory.clear_term()
4558
4042
            sys.stderr.write('\nWhile running: %s\n' % (test_id,))
4559
 
        # Ugly, but the last thing we want here is fail, so bear with it.
4560
 
        printable_e = str(e).decode(osutils.get_user_encoding(), 'replace'
4561
 
                                    ).encode('ascii', 'replace')
4562
4043
        sys.stderr.write('Unable to remove testing dir %s\n%s'
4563
 
                         % (os.path.basename(dirname), printable_e))
 
4044
                         % (os.path.basename(dirname), e))
 
4045
 
 
4046
 
 
4047
class Feature(object):
 
4048
    """An operating system Feature."""
 
4049
 
 
4050
    def __init__(self):
 
4051
        self._available = None
 
4052
 
 
4053
    def available(self):
 
4054
        """Is the feature available?
 
4055
 
 
4056
        :return: True if the feature is available.
 
4057
        """
 
4058
        if self._available is None:
 
4059
            self._available = self._probe()
 
4060
        return self._available
 
4061
 
 
4062
    def _probe(self):
 
4063
        """Implement this method in concrete features.
 
4064
 
 
4065
        :return: True if the feature is available.
 
4066
        """
 
4067
        raise NotImplementedError
 
4068
 
 
4069
    def __str__(self):
 
4070
        if getattr(self, 'feature_name', None):
 
4071
            return self.feature_name()
 
4072
        return self.__class__.__name__
 
4073
 
 
4074
 
 
4075
class _SymlinkFeature(Feature):
 
4076
 
 
4077
    def _probe(self):
 
4078
        return osutils.has_symlinks()
 
4079
 
 
4080
    def feature_name(self):
 
4081
        return 'symlinks'
 
4082
 
 
4083
SymlinkFeature = _SymlinkFeature()
 
4084
 
 
4085
 
 
4086
class _HardlinkFeature(Feature):
 
4087
 
 
4088
    def _probe(self):
 
4089
        return osutils.has_hardlinks()
 
4090
 
 
4091
    def feature_name(self):
 
4092
        return 'hardlinks'
 
4093
 
 
4094
HardlinkFeature = _HardlinkFeature()
 
4095
 
 
4096
 
 
4097
class _OsFifoFeature(Feature):
 
4098
 
 
4099
    def _probe(self):
 
4100
        return getattr(os, 'mkfifo', None)
 
4101
 
 
4102
    def feature_name(self):
 
4103
        return 'filesystem fifos'
 
4104
 
 
4105
OsFifoFeature = _OsFifoFeature()
 
4106
 
 
4107
 
 
4108
class _UnicodeFilenameFeature(Feature):
 
4109
    """Does the filesystem support Unicode filenames?"""
 
4110
 
 
4111
    def _probe(self):
 
4112
        try:
 
4113
            # Check for character combinations unlikely to be covered by any
 
4114
            # single non-unicode encoding. We use the characters
 
4115
            # - greek small letter alpha (U+03B1) and
 
4116
            # - braille pattern dots-123456 (U+283F).
 
4117
            os.stat(u'\u03b1\u283f')
 
4118
        except UnicodeEncodeError:
 
4119
            return False
 
4120
        except (IOError, OSError):
 
4121
            # The filesystem allows the Unicode filename but the file doesn't
 
4122
            # exist.
 
4123
            return True
 
4124
        else:
 
4125
            # The filesystem allows the Unicode filename and the file exists,
 
4126
            # for some reason.
 
4127
            return True
 
4128
 
 
4129
UnicodeFilenameFeature = _UnicodeFilenameFeature()
 
4130
 
 
4131
 
 
4132
class _CompatabilityThunkFeature(Feature):
 
4133
    """This feature is just a thunk to another feature.
 
4134
 
 
4135
    It issues a deprecation warning if it is accessed, to let you know that you
 
4136
    should really use a different feature.
 
4137
    """
 
4138
 
 
4139
    def __init__(self, dep_version, module, name,
 
4140
                 replacement_name, replacement_module=None):
 
4141
        super(_CompatabilityThunkFeature, self).__init__()
 
4142
        self._module = module
 
4143
        if replacement_module is None:
 
4144
            replacement_module = module
 
4145
        self._replacement_module = replacement_module
 
4146
        self._name = name
 
4147
        self._replacement_name = replacement_name
 
4148
        self._dep_version = dep_version
 
4149
        self._feature = None
 
4150
 
 
4151
    def _ensure(self):
 
4152
        if self._feature is None:
 
4153
            depr_msg = self._dep_version % ('%s.%s'
 
4154
                                            % (self._module, self._name))
 
4155
            use_msg = ' Use %s.%s instead.' % (self._replacement_module,
 
4156
                                               self._replacement_name)
 
4157
            symbol_versioning.warn(depr_msg + use_msg, DeprecationWarning)
 
4158
            # Import the new feature and use it as a replacement for the
 
4159
            # deprecated one.
 
4160
            mod = __import__(self._replacement_module, {}, {},
 
4161
                             [self._replacement_name])
 
4162
            self._feature = getattr(mod, self._replacement_name)
 
4163
 
 
4164
    def _probe(self):
 
4165
        self._ensure()
 
4166
        return self._feature._probe()
 
4167
 
 
4168
 
 
4169
class ModuleAvailableFeature(Feature):
 
4170
    """This is a feature than describes a module we want to be available.
 
4171
 
 
4172
    Declare the name of the module in __init__(), and then after probing, the
 
4173
    module will be available as 'self.module'.
 
4174
 
 
4175
    :ivar module: The module if it is available, else None.
 
4176
    """
 
4177
 
 
4178
    def __init__(self, module_name):
 
4179
        super(ModuleAvailableFeature, self).__init__()
 
4180
        self.module_name = module_name
 
4181
 
 
4182
    def _probe(self):
 
4183
        try:
 
4184
            self._module = __import__(self.module_name, {}, {}, [''])
 
4185
            return True
 
4186
        except ImportError:
 
4187
            return False
 
4188
 
 
4189
    @property
 
4190
    def module(self):
 
4191
        if self.available(): # Make sure the probe has been done
 
4192
            return self._module
 
4193
        return None
 
4194
 
 
4195
    def feature_name(self):
 
4196
        return self.module_name
 
4197
 
 
4198
 
 
4199
# This is kept here for compatibility, it is recommended to use
 
4200
# 'bzrlib.tests.feature.paramiko' instead
 
4201
ParamikoFeature = _CompatabilityThunkFeature(
 
4202
    deprecated_in((2,1,0)),
 
4203
    'bzrlib.tests.features', 'ParamikoFeature', 'paramiko')
4564
4204
 
4565
4205
 
4566
4206
def probe_unicode_in_user_encoding():
4587
4227
    Return None if all non-ascii characters is valid
4588
4228
    for given encoding.
4589
4229
    """
4590
 
    for i in range(128, 256):
4591
 
        char = int2byte(i)
 
4230
    for i in xrange(128, 256):
 
4231
        char = chr(i)
4592
4232
        try:
4593
4233
            char.decode(encoding)
4594
4234
        except UnicodeDecodeError:
4596
4236
    return None
4597
4237
 
4598
4238
 
 
4239
class _HTTPSServerFeature(Feature):
 
4240
    """Some tests want an https Server, check if one is available.
 
4241
 
 
4242
    Right now, the only way this is available is under python2.6 which provides
 
4243
    an ssl module.
 
4244
    """
 
4245
 
 
4246
    def _probe(self):
 
4247
        try:
 
4248
            import ssl
 
4249
            return True
 
4250
        except ImportError:
 
4251
            return False
 
4252
 
 
4253
    def feature_name(self):
 
4254
        return 'HTTPSServer'
 
4255
 
 
4256
 
 
4257
HTTPSServerFeature = _HTTPSServerFeature()
 
4258
 
 
4259
 
 
4260
class _UnicodeFilename(Feature):
 
4261
    """Does the filesystem support Unicode filenames?"""
 
4262
 
 
4263
    def _probe(self):
 
4264
        try:
 
4265
            os.stat(u'\u03b1')
 
4266
        except UnicodeEncodeError:
 
4267
            return False
 
4268
        except (IOError, OSError):
 
4269
            # The filesystem allows the Unicode filename but the file doesn't
 
4270
            # exist.
 
4271
            return True
 
4272
        else:
 
4273
            # The filesystem allows the Unicode filename and the file exists,
 
4274
            # for some reason.
 
4275
            return True
 
4276
 
 
4277
UnicodeFilename = _UnicodeFilename()
 
4278
 
 
4279
 
 
4280
class _UTF8Filesystem(Feature):
 
4281
    """Is the filesystem UTF-8?"""
 
4282
 
 
4283
    def _probe(self):
 
4284
        if osutils._fs_enc.upper() in ('UTF-8', 'UTF8'):
 
4285
            return True
 
4286
        return False
 
4287
 
 
4288
UTF8Filesystem = _UTF8Filesystem()
 
4289
 
 
4290
 
 
4291
class _BreakinFeature(Feature):
 
4292
    """Does this platform support the breakin feature?"""
 
4293
 
 
4294
    def _probe(self):
 
4295
        from bzrlib import breakin
 
4296
        if breakin.determine_signal() is None:
 
4297
            return False
 
4298
        if sys.platform == 'win32':
 
4299
            # Windows doesn't have os.kill, and we catch the SIGBREAK signal.
 
4300
            # We trigger SIGBREAK via a Console api so we need ctypes to
 
4301
            # access the function
 
4302
            try:
 
4303
                import ctypes
 
4304
            except OSError:
 
4305
                return False
 
4306
        return True
 
4307
 
 
4308
    def feature_name(self):
 
4309
        return "SIGQUIT or SIGBREAK w/ctypes on win32"
 
4310
 
 
4311
 
 
4312
BreakinFeature = _BreakinFeature()
 
4313
 
 
4314
 
 
4315
class _CaseInsCasePresFilenameFeature(Feature):
 
4316
    """Is the file-system case insensitive, but case-preserving?"""
 
4317
 
 
4318
    def _probe(self):
 
4319
        fileno, name = tempfile.mkstemp(prefix='MixedCase')
 
4320
        try:
 
4321
            # first check truly case-preserving for created files, then check
 
4322
            # case insensitive when opening existing files.
 
4323
            name = osutils.normpath(name)
 
4324
            base, rel = osutils.split(name)
 
4325
            found_rel = osutils.canonical_relpath(base, name)
 
4326
            return (found_rel == rel
 
4327
                    and os.path.isfile(name.upper())
 
4328
                    and os.path.isfile(name.lower()))
 
4329
        finally:
 
4330
            os.close(fileno)
 
4331
            os.remove(name)
 
4332
 
 
4333
    def feature_name(self):
 
4334
        return "case-insensitive case-preserving filesystem"
 
4335
 
 
4336
CaseInsCasePresFilenameFeature = _CaseInsCasePresFilenameFeature()
 
4337
 
 
4338
 
 
4339
class _CaseInsensitiveFilesystemFeature(Feature):
 
4340
    """Check if underlying filesystem is case-insensitive but *not* case
 
4341
    preserving.
 
4342
    """
 
4343
    # Note that on Windows, Cygwin, MacOS etc, the file-systems are far
 
4344
    # more likely to be case preserving, so this case is rare.
 
4345
 
 
4346
    def _probe(self):
 
4347
        if CaseInsCasePresFilenameFeature.available():
 
4348
            return False
 
4349
 
 
4350
        if TestCaseWithMemoryTransport.TEST_ROOT is None:
 
4351
            root = osutils.mkdtemp(prefix='testbzr-', suffix='.tmp')
 
4352
            TestCaseWithMemoryTransport.TEST_ROOT = root
 
4353
        else:
 
4354
            root = TestCaseWithMemoryTransport.TEST_ROOT
 
4355
        tdir = osutils.mkdtemp(prefix='case-sensitive-probe-', suffix='',
 
4356
            dir=root)
 
4357
        name_a = osutils.pathjoin(tdir, 'a')
 
4358
        name_A = osutils.pathjoin(tdir, 'A')
 
4359
        os.mkdir(name_a)
 
4360
        result = osutils.isdir(name_A)
 
4361
        _rmtree_temp_dir(tdir)
 
4362
        return result
 
4363
 
 
4364
    def feature_name(self):
 
4365
        return 'case-insensitive filesystem'
 
4366
 
 
4367
CaseInsensitiveFilesystemFeature = _CaseInsensitiveFilesystemFeature()
 
4368
 
 
4369
 
 
4370
# Kept for compatibility, use bzrlib.tests.features.subunit instead
 
4371
SubUnitFeature = _CompatabilityThunkFeature(
 
4372
    deprecated_in((2,1,0)),
 
4373
    'bzrlib.tests.features', 'SubUnitFeature', 'subunit')
4599
4374
# Only define SubUnitBzrRunner if subunit is available.
4600
4375
try:
4601
4376
    from subunit import TestProtocolClient
4602
4377
    from subunit.test_results import AutoTimingTestResultDecorator
4603
 
 
4604
 
    class SubUnitBzrProtocolClientv1(TestProtocolClient):
4605
 
 
4606
 
        def stopTest(self, test):
4607
 
            super(SubUnitBzrProtocolClientv1, self).stopTest(test)
4608
 
            _clear__type_equality_funcs(test)
4609
 
 
4610
 
        def addSuccess(self, test, details=None):
4611
 
            # The subunit client always includes the details in the subunit
4612
 
            # stream, but we don't want to include it in ours.
4613
 
            if details is not None and 'log' in details:
4614
 
                del details['log']
4615
 
            return super(SubUnitBzrProtocolClientv1, self).addSuccess(
4616
 
                test, details)
4617
 
 
4618
 
    class SubUnitBzrRunnerv1(TextTestRunner):
4619
 
 
 
4378
    class SubUnitBzrRunner(TextTestRunner):
4620
4379
        def run(self, test):
4621
4380
            result = AutoTimingTestResultDecorator(
4622
 
                SubUnitBzrProtocolClientv1(self.stream))
 
4381
                TestProtocolClient(self.stream))
4623
4382
            test.run(result)
4624
4383
            return result
4625
4384
except ImportError:
4626
4385
    pass
4627
 
 
4628
 
 
4629
 
try:
4630
 
    from subunit.run import SubunitTestRunner
4631
 
 
4632
 
    class SubUnitBzrRunnerv2(TextTestRunner, SubunitTestRunner):
4633
 
 
4634
 
        def __init__(self, stream=sys.stderr, descriptions=0, verbosity=1,
4635
 
                     bench_history=None, strict=False, result_decorators=None):
4636
 
            TextTestRunner.__init__(
4637
 
                self, stream=stream,
4638
 
                descriptions=descriptions, verbosity=verbosity,
4639
 
                bench_history=bench_history, strict=strict,
4640
 
                result_decorators=result_decorators)
4641
 
            SubunitTestRunner.__init__(self, verbosity=verbosity,
4642
 
                                       stream=stream)
4643
 
 
4644
 
        run = SubunitTestRunner.run
4645
 
except ImportError:
4646
 
    pass