← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/__init__.py

Streamline _walkdirs_utf8 for utf8 file systems, reducing time to traverse a mozilla tree from 1s to .6 seconds. (Robert Collins)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/__init__.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007, 2008 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
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
 
18
18
# TODO: Perhaps there should be an API to find out if bzr running under the
28
28
 
29
29
import atexit
30
30
import codecs
31
 
from copy import copy
32
31
from cStringIO import StringIO
33
32
import difflib
34
33
import doctest
35
34
import errno
36
35
import logging
37
 
import math
38
36
import os
39
37
from pprint import pformat
40
38
import random
41
39
import re
42
40
import shlex
43
41
import stat
44
 
from subprocess import Popen, PIPE, STDOUT
 
42
from subprocess import Popen, PIPE
45
43
import sys
46
44
import tempfile
47
45
import threading
48
46
import time
49
 
import traceback
50
47
import unittest
51
48
import warnings
52
49
 
53
 
import testtools
54
 
# nb: check this before importing anything else from within it
55
 
_testtools_version = getattr(testtools, '__version__', ())
56
 
if _testtools_version < (0, 9, 2):
57
 
    raise ImportError("need at least testtools 0.9.2: %s is %r"
58
 
        % (testtools.__file__, _testtools_version))
59
 
from testtools import content
60
50
 
61
51
from bzrlib import (
62
52
    branchbuilder,
63
53
    bzrdir,
64
 
    chk_map,
65
 
    config,
66
54
    debug,
67
55
    errors,
68
 
    hooks,
69
 
    lock as _mod_lock,
70
56
    memorytree,
71
57
    osutils,
72
58
    progress,
90
76
from bzrlib.merge import merge_inner
91
77
import bzrlib.merge3
92
78
import bzrlib.plugin
93
 
from bzrlib.smart import client, request, server
94
79
import bzrlib.store
95
80
from bzrlib import symbol_versioning
96
81
from bzrlib.symbol_versioning import (
97
82
    DEPRECATED_PARAMETER,
98
83
    deprecated_function,
99
 
    deprecated_in,
100
84
    deprecated_method,
101
85
    deprecated_passed,
102
86
    )
103
87
import bzrlib.trace
104
 
from bzrlib.transport import (
105
 
    get_transport,
106
 
    memory,
107
 
    pathfilter,
108
 
    )
 
88
from bzrlib.transport import get_transport
109
89
import bzrlib.transport
 
90
from bzrlib.transport.local import LocalURLServer
 
91
from bzrlib.transport.memory import MemoryServer
 
92
from bzrlib.transport.readonly import ReadonlyServer
110
93
from bzrlib.trace import mutter, note
111
 
from bzrlib.tests import (
112
 
    test_server,
113
 
    TestUtil,
114
 
    )
 
94
from bzrlib.tests import TestUtil
115
95
from bzrlib.tests.http_server import HttpServer
116
96
from bzrlib.tests.TestUtil import (
117
97
                          TestSuite,
118
98
                          TestLoader,
119
99
                          )
120
100
from bzrlib.tests.treeshape import build_tree_contents
121
 
from bzrlib.ui import NullProgressView
122
 
from bzrlib.ui.text import TextUIFactory
123
101
import bzrlib.version_info_formats.format_custom
124
102
from bzrlib.workingtree import WorkingTree, WorkingTreeFormat2
125
103
 
128
106
# shown frame is the test code, not our assertXYZ.
129
107
__unittest = 1
130
108
 
131
 
default_transport = test_server.LocalURLServer
132
 
 
133
 
 
134
 
_unitialized_attr = object()
135
 
"""A sentinel needed to act as a default value in a method signature."""
136
 
 
137
 
 
138
 
# Subunit result codes, defined here to prevent a hard dependency on subunit.
139
 
SUBUNIT_SEEK_SET = 0
140
 
SUBUNIT_SEEK_CUR = 1
 
109
default_transport = LocalURLServer
141
110
 
142
111
 
143
112
class ExtendedTestResult(unittest._TextTestResult):
157
126
    """
158
127
 
159
128
    stop_early = False
160
 
 
 
129
    
161
130
    def __init__(self, stream, descriptions, verbosity,
162
131
                 bench_history=None,
163
 
                 strict=False,
 
132
                 num_tests=None,
164
133
                 ):
165
134
        """Construct new TestResult.
166
135
 
184
153
            bench_history.write("--date %s %s\n" % (time.time(), revision_id))
185
154
        self._bench_history = bench_history
186
155
        self.ui = ui.ui_factory
187
 
        self.num_tests = 0
 
156
        self.num_tests = num_tests
188
157
        self.error_count = 0
189
158
        self.failure_count = 0
190
159
        self.known_failure_count = 0
193
162
        self.unsupported = {}
194
163
        self.count = 0
195
164
        self._overall_start_time = time.time()
196
 
        self._strict = strict
197
 
 
198
 
    def stopTestRun(self):
199
 
        run = self.testsRun
200
 
        actionTaken = "Ran"
201
 
        stopTime = time.time()
202
 
        timeTaken = stopTime - self.startTime
203
 
        self.printErrors()
204
 
        self.stream.writeln(self.separator2)
205
 
        self.stream.writeln("%s %d test%s in %.3fs" % (actionTaken,
206
 
                            run, run != 1 and "s" or "", timeTaken))
207
 
        self.stream.writeln()
208
 
        if not self.wasSuccessful():
209
 
            self.stream.write("FAILED (")
210
 
            failed, errored = map(len, (self.failures, self.errors))
211
 
            if failed:
212
 
                self.stream.write("failures=%d" % failed)
213
 
            if errored:
214
 
                if failed: self.stream.write(", ")
215
 
                self.stream.write("errors=%d" % errored)
216
 
            if self.known_failure_count:
217
 
                if failed or errored: self.stream.write(", ")
218
 
                self.stream.write("known_failure_count=%d" %
219
 
                    self.known_failure_count)
220
 
            self.stream.writeln(")")
221
 
        else:
222
 
            if self.known_failure_count:
223
 
                self.stream.writeln("OK (known_failures=%d)" %
224
 
                    self.known_failure_count)
225
 
            else:
226
 
                self.stream.writeln("OK")
227
 
        if self.skip_count > 0:
228
 
            skipped = self.skip_count
229
 
            self.stream.writeln('%d test%s skipped' %
230
 
                                (skipped, skipped != 1 and "s" or ""))
231
 
        if self.unsupported:
232
 
            for feature, count in sorted(self.unsupported.items()):
233
 
                self.stream.writeln("Missing feature '%s' skipped %d tests." %
234
 
                    (feature, count))
235
 
        if self._strict:
236
 
            ok = self.wasStrictlySuccessful()
237
 
        else:
238
 
            ok = self.wasSuccessful()
239
 
        if TestCase._first_thread_leaker_id:
240
 
            self.stream.write(
241
 
                '%s is leaking threads among %d leaking tests.\n' % (
242
 
                TestCase._first_thread_leaker_id,
243
 
                TestCase._leaking_threads_tests))
244
 
            # We don't report the main thread as an active one.
245
 
            self.stream.write(
246
 
                '%d non-main threads were left active in the end.\n'
247
 
                % (TestCase._active_threads - 1))
248
 
 
249
 
    def getDescription(self, test):
250
 
        return test.id()
251
 
 
252
 
    def _extractBenchmarkTime(self, testCase, details=None):
 
165
    
 
166
    def _extractBenchmarkTime(self, testCase):
253
167
        """Add a benchmark time for the current test case."""
254
 
        if details and 'benchtime' in details:
255
 
            return float(''.join(details['benchtime'].iter_bytes()))
256
168
        return getattr(testCase, "_benchtime", None)
257
 
 
 
169
    
258
170
    def _elapsedTestTimeString(self):
259
171
        """Return a time string for the overall time the current test has taken."""
260
172
        return self._formatTime(time.time() - self._start_time)
262
174
    def _testTimeString(self, testCase):
263
175
        benchmark_time = self._extractBenchmarkTime(testCase)
264
176
        if benchmark_time is not None:
265
 
            return self._formatTime(benchmark_time) + "*"
 
177
            return "%s/%s" % (
 
178
                self._formatTime(benchmark_time),
 
179
                self._elapsedTestTimeString())
266
180
        else:
267
 
            return self._elapsedTestTimeString()
 
181
            return "           %s" % self._elapsedTestTimeString()
268
182
 
269
183
    def _formatTime(self, seconds):
270
184
        """Format seconds as milliseconds with leading spaces."""
279
193
 
280
194
    def startTest(self, test):
281
195
        unittest.TestResult.startTest(self, test)
282
 
        if self.count == 0:
283
 
            self.startTests()
284
196
        self.report_test_start(test)
285
197
        test.number = self.count
286
198
        self._recordTestStartTime()
287
199
 
288
 
    def startTests(self):
289
 
        import platform
290
 
        if getattr(sys, 'frozen', None) is None:
291
 
            bzr_path = osutils.realpath(sys.argv[0])
292
 
        else:
293
 
            bzr_path = sys.executable
294
 
        self.stream.write(
295
 
            'bzr selftest: %s\n' % (bzr_path,))
296
 
        self.stream.write(
297
 
            '   %s\n' % (
298
 
                    bzrlib.__path__[0],))
299
 
        self.stream.write(
300
 
            '   bzr-%s python-%s %s\n' % (
301
 
                    bzrlib.version_string,
302
 
                    bzrlib._format_version_tuple(sys.version_info),
303
 
                    platform.platform(aliased=1),
304
 
                    ))
305
 
        self.stream.write('\n')
306
 
 
307
200
    def _recordTestStartTime(self):
308
201
        """Record that a test has started."""
309
202
        self._start_time = time.time()
321
214
        Called from the TestCase run() method when the test
322
215
        fails with an unexpected error.
323
216
        """
324
 
        self._post_mortem()
325
 
        unittest.TestResult.addError(self, test, err)
326
 
        self.error_count += 1
327
 
        self.report_error(test, err)
328
 
        if self.stop_early:
329
 
            self.stop()
330
 
        self._cleanupLogFile(test)
 
217
        self._testConcluded(test)
 
218
        if isinstance(err[1], TestSkipped):
 
219
            return self._addSkipped(test, err)
 
220
        elif isinstance(err[1], UnavailableFeature):
 
221
            return self.addNotSupported(test, err[1].args[0])
 
222
        else:
 
223
            unittest.TestResult.addError(self, test, err)
 
224
            self.error_count += 1
 
225
            self.report_error(test, err)
 
226
            if self.stop_early:
 
227
                self.stop()
 
228
            self._cleanupLogFile(test)
331
229
 
332
230
    def addFailure(self, test, err):
333
231
        """Tell result that test failed.
335
233
        Called from the TestCase run() method when the test
336
234
        fails because e.g. an assert() method failed.
337
235
        """
338
 
        self._post_mortem()
339
 
        unittest.TestResult.addFailure(self, test, err)
340
 
        self.failure_count += 1
341
 
        self.report_failure(test, err)
342
 
        if self.stop_early:
343
 
            self.stop()
344
 
        self._cleanupLogFile(test)
 
236
        self._testConcluded(test)
 
237
        if isinstance(err[1], KnownFailure):
 
238
            return self._addKnownFailure(test, err)
 
239
        else:
 
240
            unittest.TestResult.addFailure(self, test, err)
 
241
            self.failure_count += 1
 
242
            self.report_failure(test, err)
 
243
            if self.stop_early:
 
244
                self.stop()
 
245
            self._cleanupLogFile(test)
345
246
 
346
 
    def addSuccess(self, test, details=None):
 
247
    def addSuccess(self, test):
347
248
        """Tell result that test completed successfully.
348
249
 
349
250
        Called from the TestCase run()
350
251
        """
 
252
        self._testConcluded(test)
351
253
        if self._bench_history is not None:
352
 
            benchmark_time = self._extractBenchmarkTime(test, details)
 
254
            benchmark_time = self._extractBenchmarkTime(test)
353
255
            if benchmark_time is not None:
354
256
                self._bench_history.write("%s %s\n" % (
355
257
                    self._formatTime(benchmark_time),
359
261
        unittest.TestResult.addSuccess(self, test)
360
262
        test._log_contents = ''
361
263
 
362
 
    def addExpectedFailure(self, test, err):
 
264
    def _testConcluded(self, test):
 
265
        """Common code when a test has finished.
 
266
 
 
267
        Called regardless of whether it succeded, failed, etc.
 
268
        """
 
269
        pass
 
270
 
 
271
    def _addKnownFailure(self, test, err):
363
272
        self.known_failure_count += 1
364
273
        self.report_known_failure(test, err)
365
274
 
367
276
        """The test will not be run because of a missing feature.
368
277
        """
369
278
        # this can be called in two different ways: it may be that the
370
 
        # test started running, and then raised (through requireFeature)
 
279
        # test started running, and then raised (through addError) 
371
280
        # UnavailableFeature.  Alternatively this method can be called
372
 
        # while probing for features before running the test code proper; in
373
 
        # that case we will see startTest and stopTest, but the test will
374
 
        # never actually run.
 
281
        # while probing for features before running the tests; in that
 
282
        # case we will see startTest and stopTest, but the test will never
 
283
        # actually run.
375
284
        self.unsupported.setdefault(str(feature), 0)
376
285
        self.unsupported[str(feature)] += 1
377
286
        self.report_unsupported(test, feature)
378
287
 
379
 
    def addSkip(self, test, reason):
380
 
        """A test has not run for 'reason'."""
381
 
        self.skip_count += 1
382
 
        self.report_skip(test, reason)
383
 
 
384
 
    def addNotApplicable(self, test, reason):
385
 
        self.not_applicable_count += 1
386
 
        self.report_not_applicable(test, reason)
387
 
 
388
 
    def _post_mortem(self):
389
 
        """Start a PDB post mortem session."""
390
 
        if os.environ.get('BZR_TEST_PDB', None):
391
 
            import pdb;pdb.post_mortem()
392
 
 
393
 
    def progress(self, offset, whence):
394
 
        """The test is adjusting the count of tests to run."""
395
 
        if whence == SUBUNIT_SEEK_SET:
396
 
            self.num_tests = offset
397
 
        elif whence == SUBUNIT_SEEK_CUR:
398
 
            self.num_tests += offset
399
 
        else:
400
 
            raise errors.BzrError("Unknown whence %r" % whence)
 
288
    def _addSkipped(self, test, skip_excinfo):
 
289
        if isinstance(skip_excinfo[1], TestNotApplicable):
 
290
            self.not_applicable_count += 1
 
291
            self.report_not_applicable(test, skip_excinfo)
 
292
        else:
 
293
            self.skip_count += 1
 
294
            self.report_skip(test, skip_excinfo)
 
295
        try:
 
296
            test.tearDown()
 
297
        except KeyboardInterrupt:
 
298
            raise
 
299
        except:
 
300
            self.addError(test, test._exc_info())
 
301
        else:
 
302
            # seems best to treat this as success from point-of-view of unittest
 
303
            # -- it actually does nothing so it barely matters :)
 
304
            unittest.TestResult.addSuccess(self, test)
 
305
            test._log_contents = ''
 
306
 
 
307
    def printErrorList(self, flavour, errors):
 
308
        for test, err in errors:
 
309
            self.stream.writeln(self.separator1)
 
310
            self.stream.write("%s: " % flavour)
 
311
            self.stream.writeln(self.getDescription(test))
 
312
            if getattr(test, '_get_log', None) is not None:
 
313
                self.stream.write('\n')
 
314
                self.stream.write(
 
315
                        ('vvvv[log from %s]' % test.id()).ljust(78,'-'))
 
316
                self.stream.write('\n')
 
317
                self.stream.write(test._get_log())
 
318
                self.stream.write('\n')
 
319
                self.stream.write(
 
320
                        ('^^^^[log from %s]' % test.id()).ljust(78,'-'))
 
321
                self.stream.write('\n')
 
322
            self.stream.writeln(self.separator2)
 
323
            self.stream.writeln("%s" % err)
 
324
 
 
325
    def finished(self):
 
326
        pass
401
327
 
402
328
    def report_cleaning_up(self):
403
329
        pass
404
330
 
405
 
    def startTestRun(self):
406
 
        self.startTime = time.time()
407
 
 
408
331
    def report_success(self, test):
409
332
        pass
410
333
 
419
342
 
420
343
    def __init__(self, stream, descriptions, verbosity,
421
344
                 bench_history=None,
 
345
                 num_tests=None,
422
346
                 pb=None,
423
 
                 strict=None,
424
347
                 ):
425
348
        ExtendedTestResult.__init__(self, stream, descriptions, verbosity,
426
 
            bench_history, strict)
427
 
        # We no longer pass them around, but just rely on the UIFactory stack
428
 
        # for state
429
 
        if pb is not None:
430
 
            warnings.warn("Passing pb to TextTestResult is deprecated")
431
 
        self.pb = self.ui.nested_progress_bar()
 
349
            bench_history, num_tests)
 
350
        if pb is None:
 
351
            self.pb = self.ui.nested_progress_bar()
 
352
            self._supplied_pb = False
 
353
        else:
 
354
            self.pb = pb
 
355
            self._supplied_pb = True
432
356
        self.pb.show_pct = False
433
357
        self.pb.show_spinner = False
434
358
        self.pb.show_eta = False,
435
359
        self.pb.show_count = False
436
360
        self.pb.show_bar = False
437
 
        self.pb.update_latency = 0
438
 
        self.pb.show_transport_activity = False
439
 
 
440
 
    def stopTestRun(self):
441
 
        # called when the tests that are going to run have run
442
 
        self.pb.clear()
443
 
        self.pb.finished()
444
 
        super(TextTestResult, self).stopTestRun()
445
 
 
446
 
    def startTestRun(self):
447
 
        super(TextTestResult, self).startTestRun()
448
 
        self.pb.update('[test 0/%d] Starting' % (self.num_tests))
449
 
 
450
 
    def printErrors(self):
451
 
        # clear the pb to make room for the error listing
452
 
        self.pb.clear()
453
 
        super(TextTestResult, self).printErrors()
 
361
 
 
362
    def report_starting(self):
 
363
        self.pb.update('[test 0/%d] starting...' % (self.num_tests))
454
364
 
455
365
    def _progress_prefix_text(self):
456
366
        # the longer this text, the less space we have to show the test
462
372
        ##     a += ', %d skip' % self.skip_count
463
373
        ## if self.known_failure_count:
464
374
        ##     a += '+%dX' % self.known_failure_count
465
 
        if self.num_tests:
 
375
        if self.num_tests is not None:
466
376
            a +='/%d' % self.num_tests
467
377
        a += ' in '
468
378
        runtime = time.time() - self._overall_start_time
470
380
            a += '%dm%ds' % (runtime / 60, runtime % 60)
471
381
        else:
472
382
            a += '%ds' % runtime
473
 
        total_fail_count = self.error_count + self.failure_count
474
 
        if total_fail_count:
475
 
            a += ', %d failed' % total_fail_count
476
 
        # if self.unsupported:
477
 
        #     a += ', %d missing' % len(self.unsupported)
 
383
        if self.error_count:
 
384
            a += ', %d err' % self.error_count
 
385
        if self.failure_count:
 
386
            a += ', %d fail' % self.failure_count
 
387
        if self.unsupported:
 
388
            a += ', %d missing' % len(self.unsupported)
478
389
        a += ']'
479
390
        return a
480
391
 
482
393
        self.count += 1
483
394
        self.pb.update(
484
395
                self._progress_prefix_text()
485
 
                + ' '
 
396
                + ' ' 
486
397
                + self._shortened_test_description(test))
487
398
 
488
399
    def _test_description(self, test):
489
400
        return self._shortened_test_description(test)
490
401
 
491
402
    def report_error(self, test, err):
492
 
        self.ui.note('ERROR: %s\n    %s\n' % (
 
403
        self.pb.note('ERROR: %s\n    %s\n', 
493
404
            self._test_description(test),
494
405
            err[1],
495
 
            ))
 
406
            )
496
407
 
497
408
    def report_failure(self, test, err):
498
 
        self.ui.note('FAIL: %s\n    %s\n' % (
 
409
        self.pb.note('FAIL: %s\n    %s\n', 
499
410
            self._test_description(test),
500
411
            err[1],
501
 
            ))
 
412
            )
502
413
 
503
414
    def report_known_failure(self, test, err):
504
 
        pass
505
 
 
506
 
    def report_skip(self, test, reason):
507
 
        pass
508
 
 
509
 
    def report_not_applicable(self, test, reason):
 
415
        self.pb.note('XFAIL: %s\n%s\n',
 
416
            self._test_description(test), err[1])
 
417
 
 
418
    def report_skip(self, test, skip_excinfo):
 
419
        pass
 
420
 
 
421
    def report_not_applicable(self, test, skip_excinfo):
510
422
        pass
511
423
 
512
424
    def report_unsupported(self, test, feature):
513
425
        """test cannot be run because feature is missing."""
514
 
 
 
426
                  
515
427
    def report_cleaning_up(self):
516
 
        self.pb.update('Cleaning up')
 
428
        self.pb.update('cleaning up...')
 
429
 
 
430
    def finished(self):
 
431
        if not self._supplied_pb:
 
432
            self.pb.finished()
517
433
 
518
434
 
519
435
class VerboseTestResult(ExtendedTestResult):
527
443
            result = a_string
528
444
        return result.ljust(final_width)
529
445
 
530
 
    def startTestRun(self):
531
 
        super(VerboseTestResult, self).startTestRun()
 
446
    def report_starting(self):
532
447
        self.stream.write('running %d tests...\n' % self.num_tests)
533
448
 
534
449
    def report_test_start(self, test):
535
450
        self.count += 1
536
451
        name = self._shortened_test_description(test)
537
 
        width = osutils.terminal_width()
538
 
        if width is not None:
539
 
            # width needs space for 6 char status, plus 1 for slash, plus an
540
 
            # 11-char time string, plus a trailing blank
541
 
            # when NUMBERED_DIRS: plus 5 chars on test number, plus 1 char on
542
 
            # space
543
 
            self.stream.write(self._ellipsize_to_right(name, width-18))
544
 
        else:
545
 
            self.stream.write(name)
 
452
        # width needs space for 6 char status, plus 1 for slash, plus 2 10-char
 
453
        # numbers, plus a trailing blank
 
454
        # when NUMBERED_DIRS: plus 5 chars on test number, plus 1 char on space
 
455
        self.stream.write(self._ellipsize_to_right(name,
 
456
                          osutils.terminal_width()-30))
546
457
        self.stream.flush()
547
458
 
548
459
    def _error_summary(self, err):
573
484
        # used to show the output in PQM.
574
485
        self.stream.flush()
575
486
 
576
 
    def report_skip(self, test, reason):
 
487
    def report_skip(self, test, skip_excinfo):
577
488
        self.stream.writeln(' SKIP %s\n%s'
578
 
                % (self._testTimeString(test), reason))
 
489
                % (self._testTimeString(test),
 
490
                   self._error_summary(skip_excinfo)))
579
491
 
580
 
    def report_not_applicable(self, test, reason):
581
 
        self.stream.writeln('  N/A %s\n    %s'
582
 
                % (self._testTimeString(test), reason))
 
492
    def report_not_applicable(self, test, skip_excinfo):
 
493
        self.stream.writeln('  N/A %s\n%s'
 
494
                % (self._testTimeString(test),
 
495
                   self._error_summary(skip_excinfo)))
583
496
 
584
497
    def report_unsupported(self, test, feature):
585
498
        """test cannot be run because feature is missing."""
595
508
                 descriptions=0,
596
509
                 verbosity=1,
597
510
                 bench_history=None,
598
 
                 strict=False,
599
 
                 result_decorators=None,
 
511
                 list_only=False
600
512
                 ):
601
 
        """Create a TextTestRunner.
602
 
 
603
 
        :param result_decorators: An optional list of decorators to apply
604
 
            to the result object being used by the runner. Decorators are
605
 
            applied left to right - the first element in the list is the 
606
 
            innermost decorator.
607
 
        """
608
 
        # stream may know claim to know to write unicode strings, but in older
609
 
        # pythons this goes sufficiently wrong that it is a bad idea. (
610
 
        # specifically a built in file with encoding 'UTF-8' will still try
611
 
        # to encode using ascii.
612
 
        new_encoding = osutils.get_terminal_encoding()
613
 
        codec = codecs.lookup(new_encoding)
614
 
        if type(codec) is tuple:
615
 
            # Python 2.4
616
 
            encode = codec[0]
617
 
        else:
618
 
            encode = codec.encode
619
 
        stream = osutils.UnicodeOrBytesToBytesWriter(encode, stream)
620
 
        stream.encoding = new_encoding
621
513
        self.stream = unittest._WritelnDecorator(stream)
622
514
        self.descriptions = descriptions
623
515
        self.verbosity = verbosity
624
516
        self._bench_history = bench_history
625
 
        self._strict = strict
626
 
        self._result_decorators = result_decorators or []
 
517
        self.list_only = list_only
627
518
 
628
519
    def run(self, test):
629
520
        "Run the given test case or test suite."
 
521
        startTime = time.time()
630
522
        if self.verbosity == 1:
631
523
            result_class = TextTestResult
632
524
        elif self.verbosity >= 2:
633
525
            result_class = VerboseTestResult
634
 
        original_result = result_class(self.stream,
 
526
        result = result_class(self.stream,
635
527
                              self.descriptions,
636
528
                              self.verbosity,
637
529
                              bench_history=self._bench_history,
638
 
                              strict=self._strict,
 
530
                              num_tests=test.countTestCases(),
639
531
                              )
640
 
        # Signal to result objects that look at stop early policy to stop,
641
 
        original_result.stop_early = self.stop_on_failure
642
 
        result = original_result
643
 
        for decorator in self._result_decorators:
644
 
            result = decorator(result)
645
 
            result.stop_early = self.stop_on_failure
646
 
        result.startTestRun()
647
 
        try:
 
532
        result.stop_early = self.stop_on_failure
 
533
        result.report_starting()
 
534
        if self.list_only:
 
535
            if self.verbosity >= 2:
 
536
                self.stream.writeln("Listing tests only ...\n")
 
537
            run = 0
 
538
            for t in iter_suite_tests(test):
 
539
                self.stream.writeln("%s" % (t.id()))
 
540
                run += 1
 
541
            actionTaken = "Listed"
 
542
        else: 
648
543
            test.run(result)
649
 
        finally:
650
 
            result.stopTestRun()
651
 
        # higher level code uses our extended protocol to determine
652
 
        # what exit code to give.
653
 
        return original_result
 
544
            run = result.testsRun
 
545
            actionTaken = "Ran"
 
546
        stopTime = time.time()
 
547
        timeTaken = stopTime - startTime
 
548
        result.printErrors()
 
549
        self.stream.writeln(result.separator2)
 
550
        self.stream.writeln("%s %d test%s in %.3fs" % (actionTaken,
 
551
                            run, run != 1 and "s" or "", timeTaken))
 
552
        self.stream.writeln()
 
553
        if not result.wasSuccessful():
 
554
            self.stream.write("FAILED (")
 
555
            failed, errored = map(len, (result.failures, result.errors))
 
556
            if failed:
 
557
                self.stream.write("failures=%d" % failed)
 
558
            if errored:
 
559
                if failed: self.stream.write(", ")
 
560
                self.stream.write("errors=%d" % errored)
 
561
            if result.known_failure_count:
 
562
                if failed or errored: self.stream.write(", ")
 
563
                self.stream.write("known_failure_count=%d" %
 
564
                    result.known_failure_count)
 
565
            self.stream.writeln(")")
 
566
        else:
 
567
            if result.known_failure_count:
 
568
                self.stream.writeln("OK (known_failures=%d)" %
 
569
                    result.known_failure_count)
 
570
            else:
 
571
                self.stream.writeln("OK")
 
572
        if result.skip_count > 0:
 
573
            skipped = result.skip_count
 
574
            self.stream.writeln('%d test%s skipped' %
 
575
                                (skipped, skipped != 1 and "s" or ""))
 
576
        if result.unsupported:
 
577
            for feature, count in sorted(result.unsupported.items()):
 
578
                self.stream.writeln("Missing feature '%s' skipped %d tests." %
 
579
                    (feature, count))
 
580
        result.finished()
 
581
        return result
654
582
 
655
583
 
656
584
def iter_suite_tests(suite):
657
585
    """Return all tests in a suite, recursing through nested suites"""
658
 
    if isinstance(suite, unittest.TestCase):
659
 
        yield suite
660
 
    elif isinstance(suite, unittest.TestSuite):
661
 
        for item in suite:
 
586
    for item in suite._tests:
 
587
        if isinstance(item, unittest.TestCase):
 
588
            yield item
 
589
        elif isinstance(item, unittest.TestSuite):
662
590
            for r in iter_suite_tests(item):
663
591
                yield r
664
 
    else:
665
 
        raise Exception('unknown type %r for object %r'
666
 
                        % (type(suite), suite))
667
 
 
668
 
 
669
 
TestSkipped = testtools.testcase.TestSkipped
 
592
        else:
 
593
            raise Exception('unknown object %r inside test suite %r'
 
594
                            % (item, suite))
 
595
 
 
596
 
 
597
class TestSkipped(Exception):
 
598
    """Indicates that a test was intentionally skipped, rather than failing."""
670
599
 
671
600
 
672
601
class TestNotApplicable(TestSkipped):
673
602
    """A test is not applicable to the situation where it was run.
674
603
 
675
 
    This is only normally raised by parameterized tests, if they find that
676
 
    the instance they're constructed upon does not support one aspect
 
604
    This is only normally raised by parameterized tests, if they find that 
 
605
    the instance they're constructed upon does not support one aspect 
677
606
    of its interface.
678
607
    """
679
608
 
680
609
 
681
 
# traceback._some_str fails to format exceptions that have the default
682
 
# __str__ which does an implicit ascii conversion. However, repr() on those
683
 
# objects works, for all that its not quite what the doctor may have ordered.
684
 
def _clever_some_str(value):
685
 
    try:
686
 
        return str(value)
687
 
    except:
688
 
        try:
689
 
            return repr(value).replace('\\n', '\n')
690
 
        except:
691
 
            return '<unprintable %s object>' % type(value).__name__
692
 
 
693
 
traceback._some_str = _clever_some_str
694
 
 
695
 
 
696
 
# deprecated - use self.knownFailure(), or self.expectFailure.
697
 
KnownFailure = testtools.testcase._ExpectedFailure
 
610
class KnownFailure(AssertionError):
 
611
    """Indicates that a test failed in a precisely expected manner.
 
612
 
 
613
    Such failures dont block the whole test suite from passing because they are
 
614
    indicators of partially completed code or of future work. We have an
 
615
    explicit error for them so that we can ensure that they are always visible:
 
616
    KnownFailures are always shown in the output of bzr selftest.
 
617
    """
698
618
 
699
619
 
700
620
class UnavailableFeature(Exception):
701
621
    """A feature required for this test was not available.
702
622
 
703
 
    This can be considered a specialised form of SkippedTest.
704
 
 
705
623
    The feature should be used to construct the exception.
706
624
    """
707
625
 
708
626
 
 
627
class CommandFailed(Exception):
 
628
    pass
 
629
 
 
630
 
709
631
class StringIOWrapper(object):
710
632
    """A wrapper around cStringIO which just adds an encoding attribute.
711
 
 
 
633
    
712
634
    Internally we can check sys.stdout to see what the output encoding
713
635
    should be. However, cStringIO has no encoding attribute that we can
714
636
    set. So we wrap it instead.
732
654
            return setattr(self._cstring, name, val)
733
655
 
734
656
 
735
 
class TestUIFactory(TextUIFactory):
 
657
class TestUIFactory(ui.CLIUIFactory):
736
658
    """A UI Factory for testing.
737
659
 
738
660
    Hide the progress bar but emit note()s.
739
661
    Redirect stdin.
740
662
    Allows get_password to be tested without real tty attached.
741
 
 
742
 
    See also CannedInputUIFactory which lets you provide programmatic input in
743
 
    a structured way.
744
663
    """
745
 
    # TODO: Capture progress events at the model level and allow them to be
746
 
    # observed by tests that care.
747
 
    #
748
 
    # XXX: Should probably unify more with CannedInputUIFactory or a
749
 
    # particular configuration of TextUIFactory, or otherwise have a clearer
750
 
    # idea of how they're supposed to be different.
751
 
    # See https://bugs.edge.launchpad.net/bzr/+bug/408213
752
664
 
753
 
    def __init__(self, stdout=None, stderr=None, stdin=None):
 
665
    def __init__(self,
 
666
                 stdout=None,
 
667
                 stderr=None,
 
668
                 stdin=None):
 
669
        super(TestUIFactory, self).__init__()
754
670
        if stdin is not None:
755
671
            # We use a StringIOWrapper to be able to test various
756
672
            # encodings, but the user is still responsible to
757
673
            # encode the string and to set the encoding attribute
758
674
            # of StringIOWrapper.
759
 
            stdin = StringIOWrapper(stdin)
760
 
        super(TestUIFactory, self).__init__(stdin, stdout, stderr)
761
 
 
762
 
    def get_non_echoed_password(self):
 
675
            self.stdin = StringIOWrapper(stdin)
 
676
        if stdout is None:
 
677
            self.stdout = sys.stdout
 
678
        else:
 
679
            self.stdout = stdout
 
680
        if stderr is None:
 
681
            self.stderr = sys.stderr
 
682
        else:
 
683
            self.stderr = stderr
 
684
 
 
685
    def clear(self):
 
686
        """See progress.ProgressBar.clear()."""
 
687
 
 
688
    def clear_term(self):
 
689
        """See progress.ProgressBar.clear_term()."""
 
690
 
 
691
    def clear_term(self):
 
692
        """See progress.ProgressBar.clear_term()."""
 
693
 
 
694
    def finished(self):
 
695
        """See progress.ProgressBar.finished()."""
 
696
 
 
697
    def note(self, fmt_string, *args, **kwargs):
 
698
        """See progress.ProgressBar.note()."""
 
699
        self.stdout.write((fmt_string + "\n") % args)
 
700
 
 
701
    def progress_bar(self):
 
702
        return self
 
703
 
 
704
    def nested_progress_bar(self):
 
705
        return self
 
706
 
 
707
    def update(self, message, count=None, total=None):
 
708
        """See progress.ProgressBar.update()."""
 
709
 
 
710
    def get_non_echoed_password(self, prompt):
763
711
        """Get password from stdin without trying to handle the echo mode"""
 
712
        if prompt:
 
713
            self.stdout.write(prompt.encode(self.stdout.encoding, 'replace'))
764
714
        password = self.stdin.readline()
765
715
        if not password:
766
716
            raise EOFError
768
718
            password = password[:-1]
769
719
        return password
770
720
 
771
 
    def make_progress_view(self):
772
 
        return NullProgressView()
773
 
 
774
 
 
775
 
class TestCase(testtools.TestCase):
 
721
 
 
722
def _report_leaked_threads():
 
723
    bzrlib.trace.warning('%s is leaking threads among %d leaking tests',
 
724
                         TestCase._first_thread_leaker_id,
 
725
                         TestCase._leaking_threads_tests)
 
726
 
 
727
 
 
728
class TestCase(unittest.TestCase):
776
729
    """Base class for bzr unit tests.
777
 
 
778
 
    Tests that need access to disk resources should subclass
 
730
    
 
731
    Tests that need access to disk resources should subclass 
779
732
    TestCaseInTempDir not TestCase.
780
733
 
781
734
    Error and debug log messages are redirected from their usual
783
736
    retrieved by _get_log().  We use a real OS file, not an in-memory object,
784
737
    so that it can also capture file IO.  When the test completes this file
785
738
    is read into memory and removed from disk.
786
 
 
 
739
       
787
740
    There are also convenience functions to invoke bzr's command-line
788
741
    routine, and to build and check bzr trees.
789
 
 
 
742
   
790
743
    In addition to the usual method of overriding tearDown(), this class also
791
744
    allows subclasses to register functions into the _cleanups list, which is
792
745
    run in order as the object is torn down.  It's less likely this will be
797
750
    _leaking_threads_tests = 0
798
751
    _first_thread_leaker_id = None
799
752
    _log_file_name = None
 
753
    _log_contents = ''
 
754
    _keep_log_file = False
800
755
    # record lsprof data when performing benchmark calls.
801
756
    _gather_lsprof_in_benchmarks = False
 
757
    attrs_to_keep = ('id', '_testMethodName', '_testMethodDoc',
 
758
                     '_log_contents', '_log_file_name', '_benchtime',
 
759
                     '_TestCase__testMethodName')
802
760
 
803
761
    def __init__(self, methodName='testMethod'):
804
762
        super(TestCase, self).__init__(methodName)
805
763
        self._cleanups = []
806
 
        self._directory_isolation = True
807
 
        self.exception_handlers.insert(0,
808
 
            (UnavailableFeature, self._do_unsupported_or_skip))
809
 
        self.exception_handlers.insert(0,
810
 
            (TestNotApplicable, self._do_not_applicable))
811
764
 
812
765
    def setUp(self):
813
 
        super(TestCase, self).setUp()
814
 
        for feature in getattr(self, '_test_needs_features', []):
815
 
            self.requireFeature(feature)
816
 
        self._log_contents = None
817
 
        self.addDetail("log", content.Content(content.ContentType("text",
818
 
            "plain", {"charset": "utf8"}),
819
 
            lambda:[self._get_log(keep_log_file=True)]))
 
766
        unittest.TestCase.setUp(self)
820
767
        self._cleanEnvironment()
821
768
        self._silenceUI()
822
769
        self._startLogFile()
823
770
        self._benchcalls = []
824
771
        self._benchtime = None
825
772
        self._clear_hooks()
826
 
        self._track_transports()
827
 
        self._track_locks()
828
773
        self._clear_debug_flags()
829
774
        TestCase._active_threads = threading.activeCount()
830
775
        self.addCleanup(self._check_leaked_threads)
831
776
 
832
 
    def debug(self):
833
 
        # debug a frame up.
834
 
        import pdb
835
 
        pdb.Pdb().set_trace(sys._getframe().f_back)
836
 
 
837
777
    def _check_leaked_threads(self):
838
778
        active = threading.activeCount()
839
779
        leaked_threads = active - TestCase._active_threads
840
780
        TestCase._active_threads = active
841
 
        # If some tests make the number of threads *decrease*, we'll consider
842
 
        # that they are just observing old threads dieing, not agressively kill
843
 
        # random threads. So we don't report these tests as leaking. The risk
844
 
        # is that we have false positives that way (the test see 2 threads
845
 
        # going away but leak one) but it seems less likely than the actual
846
 
        # false positives (the test see threads going away and does not leak).
847
 
        if leaked_threads > 0:
 
781
        if leaked_threads:
848
782
            TestCase._leaking_threads_tests += 1
849
783
            if TestCase._first_thread_leaker_id is None:
850
784
                TestCase._first_thread_leaker_id = self.id()
 
785
                # we're not specifically told when all tests are finished.
 
786
                # This will do. We use a function to avoid keeping a reference
 
787
                # to a TestCase object.
 
788
                atexit.register(_report_leaked_threads)
851
789
 
852
790
    def _clear_debug_flags(self):
853
791
        """Prevent externally set debug flags affecting tests.
854
 
 
 
792
        
855
793
        Tests that want to use debug flags can just set them in the
856
794
        debug_flags set during setup/teardown.
857
795
        """
858
 
        # Start with a copy of the current debug flags we can safely modify.
859
 
        self.overrideAttr(debug, 'debug_flags', set(debug.debug_flags))
860
796
        if 'allow_debug' not in selftest_debug_flags:
 
797
            self._preserved_debug_flags = set(debug.debug_flags)
861
798
            debug.debug_flags.clear()
862
 
        if 'disable_lock_checks' not in selftest_debug_flags:
863
 
            debug.debug_flags.add('strict_locks')
 
799
            self.addCleanup(self._restore_debug_flags)
864
800
 
865
801
    def _clear_hooks(self):
866
802
        # prevent hooks affecting tests
867
 
        self._preserved_hooks = {}
868
 
        for key, factory in hooks.known_hooks.items():
869
 
            parent, name = hooks.known_hooks_key_to_parent_and_attribute(key)
870
 
            current_hooks = hooks.known_hooks_key_to_object(key)
871
 
            self._preserved_hooks[parent] = (name, current_hooks)
 
803
        import bzrlib.branch
 
804
        import bzrlib.smart.server
 
805
        self._preserved_hooks = {
 
806
            bzrlib.branch.Branch: bzrlib.branch.Branch.hooks,
 
807
            bzrlib.mutabletree.MutableTree: bzrlib.mutabletree.MutableTree.hooks,
 
808
            bzrlib.smart.server.SmartTCPServer: bzrlib.smart.server.SmartTCPServer.hooks,
 
809
            }
872
810
        self.addCleanup(self._restoreHooks)
873
 
        for key, factory in hooks.known_hooks.items():
874
 
            parent, name = hooks.known_hooks_key_to_parent_and_attribute(key)
875
 
            setattr(parent, name, factory())
876
 
        # this hook should always be installed
877
 
        request._install_hook()
878
 
 
879
 
    def disable_directory_isolation(self):
880
 
        """Turn off directory isolation checks."""
881
 
        self._directory_isolation = False
882
 
 
883
 
    def enable_directory_isolation(self):
884
 
        """Enable directory isolation checks."""
885
 
        self._directory_isolation = True
 
811
        # reset all hooks to an empty instance of the appropriate type
 
812
        bzrlib.branch.Branch.hooks = bzrlib.branch.BranchHooks()
 
813
        bzrlib.smart.server.SmartTCPServer.hooks = bzrlib.smart.server.SmartServerHooks()
886
814
 
887
815
    def _silenceUI(self):
888
816
        """Turn off UI for duration of test"""
889
817
        # by default the UI is off; tests can turn it on if they want it.
890
 
        self.overrideAttr(ui, 'ui_factory', ui.SilentUIFactory())
891
 
 
892
 
    def _check_locks(self):
893
 
        """Check that all lock take/release actions have been paired."""
894
 
        # We always check for mismatched locks. If a mismatch is found, we
895
 
        # fail unless -Edisable_lock_checks is supplied to selftest, in which
896
 
        # case we just print a warning.
897
 
        # unhook:
898
 
        acquired_locks = [lock for action, lock in self._lock_actions
899
 
                          if action == 'acquired']
900
 
        released_locks = [lock for action, lock in self._lock_actions
901
 
                          if action == 'released']
902
 
        broken_locks = [lock for action, lock in self._lock_actions
903
 
                        if action == 'broken']
904
 
        # trivially, given the tests for lock acquistion and release, if we
905
 
        # have as many in each list, it should be ok. Some lock tests also
906
 
        # break some locks on purpose and should be taken into account by
907
 
        # considering that breaking a lock is just a dirty way of releasing it.
908
 
        if len(acquired_locks) != (len(released_locks) + len(broken_locks)):
909
 
            message = ('Different number of acquired and '
910
 
                       'released or broken locks. (%s, %s + %s)' %
911
 
                       (acquired_locks, released_locks, broken_locks))
912
 
            if not self._lock_check_thorough:
913
 
                # Rather than fail, just warn
914
 
                print "Broken test %s: %s" % (self, message)
915
 
                return
916
 
            self.fail(message)
917
 
 
918
 
    def _track_locks(self):
919
 
        """Track lock activity during tests."""
920
 
        self._lock_actions = []
921
 
        if 'disable_lock_checks' in selftest_debug_flags:
922
 
            self._lock_check_thorough = False
923
 
        else:
924
 
            self._lock_check_thorough = True
925
 
 
926
 
        self.addCleanup(self._check_locks)
927
 
        _mod_lock.Lock.hooks.install_named_hook('lock_acquired',
928
 
                                                self._lock_acquired, None)
929
 
        _mod_lock.Lock.hooks.install_named_hook('lock_released',
930
 
                                                self._lock_released, None)
931
 
        _mod_lock.Lock.hooks.install_named_hook('lock_broken',
932
 
                                                self._lock_broken, None)
933
 
 
934
 
    def _lock_acquired(self, result):
935
 
        self._lock_actions.append(('acquired', result))
936
 
 
937
 
    def _lock_released(self, result):
938
 
        self._lock_actions.append(('released', result))
939
 
 
940
 
    def _lock_broken(self, result):
941
 
        self._lock_actions.append(('broken', result))
942
 
 
943
 
    def permit_dir(self, name):
944
 
        """Permit a directory to be used by this test. See permit_url."""
945
 
        name_transport = get_transport(name)
946
 
        self.permit_url(name)
947
 
        self.permit_url(name_transport.base)
948
 
 
949
 
    def permit_url(self, url):
950
 
        """Declare that url is an ok url to use in this test.
951
 
        
952
 
        Do this for memory transports, temporary test directory etc.
953
 
        
954
 
        Do not do this for the current working directory, /tmp, or any other
955
 
        preexisting non isolated url.
956
 
        """
957
 
        if not url.endswith('/'):
958
 
            url += '/'
959
 
        self._bzr_selftest_roots.append(url)
960
 
 
961
 
    def permit_source_tree_branch_repo(self):
962
 
        """Permit the source tree bzr is running from to be opened.
963
 
 
964
 
        Some code such as bzrlib.version attempts to read from the bzr branch
965
 
        that bzr is executing from (if any). This method permits that directory
966
 
        to be used in the test suite.
967
 
        """
968
 
        path = self.get_source_path()
969
 
        self.record_directory_isolation()
970
 
        try:
971
 
            try:
972
 
                workingtree.WorkingTree.open(path)
973
 
            except (errors.NotBranchError, errors.NoWorkingTree):
974
 
                return
975
 
        finally:
976
 
            self.enable_directory_isolation()
977
 
 
978
 
    def _preopen_isolate_transport(self, transport):
979
 
        """Check that all transport openings are done in the test work area."""
980
 
        while isinstance(transport, pathfilter.PathFilteringTransport):
981
 
            # Unwrap pathfiltered transports
982
 
            transport = transport.server.backing_transport.clone(
983
 
                transport._filter('.'))
984
 
        url = transport.base
985
 
        # ReadonlySmartTCPServer_for_testing decorates the backing transport
986
 
        # urls it is given by prepending readonly+. This is appropriate as the
987
 
        # client shouldn't know that the server is readonly (or not readonly).
988
 
        # We could register all servers twice, with readonly+ prepending, but
989
 
        # that makes for a long list; this is about the same but easier to
990
 
        # read.
991
 
        if url.startswith('readonly+'):
992
 
            url = url[len('readonly+'):]
993
 
        self._preopen_isolate_url(url)
994
 
 
995
 
    def _preopen_isolate_url(self, url):
996
 
        if not self._directory_isolation:
997
 
            return
998
 
        if self._directory_isolation == 'record':
999
 
            self._bzr_selftest_roots.append(url)
1000
 
            return
1001
 
        # This prevents all transports, including e.g. sftp ones backed on disk
1002
 
        # from working unless they are explicitly granted permission. We then
1003
 
        # depend on the code that sets up test transports to check that they are
1004
 
        # appropriately isolated and enable their use by calling
1005
 
        # self.permit_transport()
1006
 
        if not osutils.is_inside_any(self._bzr_selftest_roots, url):
1007
 
            raise errors.BzrError("Attempt to escape test isolation: %r %r"
1008
 
                % (url, self._bzr_selftest_roots))
1009
 
 
1010
 
    def record_directory_isolation(self):
1011
 
        """Gather accessed directories to permit later access.
1012
 
        
1013
 
        This is used for tests that access the branch bzr is running from.
1014
 
        """
1015
 
        self._directory_isolation = "record"
1016
 
 
1017
 
    def start_server(self, transport_server, backing_server=None):
1018
 
        """Start transport_server for this test.
1019
 
 
1020
 
        This starts the server, registers a cleanup for it and permits the
1021
 
        server's urls to be used.
1022
 
        """
1023
 
        if backing_server is None:
1024
 
            transport_server.start_server()
1025
 
        else:
1026
 
            transport_server.start_server(backing_server)
1027
 
        self.addCleanup(transport_server.stop_server)
1028
 
        # Obtain a real transport because if the server supplies a password, it
1029
 
        # will be hidden from the base on the client side.
1030
 
        t = get_transport(transport_server.get_url())
1031
 
        # Some transport servers effectively chroot the backing transport;
1032
 
        # others like SFTPServer don't - users of the transport can walk up the
1033
 
        # transport to read the entire backing transport. This wouldn't matter
1034
 
        # except that the workdir tests are given - and that they expect the
1035
 
        # server's url to point at - is one directory under the safety net. So
1036
 
        # Branch operations into the transport will attempt to walk up one
1037
 
        # directory. Chrooting all servers would avoid this but also mean that
1038
 
        # we wouldn't be testing directly against non-root urls. Alternatively
1039
 
        # getting the test framework to start the server with a backing server
1040
 
        # at the actual safety net directory would work too, but this then
1041
 
        # means that the self.get_url/self.get_transport methods would need
1042
 
        # to transform all their results. On balance its cleaner to handle it
1043
 
        # here, and permit a higher url when we have one of these transports.
1044
 
        if t.base.endswith('/work/'):
1045
 
            # we have safety net/test root/work
1046
 
            t = t.clone('../..')
1047
 
        elif isinstance(transport_server,
1048
 
                        test_server.SmartTCPServer_for_testing):
1049
 
            # The smart server adds a path similar to work, which is traversed
1050
 
            # up from by the client. But the server is chrooted - the actual
1051
 
            # backing transport is not escaped from, and VFS requests to the
1052
 
            # root will error (because they try to escape the chroot).
1053
 
            t2 = t.clone('..')
1054
 
            while t2.base != t.base:
1055
 
                t = t2
1056
 
                t2 = t.clone('..')
1057
 
        self.permit_url(t.base)
1058
 
 
1059
 
    def _track_transports(self):
1060
 
        """Install checks for transport usage."""
1061
 
        # TestCase has no safe place it can write to.
1062
 
        self._bzr_selftest_roots = []
1063
 
        # Currently the easiest way to be sure that nothing is going on is to
1064
 
        # hook into bzr dir opening. This leaves a small window of error for
1065
 
        # transport tests, but they are well known, and we can improve on this
1066
 
        # step.
1067
 
        bzrdir.BzrDir.hooks.install_named_hook("pre_open",
1068
 
            self._preopen_isolate_transport, "Check bzr directories are safe.")
 
818
        saved = ui.ui_factory
 
819
        def _restore():
 
820
            ui.ui_factory = saved
 
821
        ui.ui_factory = ui.SilentUIFactory()
 
822
        self.addCleanup(_restore)
1069
823
 
1070
824
    def _ndiff_strings(self, a, b):
1071
825
        """Return ndiff between two strings containing lines.
1072
 
 
 
826
        
1073
827
        A trailing newline is added if missing to make the strings
1074
828
        print properly."""
1075
829
        if b and b[-1] != '\n':
1100
854
 
1101
855
    def assertEqualDiff(self, a, b, message=None):
1102
856
        """Assert two texts are equal, if not raise an exception.
1103
 
 
1104
 
        This is intended for use with multi-line strings where it can
 
857
        
 
858
        This is intended for use with multi-line strings where it can 
1105
859
        be hard to find the differences by eye.
1106
860
        """
1107
861
        # TODO: perhaps override assertEquals to call this for strings?
1109
863
            return
1110
864
        if message is None:
1111
865
            message = "texts not equal:\n"
 
866
        if a == b + '\n':
 
867
            message = 'first string is missing a final newline.\n'
1112
868
        if a + '\n' == b:
1113
 
            message = 'first string is missing a final newline.\n'
1114
 
        if a == b + '\n':
1115
869
            message = 'second string is missing a final newline.\n'
1116
870
        raise AssertionError(message +
1117
871
                             self._ndiff_strings(a, b))
1118
 
 
 
872
        
1119
873
    def assertEqualMode(self, mode, mode_test):
1120
874
        self.assertEqual(mode, mode_test,
1121
875
                         'mode mismatch %o != %o' % (mode, mode_test))
1122
876
 
1123
 
    def assertEqualStat(self, expected, actual):
1124
 
        """assert that expected and actual are the same stat result.
1125
 
 
1126
 
        :param expected: A stat result.
1127
 
        :param actual: A stat result.
1128
 
        :raises AssertionError: If the expected and actual stat values differ
1129
 
            other than by atime.
1130
 
        """
1131
 
        self.assertEqual(expected.st_size, actual.st_size,
1132
 
                         'st_size did not match')
1133
 
        self.assertEqual(expected.st_mtime, actual.st_mtime,
1134
 
                         'st_mtime did not match')
1135
 
        self.assertEqual(expected.st_ctime, actual.st_ctime,
1136
 
                         'st_ctime did not match')
1137
 
        if sys.platform != 'win32':
1138
 
            # On Win32 both 'dev' and 'ino' cannot be trusted. In python2.4 it
1139
 
            # is 'dev' that varies, in python 2.5 (6?) it is st_ino that is
1140
 
            # odd. Regardless we shouldn't actually try to assert anything
1141
 
            # about their values
1142
 
            self.assertEqual(expected.st_dev, actual.st_dev,
1143
 
                             'st_dev did not match')
1144
 
            self.assertEqual(expected.st_ino, actual.st_ino,
1145
 
                             'st_ino did not match')
1146
 
        self.assertEqual(expected.st_mode, actual.st_mode,
1147
 
                         'st_mode did not match')
1148
 
 
1149
 
    def assertLength(self, length, obj_with_len):
1150
 
        """Assert that obj_with_len is of length length."""
1151
 
        if len(obj_with_len) != length:
1152
 
            self.fail("Incorrect length: wanted %d, got %d for %r" % (
1153
 
                length, len(obj_with_len), obj_with_len))
1154
 
 
1155
 
    def assertLogsError(self, exception_class, func, *args, **kwargs):
1156
 
        """Assert that func(*args, **kwargs) quietly logs a specific exception.
1157
 
        """
1158
 
        from bzrlib import trace
1159
 
        captured = []
1160
 
        orig_log_exception_quietly = trace.log_exception_quietly
1161
 
        try:
1162
 
            def capture():
1163
 
                orig_log_exception_quietly()
1164
 
                captured.append(sys.exc_info())
1165
 
            trace.log_exception_quietly = capture
1166
 
            func(*args, **kwargs)
1167
 
        finally:
1168
 
            trace.log_exception_quietly = orig_log_exception_quietly
1169
 
        self.assertLength(1, captured)
1170
 
        err = captured[0][1]
1171
 
        self.assertIsInstance(err, exception_class)
1172
 
        return err
1173
 
 
1174
877
    def assertPositive(self, val):
1175
878
        """Assert that val is greater than 0."""
1176
879
        self.assertTrue(val > 0, 'expected a positive value, but got %s' % val)
1188
891
        if not s.endswith(suffix):
1189
892
            raise AssertionError('string %r does not end with %r' % (s, suffix))
1190
893
 
1191
 
    def assertContainsRe(self, haystack, needle_re, flags=0):
 
894
    def assertContainsRe(self, haystack, needle_re):
1192
895
        """Assert that a contains something matching a regular expression."""
1193
 
        if not re.search(needle_re, haystack, flags):
 
896
        if not re.search(needle_re, haystack):
1194
897
            if '\n' in haystack or len(haystack) > 60:
1195
898
                # a long string, format it in a more readable way
1196
899
                raise AssertionError(
1200
903
                raise AssertionError('pattern "%s" not found in "%s"'
1201
904
                        % (needle_re, haystack))
1202
905
 
1203
 
    def assertNotContainsRe(self, haystack, needle_re, flags=0):
 
906
    def assertNotContainsRe(self, haystack, needle_re):
1204
907
        """Assert that a does not match a regular expression"""
1205
 
        if re.search(needle_re, haystack, flags):
 
908
        if re.search(needle_re, haystack):
1206
909
            raise AssertionError('pattern "%s" found in "%s"'
1207
910
                    % (needle_re, haystack))
1208
911
 
1209
 
    def assertContainsString(self, haystack, needle):
1210
 
        if haystack.find(needle) == -1:
1211
 
            self.fail("string %r not found in '''%s'''" % (needle, haystack))
1212
 
 
1213
912
    def assertSubset(self, sublist, superlist):
1214
913
        """Assert that every entry in sublist is present in superlist."""
1215
914
        missing = set(sublist) - set(superlist)
1219
918
 
1220
919
    def assertListRaises(self, excClass, func, *args, **kwargs):
1221
920
        """Fail unless excClass is raised when the iterator from func is used.
1222
 
 
 
921
        
1223
922
        Many functions can return generators this makes sure
1224
923
        to wrap them in a list() call to make sure the whole generator
1225
924
        is run, and that the proper exception is raised.
1272
971
                raise AssertionError("%r is %r." % (left, right))
1273
972
 
1274
973
    def assertTransportMode(self, transport, path, mode):
1275
 
        """Fail if a path does not have mode "mode".
1276
 
 
 
974
        """Fail if a path does not have mode mode.
 
975
        
1277
976
        If modes are not supported on this transport, the assertion is ignored.
1278
977
        """
1279
978
        if not transport._can_roundtrip_unix_modebits():
1281
980
        path_stat = transport.stat(path)
1282
981
        actual_mode = stat.S_IMODE(path_stat.st_mode)
1283
982
        self.assertEqual(mode, actual_mode,
1284
 
                         'mode of %r incorrect (%s != %s)'
1285
 
                         % (path, oct(mode), oct(actual_mode)))
 
983
            'mode of %r incorrect (%o != %o)' % (path, mode, actual_mode))
1286
984
 
1287
985
    def assertIsSameRealPath(self, path1, path2):
1288
986
        """Fail if path1 and path2 points to different files"""
1290
988
                         osutils.realpath(path2),
1291
989
                         "apparent paths:\na = %s\nb = %s\n," % (path1, path2))
1292
990
 
1293
 
    def assertIsInstance(self, obj, kls, msg=None):
1294
 
        """Fail if obj is not an instance of kls
1295
 
        
1296
 
        :param msg: Supplementary message to show if the assertion fails.
1297
 
        """
 
991
    def assertIsInstance(self, obj, kls):
 
992
        """Fail if obj is not an instance of kls"""
1298
993
        if not isinstance(obj, kls):
1299
 
            m = "%r is an instance of %s rather than %s" % (
1300
 
                obj, obj.__class__, kls)
1301
 
            if msg:
1302
 
                m += ": " + msg
1303
 
            self.fail(m)
 
994
            self.fail("%r is an instance of %s rather than %s" % (
 
995
                obj, obj.__class__, kls))
 
996
 
 
997
    def expectFailure(self, reason, assertion, *args, **kwargs):
 
998
        """Invoke a test, expecting it to fail for the given reason.
 
999
 
 
1000
        This is for assertions that ought to succeed, but currently fail.
 
1001
        (The failure is *expected* but not *wanted*.)  Please be very precise
 
1002
        about the failure you're expecting.  If a new bug is introduced,
 
1003
        AssertionError should be raised, not KnownFailure.
 
1004
 
 
1005
        Frequently, expectFailure should be followed by an opposite assertion.
 
1006
        See example below.
 
1007
 
 
1008
        Intended to be used with a callable that raises AssertionError as the
 
1009
        'assertion' parameter.  args and kwargs are passed to the 'assertion'.
 
1010
 
 
1011
        Raises KnownFailure if the test fails.  Raises AssertionError if the
 
1012
        test succeeds.
 
1013
 
 
1014
        example usage::
 
1015
 
 
1016
          self.expectFailure('Math is broken', self.assertNotEqual, 54,
 
1017
                             dynamic_val)
 
1018
          self.assertEqual(42, dynamic_val)
 
1019
 
 
1020
          This means that a dynamic_val of 54 will cause the test to raise
 
1021
          a KnownFailure.  Once math is fixed and the expectFailure is removed,
 
1022
          only a dynamic_val of 42 will allow the test to pass.  Anything other
 
1023
          than 54 or 42 will cause an AssertionError.
 
1024
        """
 
1025
        try:
 
1026
            assertion(*args, **kwargs)
 
1027
        except AssertionError:
 
1028
            raise KnownFailure(reason)
 
1029
        else:
 
1030
            self.fail('Unexpected success.  Should have failed: %s' % reason)
1304
1031
 
1305
1032
    def assertFileEqual(self, content, path):
1306
1033
        """Fail if path does not contain 'content'."""
1404
1131
        # warnings.  It's the easiest way to insulate ourselves from -Werror,
1405
1132
        # though.  -- Andrew, 20071062
1406
1133
        wlist = []
1407
 
        def _catcher(message, category, filename, lineno, file=None, line=None):
 
1134
        def _catcher(message, category, filename, lineno, file=None):
1408
1135
            # despite the name, 'message' is normally(?) a Warning subclass
1409
1136
            # instance
1410
1137
            wlist.append(message)
1422
1149
    def callDeprecated(self, expected, callable, *args, **kwargs):
1423
1150
        """Assert that a callable is deprecated in a particular way.
1424
1151
 
1425
 
        This is a very precise test for unusual requirements. The
 
1152
        This is a very precise test for unusual requirements. The 
1426
1153
        applyDeprecated helper function is probably more suited for most tests
1427
1154
        as it allows you to simply specify the deprecation format being used
1428
1155
        and will ensure that that is issued for the function being called.
1457
1184
 
1458
1185
        Close the file and delete it, unless setKeepLogfile was called.
1459
1186
        """
1460
 
        if bzrlib.trace._trace_file:
1461
 
            # flush the log file, to get all content
1462
 
            bzrlib.trace._trace_file.flush()
 
1187
        if self._log_file is None:
 
1188
            return
1463
1189
        bzrlib.trace.pop_log_file(self._log_memento)
1464
 
        # Cache the log result and delete the file on disk
1465
 
        self._get_log(False)
1466
 
 
1467
 
    def thisFailsStrictLockCheck(self):
1468
 
        """It is known that this test would fail with -Dstrict_locks.
1469
 
 
1470
 
        By default, all tests are run with strict lock checking unless
1471
 
        -Edisable_lock_checks is supplied. However there are some tests which
1472
 
        we know fail strict locks at this point that have not been fixed.
1473
 
        They should call this function to disable the strict checking.
1474
 
 
1475
 
        This should be used sparingly, it is much better to fix the locking
1476
 
        issues rather than papering over the problem by calling this function.
1477
 
        """
1478
 
        debug.debug_flags.discard('strict_locks')
 
1190
        self._log_file.close()
 
1191
        self._log_file = None
 
1192
        if not self._keep_log_file:
 
1193
            os.remove(self._log_file_name)
 
1194
            self._log_file_name = None
 
1195
 
 
1196
    def setKeepLogfile(self):
 
1197
        """Make the logfile not be deleted when _finishLogFile is called."""
 
1198
        self._keep_log_file = True
1479
1199
 
1480
1200
    def addCleanup(self, callable, *args, **kwargs):
1481
1201
        """Arrange to run a callable when this case is torn down.
1482
1202
 
1483
 
        Callables are run in the reverse of the order they are registered,
 
1203
        Callables are run in the reverse of the order they are registered, 
1484
1204
        ie last-in first-out.
1485
1205
        """
1486
1206
        self._cleanups.append((callable, args, kwargs))
1487
1207
 
1488
 
    def overrideAttr(self, obj, attr_name, new=_unitialized_attr):
1489
 
        """Overrides an object attribute restoring it after the test.
1490
 
 
1491
 
        :param obj: The object that will be mutated.
1492
 
 
1493
 
        :param attr_name: The attribute name we want to preserve/override in
1494
 
            the object.
1495
 
 
1496
 
        :param new: The optional value we want to set the attribute to.
1497
 
 
1498
 
        :returns: The actual attr value.
1499
 
        """
1500
 
        value = getattr(obj, attr_name)
1501
 
        # The actual value is captured by the call below
1502
 
        self.addCleanup(setattr, obj, attr_name, value)
1503
 
        if new is not _unitialized_attr:
1504
 
            setattr(obj, attr_name, new)
1505
 
        return value
1506
 
 
1507
1208
    def _cleanEnvironment(self):
1508
1209
        new_env = {
1509
1210
            'BZR_HOME': None, # Don't inherit BZR_HOME to all the tests.
1510
1211
            'HOME': os.getcwd(),
1511
 
            # bzr now uses the Win32 API and doesn't rely on APPDATA, but the
1512
 
            # tests do check our impls match APPDATA
 
1212
            'APPDATA': None,  # bzr now use Win32 API and don't rely on APPDATA
1513
1213
            'BZR_EDITOR': None, # test_msgeditor manipulates this variable
1514
 
            'VISUAL': None,
1515
 
            'EDITOR': None,
1516
1214
            'BZR_EMAIL': None,
1517
1215
            'BZREMAIL': None, # may still be present in the environment
1518
1216
            'EMAIL': None,
1519
1217
            'BZR_PROGRESS_BAR': None,
1520
1218
            'BZR_LOG': None,
1521
 
            'BZR_PLUGIN_PATH': None,
1522
 
            'BZR_DISABLE_PLUGINS': None,
1523
 
            'BZR_PLUGINS_AT': None,
1524
 
            'BZR_CONCURRENCY': None,
1525
 
            # Make sure that any text ui tests are consistent regardless of
1526
 
            # the environment the test case is run in; you may want tests that
1527
 
            # test other combinations.  'dumb' is a reasonable guess for tests
1528
 
            # going to a pipe or a StringIO.
1529
 
            'TERM': 'dumb',
1530
 
            'LINES': '25',
1531
 
            'COLUMNS': '80',
1532
 
            'BZR_COLUMNS': '80',
1533
1219
            # SSH Agent
1534
1220
            'SSH_AUTH_SOCK': None,
1535
1221
            # Proxies
1541
1227
            'NO_PROXY': None,
1542
1228
            'all_proxy': None,
1543
1229
            'ALL_PROXY': None,
1544
 
            # Nobody cares about ftp_proxy, FTP_PROXY AFAIK. So far at
 
1230
            # Nobody cares about these ones AFAIK. So far at
1545
1231
            # least. If you do (care), please update this comment
1546
 
            # -- vila 20080401
 
1232
            # -- vila 20061212
1547
1233
            'ftp_proxy': None,
1548
1234
            'FTP_PROXY': None,
1549
1235
            'BZR_REMOTE_PATH': None,
1550
 
            # Generally speaking, we don't want apport reporting on crashes in
1551
 
            # the test envirnoment unless we're specifically testing apport,
1552
 
            # so that it doesn't leak into the real system environment.  We
1553
 
            # use an env var so it propagates to subprocesses.
1554
 
            'APPORT_DISABLE': '1',
1555
1236
        }
1556
 
        self._old_env = {}
 
1237
        self.__old_env = {}
1557
1238
        self.addCleanup(self._restoreEnvironment)
1558
1239
        for name, value in new_env.iteritems():
1559
1240
            self._captureVar(name, value)
1560
1241
 
1561
1242
    def _captureVar(self, name, newvalue):
1562
1243
        """Set an environment variable, and reset it when finished."""
1563
 
        self._old_env[name] = osutils.set_or_unset_env(name, newvalue)
 
1244
        self.__old_env[name] = osutils.set_or_unset_env(name, newvalue)
 
1245
 
 
1246
    def _restore_debug_flags(self):
 
1247
        debug.debug_flags.clear()
 
1248
        debug.debug_flags.update(self._preserved_debug_flags)
1564
1249
 
1565
1250
    def _restoreEnvironment(self):
1566
 
        for name, value in self._old_env.iteritems():
 
1251
        for name, value in self.__old_env.iteritems():
1567
1252
            osutils.set_or_unset_env(name, value)
1568
1253
 
1569
1254
    def _restoreHooks(self):
1570
 
        for klass, (name, hooks) in self._preserved_hooks.items():
1571
 
            setattr(klass, name, hooks)
 
1255
        for klass, hooks in self._preserved_hooks.items():
 
1256
            setattr(klass, 'hooks', hooks)
1572
1257
 
1573
1258
    def knownFailure(self, reason):
1574
1259
        """This test has failed for some known reason."""
1575
1260
        raise KnownFailure(reason)
1576
1261
 
1577
 
    def _do_skip(self, result, reason):
1578
 
        addSkip = getattr(result, 'addSkip', None)
1579
 
        if not callable(addSkip):
1580
 
            result.addSuccess(result)
1581
 
        else:
1582
 
            addSkip(self, reason)
1583
 
 
1584
 
    @staticmethod
1585
 
    def _do_known_failure(self, result, e):
1586
 
        err = sys.exc_info()
1587
 
        addExpectedFailure = getattr(result, 'addExpectedFailure', None)
1588
 
        if addExpectedFailure is not None:
1589
 
            addExpectedFailure(self, err)
1590
 
        else:
1591
 
            result.addSuccess(self)
1592
 
 
1593
 
    @staticmethod
1594
 
    def _do_not_applicable(self, result, e):
1595
 
        if not e.args:
1596
 
            reason = 'No reason given'
1597
 
        else:
1598
 
            reason = e.args[0]
1599
 
        addNotApplicable = getattr(result, 'addNotApplicable', None)
1600
 
        if addNotApplicable is not None:
1601
 
            result.addNotApplicable(self, reason)
1602
 
        else:
1603
 
            self._do_skip(result, reason)
1604
 
 
1605
 
    @staticmethod
1606
 
    def _do_unsupported_or_skip(self, result, e):
1607
 
        reason = e.args[0]
1608
 
        addNotSupported = getattr(result, 'addNotSupported', None)
1609
 
        if addNotSupported is not None:
1610
 
            result.addNotSupported(self, reason)
1611
 
        else:
1612
 
            self._do_skip(result, reason)
 
1262
    def run(self, result=None):
 
1263
        if result is None: result = self.defaultTestResult()
 
1264
        for feature in getattr(self, '_test_needs_features', []):
 
1265
            if not feature.available():
 
1266
                result.startTest(self)
 
1267
                if getattr(result, 'addNotSupported', None):
 
1268
                    result.addNotSupported(self, feature)
 
1269
                else:
 
1270
                    result.addSuccess(self)
 
1271
                result.stopTest(self)
 
1272
                return
 
1273
        try:
 
1274
            return unittest.TestCase.run(self, result)
 
1275
        finally:
 
1276
            saved_attrs = {}
 
1277
            absent_attr = object()
 
1278
            for attr_name in self.attrs_to_keep:
 
1279
                attr = getattr(self, attr_name, absent_attr)
 
1280
                if attr is not absent_attr:
 
1281
                    saved_attrs[attr_name] = attr
 
1282
            self.__dict__ = saved_attrs
 
1283
 
 
1284
    def tearDown(self):
 
1285
        self._runCleanups()
 
1286
        unittest.TestCase.tearDown(self)
1613
1287
 
1614
1288
    def time(self, callable, *args, **kwargs):
1615
1289
        """Run callable and accrue the time it takes to the benchmark time.
1616
 
 
 
1290
        
1617
1291
        If lsprofiling is enabled (i.e. by --lsprof-time to bzr selftest) then
1618
1292
        this will cause lsprofile statistics to be gathered and stored in
1619
1293
        self._benchcalls.
1620
1294
        """
1621
1295
        if self._benchtime is None:
1622
 
            self.addDetail('benchtime', content.Content(content.ContentType(
1623
 
                "text", "plain"), lambda:[str(self._benchtime)]))
1624
1296
            self._benchtime = 0
1625
1297
        start = time.time()
1626
1298
        try:
1635
1307
        finally:
1636
1308
            self._benchtime += time.time() - start
1637
1309
 
 
1310
    def _runCleanups(self):
 
1311
        """Run registered cleanup functions. 
 
1312
 
 
1313
        This should only be called from TestCase.tearDown.
 
1314
        """
 
1315
        # TODO: Perhaps this should keep running cleanups even if 
 
1316
        # one of them fails?
 
1317
 
 
1318
        # Actually pop the cleanups from the list so tearDown running
 
1319
        # twice is safe (this happens for skipped tests).
 
1320
        while self._cleanups:
 
1321
            cleanup, args, kwargs = self._cleanups.pop()
 
1322
            cleanup(*args, **kwargs)
 
1323
 
1638
1324
    def log(self, *args):
1639
1325
        mutter(*args)
1640
1326
 
1641
1327
    def _get_log(self, keep_log_file=False):
1642
 
        """Internal helper to get the log from bzrlib.trace for this test.
1643
 
 
1644
 
        Please use self.getDetails, or self.get_log to access this in test case
1645
 
        code.
 
1328
        """Get the log from bzrlib.trace calls from this test.
1646
1329
 
1647
1330
        :param keep_log_file: When True, if the log is still a file on disk
1648
1331
            leave it as a file on disk. When False, if the log is still a file
1650
1333
            self._log_contents.
1651
1334
        :return: A string containing the log.
1652
1335
        """
1653
 
        if self._log_contents is not None:
1654
 
            try:
1655
 
                self._log_contents.decode('utf8')
1656
 
            except UnicodeDecodeError:
1657
 
                unicodestr = self._log_contents.decode('utf8', 'replace')
1658
 
                self._log_contents = unicodestr.encode('utf8')
 
1336
        # flush the log file, to get all content
 
1337
        import bzrlib.trace
 
1338
        bzrlib.trace._trace_file.flush()
 
1339
        if self._log_contents:
 
1340
            # XXX: this can hardly contain the content flushed above --vila
 
1341
            # 20080128
1659
1342
            return self._log_contents
1660
 
        import bzrlib.trace
1661
 
        if bzrlib.trace._trace_file:
1662
 
            # flush the log file, to get all content
1663
 
            bzrlib.trace._trace_file.flush()
1664
1343
        if self._log_file_name is not None:
1665
1344
            logfile = open(self._log_file_name)
1666
1345
            try:
1667
1346
                log_contents = logfile.read()
1668
1347
            finally:
1669
1348
                logfile.close()
1670
 
            try:
1671
 
                log_contents.decode('utf8')
1672
 
            except UnicodeDecodeError:
1673
 
                unicodestr = log_contents.decode('utf8', 'replace')
1674
 
                log_contents = unicodestr.encode('utf8')
1675
1349
            if not keep_log_file:
1676
 
                close_attempts = 0
1677
 
                max_close_attempts = 100
1678
 
                first_close_error = None
1679
 
                while close_attempts < max_close_attempts:
1680
 
                    close_attempts += 1
1681
 
                    try:
1682
 
                        self._log_file.close()
1683
 
                    except IOError, ioe:
1684
 
                        if ioe.errno is None:
1685
 
                            # No errno implies 'close() called during
1686
 
                            # concurrent operation on the same file object', so
1687
 
                            # retry.  Probably a thread is trying to write to
1688
 
                            # the log file.
1689
 
                            if first_close_error is None:
1690
 
                                first_close_error = ioe
1691
 
                            continue
1692
 
                        raise
1693
 
                    else:
1694
 
                        break
1695
 
                if close_attempts > 1:
1696
 
                    sys.stderr.write(
1697
 
                        'Unable to close log file on first attempt, '
1698
 
                        'will retry: %s\n' % (first_close_error,))
1699
 
                    if close_attempts == max_close_attempts:
1700
 
                        sys.stderr.write(
1701
 
                            'Unable to close log file after %d attempts.\n'
1702
 
                            % (max_close_attempts,))
1703
 
                self._log_file = None
1704
 
                # Permit multiple calls to get_log until we clean it up in
1705
 
                # finishLogFile
1706
1350
                self._log_contents = log_contents
1707
1351
                try:
1708
1352
                    os.remove(self._log_file_name)
1712
1356
                                             ' %r\n' % self._log_file_name))
1713
1357
                    else:
1714
1358
                        raise
1715
 
                self._log_file_name = None
1716
1359
            return log_contents
1717
1360
        else:
1718
 
            return "No log file content and no log file name."
1719
 
 
1720
 
    def get_log(self):
1721
 
        """Get a unicode string containing the log from bzrlib.trace.
1722
 
 
1723
 
        Undecodable characters are replaced.
1724
 
        """
1725
 
        return u"".join(self.getDetails()['log'].iter_text())
 
1361
            return "DELETED log file to reduce memory footprint"
1726
1362
 
1727
1363
    def requireFeature(self, feature):
1728
1364
        """This test requires a specific feature is available.
1745
1381
 
1746
1382
    def _run_bzr_core(self, args, retcode, encoding, stdin,
1747
1383
            working_dir):
1748
 
        # Clear chk_map page cache, because the contents are likely to mask
1749
 
        # locking errors.
1750
 
        chk_map.clear_cache()
1751
1384
        if encoding is None:
1752
 
            encoding = osutils.get_user_encoding()
 
1385
            encoding = bzrlib.user_encoding
1753
1386
        stdout = StringIOWrapper()
1754
1387
        stderr = StringIOWrapper()
1755
1388
        stdout.encoding = encoding
1770
1403
            os.chdir(working_dir)
1771
1404
 
1772
1405
        try:
1773
 
            try:
1774
 
                result = self.apply_redirected(ui.ui_factory.stdin,
1775
 
                    stdout, stderr,
1776
 
                    bzrlib.commands.run_bzr_catch_user_errors,
1777
 
                    args)
1778
 
            except KeyboardInterrupt:
1779
 
                # Reraise KeyboardInterrupt with contents of redirected stdout
1780
 
                # and stderr as arguments, for tests which are interested in
1781
 
                # stdout and stderr and are expecting the exception.
1782
 
                out = stdout.getvalue()
1783
 
                err = stderr.getvalue()
1784
 
                if out:
1785
 
                    self.log('output:\n%r', out)
1786
 
                if err:
1787
 
                    self.log('errors:\n%r', err)
1788
 
                raise KeyboardInterrupt(out, err)
 
1406
            result = self.apply_redirected(ui.ui_factory.stdin,
 
1407
                stdout, stderr,
 
1408
                bzrlib.commands.run_bzr_catch_user_errors,
 
1409
                args)
1789
1410
        finally:
1790
1411
            logger.removeHandler(handler)
1791
1412
            ui.ui_factory = old_ui_factory
1801
1422
        if retcode is not None:
1802
1423
            self.assertEquals(retcode, result,
1803
1424
                              message='Unexpected return code')
1804
 
        return result, out, err
 
1425
        return out, err
1805
1426
 
1806
1427
    def run_bzr(self, args, retcode=0, encoding=None, stdin=None,
1807
1428
                working_dir=None, error_regexes=[], output_encoding=None):
1812
1433
        passed in three ways:
1813
1434
 
1814
1435
        1- A list of strings, eg ["commit", "a"].  This is recommended
1815
 
        when the command contains whitespace or metacharacters, or
 
1436
        when the command contains whitespace or metacharacters, or 
1816
1437
        is built up at run time.
1817
1438
 
1818
 
        2- A single string, eg "add a".  This is the most convenient
 
1439
        2- A single string, eg "add a".  This is the most convenient 
1819
1440
        for hardcoded commands.
1820
1441
 
1821
1442
        This runs bzr through the interface that catches and reports
1836
1457
        :keyword error_regexes: A list of expected error messages.  If
1837
1458
            specified they must be seen in the error output of the command.
1838
1459
        """
1839
 
        retcode, out, err = self._run_bzr_autosplit(
 
1460
        out, err = self._run_bzr_autosplit(
1840
1461
            args=args,
1841
1462
            retcode=retcode,
1842
1463
            encoding=encoding,
1843
1464
            stdin=stdin,
1844
1465
            working_dir=working_dir,
1845
1466
            )
1846
 
        self.assertIsInstance(error_regexes, (list, tuple))
1847
1467
        for regex in error_regexes:
1848
1468
            self.assertContainsRe(err, regex)
1849
1469
        return out, err
1881
1501
    def run_bzr_subprocess(self, *args, **kwargs):
1882
1502
        """Run bzr in a subprocess for testing.
1883
1503
 
1884
 
        This starts a new Python interpreter and runs bzr in there.
 
1504
        This starts a new Python interpreter and runs bzr in there. 
1885
1505
        This should only be used for tests that have a justifiable need for
1886
1506
        this isolation: e.g. they are testing startup time, or signal
1887
 
        handling, or early startup code, etc.  Subprocess code can't be
 
1507
        handling, or early startup code, etc.  Subprocess code can't be 
1888
1508
        profiled or debugged so easily.
1889
1509
 
1890
1510
        :keyword retcode: The status code that is expected.  Defaults to 0.  If
1993
1613
        """
1994
1614
        return Popen(*args, **kwargs)
1995
1615
 
1996
 
    def get_source_path(self):
1997
 
        """Return the path of the directory containing bzrlib."""
1998
 
        return os.path.dirname(os.path.dirname(bzrlib.__file__))
1999
 
 
2000
1616
    def get_bzr_path(self):
2001
1617
        """Return the path of the 'bzr' executable for this test suite."""
2002
 
        bzr_path = self.get_source_path()+'/bzr'
 
1618
        bzr_path = os.path.dirname(os.path.dirname(bzrlib.__file__))+'/bzr'
2003
1619
        if not os.path.isfile(bzr_path):
2004
1620
            # We are probably installed. Assume sys.argv is the right file
2005
1621
            bzr_path = sys.argv[0]
2091
1707
 
2092
1708
        Tests that expect to provoke LockContention errors should call this.
2093
1709
        """
2094
 
        self.overrideAttr(bzrlib.lockdir, '_DEFAULT_TIMEOUT_SECONDS', 0)
 
1710
        orig_timeout = bzrlib.lockdir._DEFAULT_TIMEOUT_SECONDS
 
1711
        def resetTimeout():
 
1712
            bzrlib.lockdir._DEFAULT_TIMEOUT_SECONDS = orig_timeout
 
1713
        self.addCleanup(resetTimeout)
 
1714
        bzrlib.lockdir._DEFAULT_TIMEOUT_SECONDS = 0
2095
1715
 
2096
1716
    def make_utf8_encoded_stringio(self, encoding_type=None):
2097
1717
        """Return a StringIOWrapper instance, that will encode Unicode
2105
1725
        sio.encoding = output_encoding
2106
1726
        return sio
2107
1727
 
2108
 
    def disable_verb(self, verb):
2109
 
        """Disable a smart server verb for one test."""
2110
 
        from bzrlib.smart import request
2111
 
        request_handlers = request.request_handlers
2112
 
        orig_method = request_handlers.get(verb)
2113
 
        request_handlers.remove(verb)
2114
 
        self.addCleanup(request_handlers.register, verb, orig_method)
2115
 
 
2116
 
 
2117
 
class CapturedCall(object):
2118
 
    """A helper for capturing smart server calls for easy debug analysis."""
2119
 
 
2120
 
    def __init__(self, params, prefix_length):
2121
 
        """Capture the call with params and skip prefix_length stack frames."""
2122
 
        self.call = params
2123
 
        import traceback
2124
 
        # The last 5 frames are the __init__, the hook frame, and 3 smart
2125
 
        # client frames. Beyond this we could get more clever, but this is good
2126
 
        # enough for now.
2127
 
        stack = traceback.extract_stack()[prefix_length:-5]
2128
 
        self.stack = ''.join(traceback.format_list(stack))
2129
 
 
2130
 
    def __str__(self):
2131
 
        return self.call.method
2132
 
 
2133
 
    def __repr__(self):
2134
 
        return self.call.method
2135
 
 
2136
 
    def stack(self):
2137
 
        return self.stack
2138
 
 
2139
1728
 
2140
1729
class TestCaseWithMemoryTransport(TestCase):
2141
1730
    """Common test class for tests that do not need disk resources.
2161
1750
 
2162
1751
    def __init__(self, methodName='runTest'):
2163
1752
        # allow test parameterization after test construction and before test
2164
 
        # execution. Variables that the parameterizer sets need to be
 
1753
        # execution. Variables that the parameterizer sets need to be 
2165
1754
        # ones that are not set by setUp, or setUp will trash them.
2166
1755
        super(TestCaseWithMemoryTransport, self).__init__(methodName)
2167
1756
        self.vfs_transport_factory = default_transport
2174
1763
 
2175
1764
        This transport is for the test scratch space relative to
2176
1765
        "self._test_root"
2177
 
 
 
1766
        
2178
1767
        :param relpath: a path relative to the base url.
2179
1768
        """
2180
1769
        t = get_transport(self.get_url(relpath))
2183
1772
 
2184
1773
    def get_readonly_transport(self, relpath=None):
2185
1774
        """Return a readonly transport for the test scratch space
2186
 
 
 
1775
        
2187
1776
        This can be used to test that operations which should only need
2188
1777
        readonly access in fact do not try to write.
2189
1778
 
2208
1797
        if self.__readonly_server is None:
2209
1798
            if self.transport_readonly_server is None:
2210
1799
                # readonly decorator requested
2211
 
                self.__readonly_server = test_server.ReadonlyServer()
 
1800
                # bring up the server
 
1801
                self.__readonly_server = ReadonlyServer()
 
1802
                self.__readonly_server.setUp(self.get_vfs_only_server())
2212
1803
            else:
2213
 
                # explicit readonly transport.
2214
1804
                self.__readonly_server = self.create_transport_readonly_server()
2215
 
            self.start_server(self.__readonly_server,
2216
 
                self.get_vfs_only_server())
 
1805
                self.__readonly_server.setUp(self.get_vfs_only_server())
 
1806
            self.addCleanup(self.__readonly_server.tearDown)
2217
1807
        return self.__readonly_server
2218
1808
 
2219
1809
    def get_readonly_url(self, relpath=None):
2220
1810
        """Get a URL for the readonly transport.
2221
1811
 
2222
 
        This will either be backed by '.' or a decorator to the transport
 
1812
        This will either be backed by '.' or a decorator to the transport 
2223
1813
        used by self.get_url()
2224
1814
        relpath provides for clients to get a path relative to the base url.
2225
1815
        These should only be downwards relative, not upwards.
2237
1827
        is no means to override it.
2238
1828
        """
2239
1829
        if self.__vfs_server is None:
2240
 
            self.__vfs_server = memory.MemoryServer()
2241
 
            self.start_server(self.__vfs_server)
 
1830
            self.__vfs_server = MemoryServer()
 
1831
            self.__vfs_server.setUp()
 
1832
            self.addCleanup(self.__vfs_server.tearDown)
2242
1833
        return self.__vfs_server
2243
1834
 
2244
1835
    def get_server(self):
2251
1842
        then the self.get_vfs_server is returned.
2252
1843
        """
2253
1844
        if self.__server is None:
2254
 
            if (self.transport_server is None or self.transport_server is
2255
 
                self.vfs_transport_factory):
2256
 
                self.__server = self.get_vfs_only_server()
 
1845
            if self.transport_server is None or self.transport_server is self.vfs_transport_factory:
 
1846
                return self.get_vfs_only_server()
2257
1847
            else:
2258
1848
                # bring up a decorated means of access to the vfs only server.
2259
1849
                self.__server = self.transport_server()
2260
 
                self.start_server(self.__server, self.get_vfs_only_server())
 
1850
                try:
 
1851
                    self.__server.setUp(self.get_vfs_only_server())
 
1852
                except TypeError, e:
 
1853
                    # This should never happen; the try:Except here is to assist
 
1854
                    # developers having to update code rather than seeing an
 
1855
                    # uninformative TypeError.
 
1856
                    raise Exception, "Old server API in use: %s, %s" % (self.__server, e)
 
1857
            self.addCleanup(self.__server.tearDown)
2261
1858
        return self.__server
2262
1859
 
2263
1860
    def _adjust_url(self, base, relpath):
2325
1922
        propagating. This method ensures than a test did not leaked.
2326
1923
        """
2327
1924
        root = TestCaseWithMemoryTransport.TEST_ROOT
2328
 
        self.permit_url(get_transport(root).base)
2329
1925
        wt = workingtree.WorkingTree.open(root)
2330
1926
        last_rev = wt.last_revision()
2331
1927
        if last_rev != 'null:':
2333
1929
            # recreate a new one or all the followng tests will fail.
2334
1930
            # If you need to inspect its content uncomment the following line
2335
1931
            # import pdb; pdb.set_trace()
2336
 
            _rmtree_temp_dir(root + '/.bzr', test_id=self.id())
 
1932
            _rmtree_temp_dir(root + '/.bzr')
2337
1933
            self._create_safety_net()
2338
1934
            raise AssertionError('%s/.bzr should not be modified' % root)
2339
1935
 
2340
1936
    def _make_test_root(self):
2341
1937
        if TestCaseWithMemoryTransport.TEST_ROOT is None:
2342
 
            # Watch out for tricky test dir (on OSX /tmp -> /private/tmp)
2343
 
            root = osutils.realpath(osutils.mkdtemp(prefix='testbzr-',
2344
 
                                                    suffix='.tmp'))
 
1938
            root = osutils.mkdtemp(prefix='testbzr-', suffix='.tmp')
2345
1939
            TestCaseWithMemoryTransport.TEST_ROOT = root
2346
1940
 
2347
1941
            self._create_safety_net()
2350
1944
            # specifically told when all tests are finished.  This will do.
2351
1945
            atexit.register(_rmtree_temp_dir, root)
2352
1946
 
2353
 
        self.permit_dir(TestCaseWithMemoryTransport.TEST_ROOT)
2354
1947
        self.addCleanup(self._check_safety_net)
2355
1948
 
2356
1949
    def makeAndChdirToTestDir(self):
2357
1950
        """Create a temporary directories for this one test.
2358
 
 
 
1951
        
2359
1952
        This must set self.test_home_dir and self.test_dir and chdir to
2360
1953
        self.test_dir.
2361
 
 
 
1954
        
2362
1955
        For TestCaseWithMemoryTransport we chdir to the TEST_ROOT for this test.
2363
1956
        """
2364
1957
        os.chdir(TestCaseWithMemoryTransport.TEST_ROOT)
2365
1958
        self.test_dir = TestCaseWithMemoryTransport.TEST_ROOT
2366
1959
        self.test_home_dir = self.test_dir + "/MemoryTransportMissingHomeDir"
2367
 
        self.permit_dir(self.test_dir)
2368
 
 
 
1960
        
2369
1961
    def make_branch(self, relpath, format=None):
2370
1962
        """Create a branch on the transport at relpath."""
2371
1963
        repo = self.make_repository(relpath, format=format)
2389
1981
 
2390
1982
    def make_repository(self, relpath, shared=False, format=None):
2391
1983
        """Create a repository on our default transport at relpath.
2392
 
 
 
1984
        
2393
1985
        Note that relpath must be a relative path, not a full url.
2394
1986
        """
2395
1987
        # FIXME: If you create a remoterepository this returns the underlying
2396
 
        # real format, which is incorrect.  Actually we should make sure that
 
1988
        # real format, which is incorrect.  Actually we should make sure that 
2397
1989
        # RemoteBzrDir returns a RemoteRepository.
2398
1990
        # maybe  mbp 20070410
2399
1991
        made_control = self.make_bzrdir(relpath, format=format)
2400
1992
        return made_control.create_repository(shared=shared)
2401
1993
 
2402
 
    def make_smart_server(self, path):
2403
 
        smart_server = test_server.SmartTCPServer_for_testing()
2404
 
        self.start_server(smart_server, self.get_server())
2405
 
        remote_transport = get_transport(smart_server.get_url()).clone(path)
2406
 
        return remote_transport
2407
 
 
2408
1994
    def make_branch_and_memory_tree(self, relpath, format=None):
2409
1995
        """Create a branch on the default transport and a MemoryTree for it."""
2410
1996
        b = self.make_branch(relpath, format=format)
2411
1997
        return memorytree.MemoryTree.create_on_branch(b)
2412
1998
 
2413
1999
    def make_branch_builder(self, relpath, format=None):
2414
 
        branch = self.make_branch(relpath, format=format)
2415
 
        return branchbuilder.BranchBuilder(branch=branch)
 
2000
        url = self.get_url(relpath)
 
2001
        tran = get_transport(url)
 
2002
        return branchbuilder.BranchBuilder(get_transport(url), format=format)
2416
2003
 
2417
2004
    def overrideEnvironmentForTesting(self):
2418
 
        test_home_dir = self.test_home_dir
2419
 
        if isinstance(test_home_dir, unicode):
2420
 
            test_home_dir = test_home_dir.encode(sys.getfilesystemencoding())
2421
 
        os.environ['HOME'] = test_home_dir
2422
 
        os.environ['BZR_HOME'] = test_home_dir
2423
 
 
 
2005
        os.environ['HOME'] = self.test_home_dir
 
2006
        os.environ['BZR_HOME'] = self.test_home_dir
 
2007
        
2424
2008
    def setUp(self):
2425
2009
        super(TestCaseWithMemoryTransport, self).setUp()
2426
2010
        self._make_test_root()
2427
 
        self.addCleanup(os.chdir, os.getcwdu())
 
2011
        _currentdir = os.getcwdu()
 
2012
        def _leaveDirectory():
 
2013
            os.chdir(_currentdir)
 
2014
        self.addCleanup(_leaveDirectory)
2428
2015
        self.makeAndChdirToTestDir()
2429
2016
        self.overrideEnvironmentForTesting()
2430
2017
        self.__readonly_server = None
2431
2018
        self.__server = None
2432
2019
        self.reduceLockdirTimeout()
2433
2020
 
2434
 
    def setup_smart_server_with_call_log(self):
2435
 
        """Sets up a smart server as the transport server with a call log."""
2436
 
        self.transport_server = test_server.SmartTCPServer_for_testing
2437
 
        self.hpss_calls = []
2438
 
        import traceback
2439
 
        # Skip the current stack down to the caller of
2440
 
        # setup_smart_server_with_call_log
2441
 
        prefix_length = len(traceback.extract_stack()) - 2
2442
 
        def capture_hpss_call(params):
2443
 
            self.hpss_calls.append(
2444
 
                CapturedCall(params, prefix_length))
2445
 
        client._SmartClient.hooks.install_named_hook(
2446
 
            'call', capture_hpss_call, None)
2447
 
 
2448
 
    def reset_smart_call_log(self):
2449
 
        self.hpss_calls = []
2450
 
 
2451
 
 
 
2021
     
2452
2022
class TestCaseInTempDir(TestCaseWithMemoryTransport):
2453
2023
    """Derived class that runs a test within a temporary directory.
2454
2024
 
2459
2029
    All test cases create their own directory within that.  If the
2460
2030
    tests complete successfully, the directory is removed.
2461
2031
 
2462
 
    :ivar test_base_dir: The path of the top-level directory for this
 
2032
    :ivar test_base_dir: The path of the top-level directory for this 
2463
2033
    test, which contains a home directory and a work directory.
2464
2034
 
2465
2035
    :ivar test_home_dir: An initially empty directory under test_base_dir
2481
2051
 
2482
2052
    def _getTestDirPrefix(self):
2483
2053
        # create a directory within the top level test directory
2484
 
        if sys.platform in ('win32', 'cygwin'):
 
2054
        if sys.platform == 'win32':
2485
2055
            name_prefix = re.sub('[<>*=+",:;_/\\-]', '_', self.id())
2486
2056
            # windows is likely to have path-length limits so use a short name
2487
2057
            name_prefix = name_prefix[-30:]
2491
2061
 
2492
2062
    def makeAndChdirToTestDir(self):
2493
2063
        """See TestCaseWithMemoryTransport.makeAndChdirToTestDir().
2494
 
 
 
2064
        
2495
2065
        For TestCaseInTempDir we create a temporary directory based on the test
2496
2066
        name and then create two subdirs - test and home under it.
2497
2067
        """
2498
 
        name_prefix = osutils.pathjoin(TestCaseWithMemoryTransport.TEST_ROOT,
2499
 
            self._getTestDirPrefix())
 
2068
        name_prefix = osutils.pathjoin(self.TEST_ROOT, self._getTestDirPrefix())
2500
2069
        name = name_prefix
2501
2070
        for i in range(100):
2502
2071
            if os.path.exists(name):
2503
2072
                name = name_prefix + '_' + str(i)
2504
2073
            else:
2505
 
                # now create test and home directories within this dir
2506
 
                self.test_base_dir = name
2507
 
                self.addCleanup(self.deleteTestDir)
2508
 
                os.mkdir(self.test_base_dir)
 
2074
                os.mkdir(name)
2509
2075
                break
2510
 
        self.permit_dir(self.test_base_dir)
2511
 
        # 'sprouting' and 'init' of a branch both walk up the tree to find
2512
 
        # stacking policy to honour; create a bzr dir with an unshared
2513
 
        # repository (but not a branch - our code would be trying to escape
2514
 
        # then!) to stop them, and permit it to be read.
2515
 
        # control = bzrdir.BzrDir.create(self.test_base_dir)
2516
 
        # control.create_repository()
 
2076
        # now create test and home directories within this dir
 
2077
        self.test_base_dir = name
2517
2078
        self.test_home_dir = self.test_base_dir + '/home'
2518
2079
        os.mkdir(self.test_home_dir)
2519
2080
        self.test_dir = self.test_base_dir + '/work'
2525
2086
            f.write(self.id())
2526
2087
        finally:
2527
2088
            f.close()
 
2089
        self.addCleanup(self.deleteTestDir)
2528
2090
 
2529
2091
    def deleteTestDir(self):
2530
 
        os.chdir(TestCaseWithMemoryTransport.TEST_ROOT)
2531
 
        _rmtree_temp_dir(self.test_base_dir, test_id=self.id())
 
2092
        os.chdir(self.TEST_ROOT)
 
2093
        _rmtree_temp_dir(self.test_base_dir)
2532
2094
 
2533
2095
    def build_tree(self, shape, line_endings='binary', transport=None):
2534
2096
        """Build a test tree according to a pattern.
2555
2117
        if transport is None or transport.is_readonly():
2556
2118
            transport = get_transport(".")
2557
2119
        for name in shape:
2558
 
            self.assertIsInstance(name, basestring)
 
2120
            self.assert_(isinstance(name, basestring))
2559
2121
            if name[-1] == '/':
2560
2122
                transport.mkdir(urlutils.escape(name[:-1]))
2561
2123
            else:
2604
2166
    ReadonlyTransportDecorator is used instead which allows the use of non disk
2605
2167
    based read write transports.
2606
2168
 
2607
 
    If an explicit class is provided for readonly access, that server and the
 
2169
    If an explicit class is provided for readonly access, that server and the 
2608
2170
    readwrite one must both define get_url() as resolving to os.getcwd().
2609
2171
    """
2610
2172
 
2616
2178
        """
2617
2179
        if self.__vfs_server is None:
2618
2180
            self.__vfs_server = self.vfs_transport_factory()
2619
 
            self.start_server(self.__vfs_server)
 
2181
            self.__vfs_server.setUp()
 
2182
            self.addCleanup(self.__vfs_server.tearDown)
2620
2183
        return self.__vfs_server
2621
2184
 
2622
2185
    def make_branch_and_tree(self, relpath, format=None):
2629
2192
        repository will also be accessed locally. Otherwise a lightweight
2630
2193
        checkout is created and returned.
2631
2194
 
2632
 
        We do this because we can't physically create a tree in the local
2633
 
        path, with a branch reference to the transport_factory url, and
2634
 
        a branch + repository in the vfs_transport, unless the vfs_transport
2635
 
        namespace is distinct from the local disk - the two branch objects
2636
 
        would collide. While we could construct a tree with its branch object
2637
 
        pointing at the transport_factory transport in memory, reopening it
2638
 
        would behaving unexpectedly, and has in the past caused testing bugs
2639
 
        when we tried to do it that way.
2640
 
 
2641
2195
        :param format: The BzrDirFormat.
2642
2196
        :returns: the WorkingTree.
2643
2197
        """
2652
2206
            # We can only make working trees locally at the moment.  If the
2653
2207
            # transport can't support them, then we keep the non-disk-backed
2654
2208
            # branch and create a local checkout.
2655
 
            if self.vfs_transport_factory is test_server.LocalURLServer:
 
2209
            if self.vfs_transport_factory is LocalURLServer:
2656
2210
                # the branch is colocated on disk, we cannot create a checkout.
2657
2211
                # hopefully callers will expect this.
2658
2212
                local_controldir= bzrdir.BzrDir.open(self.get_vfs_only_url(relpath))
2695
2249
        super(TestCaseWithTransport, self).setUp()
2696
2250
        self.__vfs_server = None
2697
2251
 
2698
 
    def disable_missing_extensions_warning(self):
2699
 
        """Some tests expect a precise stderr content.
2700
 
 
2701
 
        There is no point in forcing them to duplicate the extension related
2702
 
        warning.
2703
 
        """
2704
 
        config.GlobalConfig().set_user_option('ignore_missing_extensions', True)
2705
 
 
2706
2252
 
2707
2253
class ChrootedTestCase(TestCaseWithTransport):
2708
2254
    """A support class that provides readonly urls outside the local namespace.
2712
2258
    for readonly urls.
2713
2259
 
2714
2260
    TODO RBC 20060127: make this an option to TestCaseWithTransport so it can
2715
 
                       be used without needed to redo it when a different
 
2261
                       be used without needed to redo it when a different 
2716
2262
                       subclass is in use ?
2717
2263
    """
2718
2264
 
2719
2265
    def setUp(self):
2720
2266
        super(ChrootedTestCase, self).setUp()
2721
 
        if not self.vfs_transport_factory == memory.MemoryServer:
 
2267
        if not self.vfs_transport_factory == MemoryServer:
2722
2268
            self.transport_readonly_server = HttpServer
2723
2269
 
2724
2270
 
2725
2271
def condition_id_re(pattern):
2726
2272
    """Create a condition filter which performs a re check on a test's id.
2727
 
 
 
2273
    
2728
2274
    :param pattern: A regular expression string.
2729
2275
    :return: A callable that returns True if the re matches.
2730
2276
    """
2731
 
    filter_re = osutils.re_compile_checked(pattern, 0,
2732
 
        'test filter')
 
2277
    filter_re = re.compile(pattern)
2733
2278
    def condition(test):
2734
2279
        test_id = test.id()
2735
2280
        return filter_re.search(test_id)
2738
2283
 
2739
2284
def condition_isinstance(klass_or_klass_list):
2740
2285
    """Create a condition filter which returns isinstance(param, klass).
2741
 
 
 
2286
    
2742
2287
    :return: A callable which when called with one parameter obj return the
2743
2288
        result of isinstance(obj, klass_or_klass_list).
2744
2289
    """
2749
2294
 
2750
2295
def condition_id_in_list(id_list):
2751
2296
    """Create a condition filter which verify that test's id in a list.
2752
 
 
 
2297
    
2753
2298
    :param id_list: A TestIdList object.
2754
2299
    :return: A callable that returns True if the test's id appears in the list.
2755
2300
    """
2760
2305
 
2761
2306
def condition_id_startswith(starts):
2762
2307
    """Create a condition filter verifying that test's id starts with a string.
2763
 
 
 
2308
    
2764
2309
    :param starts: A list of string.
2765
 
    :return: A callable that returns True if the test's id starts with one of
 
2310
    :return: A callable that returns True if the test's id starts with one of 
2766
2311
        the given strings.
2767
2312
    """
2768
2313
    def condition(test):
2791
2336
 
2792
2337
def filter_suite_by_condition(suite, condition):
2793
2338
    """Create a test suite by filtering another one.
2794
 
 
 
2339
    
2795
2340
    :param suite: The source suite.
2796
2341
    :param condition: A callable whose result evaluates True when called with a
2797
2342
        test case which should be included in the result.
2807
2352
 
2808
2353
def filter_suite_by_re(suite, pattern):
2809
2354
    """Create a test suite by filtering another one.
2810
 
 
 
2355
    
2811
2356
    :param suite:           the source suite
2812
2357
    :param pattern:         pattern that names must match
2813
2358
    :returns: the newly created suite
2865
2410
 
2866
2411
def randomize_suite(suite):
2867
2412
    """Return a new TestSuite with suite's tests in random order.
2868
 
 
 
2413
    
2869
2414
    The tests in the input suite are flattened into a single suite in order to
2870
2415
    accomplish this. Any nested TestSuites are removed to provide global
2871
2416
    randomness.
2877
2422
 
2878
2423
def split_suite_by_condition(suite, condition):
2879
2424
    """Split a test suite into two by a condition.
2880
 
 
 
2425
    
2881
2426
    :param suite: The suite to split.
2882
2427
    :param condition: The condition to match on. Tests that match this
2883
2428
        condition are returned in the first test suite, ones that do not match
2899
2444
 
2900
2445
def split_suite_by_re(suite, pattern):
2901
2446
    """Split a test suite into two by a regular expression.
2902
 
 
 
2447
    
2903
2448
    :param suite: The suite to split.
2904
2449
    :param pattern: A regular expression string. Test ids that match this
2905
2450
        pattern will be in the first test suite returned, and the others in the
2919
2464
              list_only=False,
2920
2465
              random_seed=None,
2921
2466
              exclude_pattern=None,
2922
 
              strict=False,
2923
 
              runner_class=None,
2924
 
              suite_decorators=None,
2925
 
              stream=None,
2926
 
              result_decorators=None,
2927
 
              ):
2928
 
    """Run a test suite for bzr selftest.
2929
 
 
2930
 
    :param runner_class: The class of runner to use. Must support the
2931
 
        constructor arguments passed by run_suite which are more than standard
2932
 
        python uses.
2933
 
    :return: A boolean indicating success.
2934
 
    """
 
2467
              strict=False):
2935
2468
    TestCase._gather_lsprof_in_benchmarks = lsprof_timed
2936
2469
    if verbose:
2937
2470
        verbosity = 2
2938
2471
    else:
2939
2472
        verbosity = 1
2940
 
    if runner_class is None:
2941
 
        runner_class = TextTestRunner
2942
 
    if stream is None:
2943
 
        stream = sys.stdout
2944
 
    runner = runner_class(stream=stream,
 
2473
    runner = TextTestRunner(stream=sys.stdout,
2945
2474
                            descriptions=0,
2946
2475
                            verbosity=verbosity,
2947
2476
                            bench_history=bench_history,
2948
 
                            strict=strict,
2949
 
                            result_decorators=result_decorators,
 
2477
                            list_only=list_only,
2950
2478
                            )
2951
2479
    runner.stop_on_failure=stop_on_failure
2952
 
    # built in decorator factories:
2953
 
    decorators = [
2954
 
        random_order(random_seed, runner),
2955
 
        exclude_tests(exclude_pattern),
2956
 
        ]
2957
 
    if matching_tests_first:
2958
 
        decorators.append(tests_first(pattern))
 
2480
    # Initialise the random number generator and display the seed used.
 
2481
    # We convert the seed to a long to make it reuseable across invocations.
 
2482
    random_order = False
 
2483
    if random_seed is not None:
 
2484
        random_order = True
 
2485
        if random_seed == "now":
 
2486
            random_seed = long(time.time())
 
2487
        else:
 
2488
            # Convert the seed to a long if we can
 
2489
            try:
 
2490
                random_seed = long(random_seed)
 
2491
            except:
 
2492
                pass
 
2493
        runner.stream.writeln("Randomizing test order using seed %s\n" %
 
2494
            (random_seed))
 
2495
        random.seed(random_seed)
 
2496
    # Customise the list of tests if requested
 
2497
    if exclude_pattern is not None:
 
2498
        suite = exclude_tests_by_re(suite, exclude_pattern)
 
2499
    if random_order:
 
2500
        order_changer = randomize_suite
2959
2501
    else:
2960
 
        decorators.append(filter_tests(pattern))
2961
 
    if suite_decorators:
2962
 
        decorators.extend(suite_decorators)
2963
 
    # tell the result object how many tests will be running: (except if
2964
 
    # --parallel=fork is being used. Robert said he will provide a better
2965
 
    # progress design later -- vila 20090817)
2966
 
    if fork_decorator not in decorators:
2967
 
        decorators.append(CountingDecorator)
2968
 
    for decorator in decorators:
2969
 
        suite = decorator(suite)
2970
 
    if list_only:
2971
 
        # Done after test suite decoration to allow randomisation etc
2972
 
        # to take effect, though that is of marginal benefit.
2973
 
        if verbosity >= 2:
2974
 
            stream.write("Listing tests only ...\n")
2975
 
        for t in iter_suite_tests(suite):
2976
 
            stream.write("%s\n" % (t.id()))
2977
 
        return True
 
2502
        order_changer = preserve_input
 
2503
    if pattern != '.*' or random_order:
 
2504
        if matching_tests_first:
 
2505
            suites = map(order_changer, split_suite_by_re(suite, pattern))
 
2506
            suite = TestUtil.TestSuite(suites)
 
2507
        else:
 
2508
            suite = order_changer(filter_suite_by_re(suite, pattern))
 
2509
 
2978
2510
    result = runner.run(suite)
 
2511
 
2979
2512
    if strict:
2980
2513
        return result.wasStrictlySuccessful()
2981
 
    else:
2982
 
        return result.wasSuccessful()
2983
 
 
2984
 
 
2985
 
# A registry where get() returns a suite decorator.
2986
 
parallel_registry = registry.Registry()
2987
 
 
2988
 
 
2989
 
def fork_decorator(suite):
2990
 
    concurrency = osutils.local_concurrency()
2991
 
    if concurrency == 1:
2992
 
        return suite
2993
 
    from testtools import ConcurrentTestSuite
2994
 
    return ConcurrentTestSuite(suite, fork_for_tests)
2995
 
parallel_registry.register('fork', fork_decorator)
2996
 
 
2997
 
 
2998
 
def subprocess_decorator(suite):
2999
 
    concurrency = osutils.local_concurrency()
3000
 
    if concurrency == 1:
3001
 
        return suite
3002
 
    from testtools import ConcurrentTestSuite
3003
 
    return ConcurrentTestSuite(suite, reinvoke_for_tests)
3004
 
parallel_registry.register('subprocess', subprocess_decorator)
3005
 
 
3006
 
 
3007
 
def exclude_tests(exclude_pattern):
3008
 
    """Return a test suite decorator that excludes tests."""
3009
 
    if exclude_pattern is None:
3010
 
        return identity_decorator
3011
 
    def decorator(suite):
3012
 
        return ExcludeDecorator(suite, exclude_pattern)
3013
 
    return decorator
3014
 
 
3015
 
 
3016
 
def filter_tests(pattern):
3017
 
    if pattern == '.*':
3018
 
        return identity_decorator
3019
 
    def decorator(suite):
3020
 
        return FilterTestsDecorator(suite, pattern)
3021
 
    return decorator
3022
 
 
3023
 
 
3024
 
def random_order(random_seed, runner):
3025
 
    """Return a test suite decorator factory for randomising tests order.
3026
 
    
3027
 
    :param random_seed: now, a string which casts to a long, or a long.
3028
 
    :param runner: A test runner with a stream attribute to report on.
3029
 
    """
3030
 
    if random_seed is None:
3031
 
        return identity_decorator
3032
 
    def decorator(suite):
3033
 
        return RandomDecorator(suite, random_seed, runner.stream)
3034
 
    return decorator
3035
 
 
3036
 
 
3037
 
def tests_first(pattern):
3038
 
    if pattern == '.*':
3039
 
        return identity_decorator
3040
 
    def decorator(suite):
3041
 
        return TestFirstDecorator(suite, pattern)
3042
 
    return decorator
3043
 
 
3044
 
 
3045
 
def identity_decorator(suite):
3046
 
    """Return suite."""
3047
 
    return suite
3048
 
 
3049
 
 
3050
 
class TestDecorator(TestSuite):
3051
 
    """A decorator for TestCase/TestSuite objects.
3052
 
    
3053
 
    Usually, subclasses should override __iter__(used when flattening test
3054
 
    suites), which we do to filter, reorder, parallelise and so on, run() and
3055
 
    debug().
3056
 
    """
3057
 
 
3058
 
    def __init__(self, suite):
3059
 
        TestSuite.__init__(self)
3060
 
        self.addTest(suite)
3061
 
 
3062
 
    def countTestCases(self):
3063
 
        cases = 0
3064
 
        for test in self:
3065
 
            cases += test.countTestCases()
3066
 
        return cases
3067
 
 
3068
 
    def debug(self):
3069
 
        for test in self:
3070
 
            test.debug()
3071
 
 
3072
 
    def run(self, result):
3073
 
        # Use iteration on self, not self._tests, to allow subclasses to hook
3074
 
        # into __iter__.
3075
 
        for test in self:
3076
 
            if result.shouldStop:
3077
 
                break
3078
 
            test.run(result)
3079
 
        return result
3080
 
 
3081
 
 
3082
 
class CountingDecorator(TestDecorator):
3083
 
    """A decorator which calls result.progress(self.countTestCases)."""
3084
 
 
3085
 
    def run(self, result):
3086
 
        progress_method = getattr(result, 'progress', None)
3087
 
        if callable(progress_method):
3088
 
            progress_method(self.countTestCases(), SUBUNIT_SEEK_SET)
3089
 
        return super(CountingDecorator, self).run(result)
3090
 
 
3091
 
 
3092
 
class ExcludeDecorator(TestDecorator):
3093
 
    """A decorator which excludes test matching an exclude pattern."""
3094
 
 
3095
 
    def __init__(self, suite, exclude_pattern):
3096
 
        TestDecorator.__init__(self, suite)
3097
 
        self.exclude_pattern = exclude_pattern
3098
 
        self.excluded = False
3099
 
 
3100
 
    def __iter__(self):
3101
 
        if self.excluded:
3102
 
            return iter(self._tests)
3103
 
        self.excluded = True
3104
 
        suite = exclude_tests_by_re(self, self.exclude_pattern)
3105
 
        del self._tests[:]
3106
 
        self.addTests(suite)
3107
 
        return iter(self._tests)
3108
 
 
3109
 
 
3110
 
class FilterTestsDecorator(TestDecorator):
3111
 
    """A decorator which filters tests to those matching a pattern."""
3112
 
 
3113
 
    def __init__(self, suite, pattern):
3114
 
        TestDecorator.__init__(self, suite)
3115
 
        self.pattern = pattern
3116
 
        self.filtered = False
3117
 
 
3118
 
    def __iter__(self):
3119
 
        if self.filtered:
3120
 
            return iter(self._tests)
3121
 
        self.filtered = True
3122
 
        suite = filter_suite_by_re(self, self.pattern)
3123
 
        del self._tests[:]
3124
 
        self.addTests(suite)
3125
 
        return iter(self._tests)
3126
 
 
3127
 
 
3128
 
class RandomDecorator(TestDecorator):
3129
 
    """A decorator which randomises the order of its tests."""
3130
 
 
3131
 
    def __init__(self, suite, random_seed, stream):
3132
 
        TestDecorator.__init__(self, suite)
3133
 
        self.random_seed = random_seed
3134
 
        self.randomised = False
3135
 
        self.stream = stream
3136
 
 
3137
 
    def __iter__(self):
3138
 
        if self.randomised:
3139
 
            return iter(self._tests)
3140
 
        self.randomised = True
3141
 
        self.stream.write("Randomizing test order using seed %s\n\n" %
3142
 
            (self.actual_seed()))
3143
 
        # Initialise the random number generator.
3144
 
        random.seed(self.actual_seed())
3145
 
        suite = randomize_suite(self)
3146
 
        del self._tests[:]
3147
 
        self.addTests(suite)
3148
 
        return iter(self._tests)
3149
 
 
3150
 
    def actual_seed(self):
3151
 
        if self.random_seed == "now":
3152
 
            # We convert the seed to a long to make it reuseable across
3153
 
            # invocations (because the user can reenter it).
3154
 
            self.random_seed = long(time.time())
3155
 
        else:
3156
 
            # Convert the seed to a long if we can
3157
 
            try:
3158
 
                self.random_seed = long(self.random_seed)
3159
 
            except:
3160
 
                pass
3161
 
        return self.random_seed
3162
 
 
3163
 
 
3164
 
class TestFirstDecorator(TestDecorator):
3165
 
    """A decorator which moves named tests to the front."""
3166
 
 
3167
 
    def __init__(self, suite, pattern):
3168
 
        TestDecorator.__init__(self, suite)
3169
 
        self.pattern = pattern
3170
 
        self.filtered = False
3171
 
 
3172
 
    def __iter__(self):
3173
 
        if self.filtered:
3174
 
            return iter(self._tests)
3175
 
        self.filtered = True
3176
 
        suites = split_suite_by_re(self, self.pattern)
3177
 
        del self._tests[:]
3178
 
        self.addTests(suites)
3179
 
        return iter(self._tests)
3180
 
 
3181
 
 
3182
 
def partition_tests(suite, count):
3183
 
    """Partition suite into count lists of tests."""
3184
 
    result = []
3185
 
    tests = list(iter_suite_tests(suite))
3186
 
    tests_per_process = int(math.ceil(float(len(tests)) / count))
3187
 
    for block in range(count):
3188
 
        low_test = block * tests_per_process
3189
 
        high_test = low_test + tests_per_process
3190
 
        process_tests = tests[low_test:high_test]
3191
 
        result.append(process_tests)
3192
 
    return result
3193
 
 
3194
 
 
3195
 
def fork_for_tests(suite):
3196
 
    """Take suite and start up one runner per CPU by forking()
3197
 
 
3198
 
    :return: An iterable of TestCase-like objects which can each have
3199
 
        run(result) called on them to feed tests to result.
3200
 
    """
3201
 
    concurrency = osutils.local_concurrency()
3202
 
    result = []
3203
 
    from subunit import TestProtocolClient, ProtocolTestCase
3204
 
    from subunit.test_results import AutoTimingTestResultDecorator
3205
 
    class TestInOtherProcess(ProtocolTestCase):
3206
 
        # Should be in subunit, I think. RBC.
3207
 
        def __init__(self, stream, pid):
3208
 
            ProtocolTestCase.__init__(self, stream)
3209
 
            self.pid = pid
3210
 
 
3211
 
        def run(self, result):
3212
 
            try:
3213
 
                ProtocolTestCase.run(self, result)
3214
 
            finally:
3215
 
                os.waitpid(self.pid, os.WNOHANG)
3216
 
 
3217
 
    test_blocks = partition_tests(suite, concurrency)
3218
 
    for process_tests in test_blocks:
3219
 
        process_suite = TestSuite()
3220
 
        process_suite.addTests(process_tests)
3221
 
        c2pread, c2pwrite = os.pipe()
3222
 
        pid = os.fork()
3223
 
        if pid == 0:
3224
 
            try:
3225
 
                os.close(c2pread)
3226
 
                # Leave stderr and stdout open so we can see test noise
3227
 
                # Close stdin so that the child goes away if it decides to
3228
 
                # read from stdin (otherwise its a roulette to see what
3229
 
                # child actually gets keystrokes for pdb etc).
3230
 
                sys.stdin.close()
3231
 
                sys.stdin = None
3232
 
                stream = os.fdopen(c2pwrite, 'wb', 1)
3233
 
                subunit_result = AutoTimingTestResultDecorator(
3234
 
                    TestProtocolClient(stream))
3235
 
                process_suite.run(subunit_result)
3236
 
            finally:
3237
 
                os._exit(0)
3238
 
        else:
3239
 
            os.close(c2pwrite)
3240
 
            stream = os.fdopen(c2pread, 'rb', 1)
3241
 
            test = TestInOtherProcess(stream, pid)
3242
 
            result.append(test)
3243
 
    return result
3244
 
 
3245
 
 
3246
 
def reinvoke_for_tests(suite):
3247
 
    """Take suite and start up one runner per CPU using subprocess().
3248
 
 
3249
 
    :return: An iterable of TestCase-like objects which can each have
3250
 
        run(result) called on them to feed tests to result.
3251
 
    """
3252
 
    concurrency = osutils.local_concurrency()
3253
 
    result = []
3254
 
    from subunit import ProtocolTestCase
3255
 
    class TestInSubprocess(ProtocolTestCase):
3256
 
        def __init__(self, process, name):
3257
 
            ProtocolTestCase.__init__(self, process.stdout)
3258
 
            self.process = process
3259
 
            self.process.stdin.close()
3260
 
            self.name = name
3261
 
 
3262
 
        def run(self, result):
3263
 
            try:
3264
 
                ProtocolTestCase.run(self, result)
3265
 
            finally:
3266
 
                self.process.wait()
3267
 
                os.unlink(self.name)
3268
 
            # print "pid %d finished" % finished_process
3269
 
    test_blocks = partition_tests(suite, concurrency)
3270
 
    for process_tests in test_blocks:
3271
 
        # ugly; currently reimplement rather than reuses TestCase methods.
3272
 
        bzr_path = os.path.dirname(os.path.dirname(bzrlib.__file__))+'/bzr'
3273
 
        if not os.path.isfile(bzr_path):
3274
 
            # We are probably installed. Assume sys.argv is the right file
3275
 
            bzr_path = sys.argv[0]
3276
 
        bzr_path = [bzr_path]
3277
 
        if sys.platform == "win32":
3278
 
            # if we're on windows, we can't execute the bzr script directly
3279
 
            bzr_path = [sys.executable] + bzr_path
3280
 
        fd, test_list_file_name = tempfile.mkstemp()
3281
 
        test_list_file = os.fdopen(fd, 'wb', 1)
3282
 
        for test in process_tests:
3283
 
            test_list_file.write(test.id() + '\n')
3284
 
        test_list_file.close()
3285
 
        try:
3286
 
            argv = bzr_path + ['selftest', '--load-list', test_list_file_name,
3287
 
                '--subunit']
3288
 
            if '--no-plugins' in sys.argv:
3289
 
                argv.append('--no-plugins')
3290
 
            # stderr=STDOUT would be ideal, but until we prevent noise on
3291
 
            # stderr it can interrupt the subunit protocol.
3292
 
            process = Popen(argv, stdin=PIPE, stdout=PIPE, stderr=PIPE,
3293
 
                bufsize=1)
3294
 
            test = TestInSubprocess(process, test_list_file_name)
3295
 
            result.append(test)
3296
 
        except:
3297
 
            os.unlink(test_list_file_name)
3298
 
            raise
3299
 
    return result
3300
 
 
3301
 
 
3302
 
class ForwardingResult(unittest.TestResult):
3303
 
 
3304
 
    def __init__(self, target):
3305
 
        unittest.TestResult.__init__(self)
3306
 
        self.result = target
3307
 
 
3308
 
    def startTest(self, test):
3309
 
        self.result.startTest(test)
3310
 
 
3311
 
    def stopTest(self, test):
3312
 
        self.result.stopTest(test)
3313
 
 
3314
 
    def startTestRun(self):
3315
 
        self.result.startTestRun()
3316
 
 
3317
 
    def stopTestRun(self):
3318
 
        self.result.stopTestRun()
3319
 
 
3320
 
    def addSkip(self, test, reason):
3321
 
        self.result.addSkip(test, reason)
3322
 
 
3323
 
    def addSuccess(self, test):
3324
 
        self.result.addSuccess(test)
3325
 
 
3326
 
    def addError(self, test, err):
3327
 
        self.result.addError(test, err)
3328
 
 
3329
 
    def addFailure(self, test, err):
3330
 
        self.result.addFailure(test, err)
3331
 
ForwardingResult = testtools.ExtendedToOriginalDecorator
3332
 
 
3333
 
 
3334
 
class ProfileResult(ForwardingResult):
3335
 
    """Generate profiling data for all activity between start and success.
3336
 
    
3337
 
    The profile data is appended to the test's _benchcalls attribute and can
3338
 
    be accessed by the forwarded-to TestResult.
3339
 
 
3340
 
    While it might be cleaner do accumulate this in stopTest, addSuccess is
3341
 
    where our existing output support for lsprof is, and this class aims to
3342
 
    fit in with that: while it could be moved it's not necessary to accomplish
3343
 
    test profiling, nor would it be dramatically cleaner.
3344
 
    """
3345
 
 
3346
 
    def startTest(self, test):
3347
 
        self.profiler = bzrlib.lsprof.BzrProfiler()
3348
 
        self.profiler.start()
3349
 
        ForwardingResult.startTest(self, test)
3350
 
 
3351
 
    def addSuccess(self, test):
3352
 
        stats = self.profiler.stop()
3353
 
        try:
3354
 
            calls = test._benchcalls
3355
 
        except AttributeError:
3356
 
            test._benchcalls = []
3357
 
            calls = test._benchcalls
3358
 
        calls.append(((test.id(), "", ""), stats))
3359
 
        ForwardingResult.addSuccess(self, test)
3360
 
 
3361
 
    def stopTest(self, test):
3362
 
        ForwardingResult.stopTest(self, test)
3363
 
        self.profiler = None
 
2514
 
 
2515
    return result.wasSuccessful()
3364
2516
 
3365
2517
 
3366
2518
# Controlled by "bzr selftest -E=..." option
3367
 
# Currently supported:
3368
 
#   -Eallow_debug           Will no longer clear debug.debug_flags() so it
3369
 
#                           preserves any flags supplied at the command line.
3370
 
#   -Edisable_lock_checks   Turns errors in mismatched locks into simple prints
3371
 
#                           rather than failing tests. And no longer raise
3372
 
#                           LockContention when fctnl locks are not being used
3373
 
#                           with proper exclusion rules.
3374
2519
selftest_debug_flags = set()
3375
2520
 
3376
2521
 
3387
2532
             load_list=None,
3388
2533
             debug_flags=None,
3389
2534
             starting_with=None,
3390
 
             runner_class=None,
3391
 
             suite_decorators=None,
3392
 
             stream=None,
3393
 
             lsprof_tests=False,
3394
2535
             ):
3395
2536
    """Run the whole test suite under the enhanced runner"""
3396
2537
    # XXX: Very ugly way to do this...
3413
2554
            keep_only = None
3414
2555
        else:
3415
2556
            keep_only = load_test_id_list(load_list)
3416
 
        if starting_with:
3417
 
            starting_with = [test_prefix_alias_registry.resolve_alias(start)
3418
 
                             for start in starting_with]
3419
2557
        if test_suite_factory is None:
3420
 
            # Reduce loading time by loading modules based on the starting_with
3421
 
            # patterns.
3422
2558
            suite = test_suite(keep_only, starting_with)
3423
2559
        else:
3424
2560
            suite = test_suite_factory()
3425
 
        if starting_with:
3426
 
            # But always filter as requested.
3427
 
            suite = filter_suite_by_id_startswith(suite, starting_with)
3428
 
        result_decorators = []
3429
 
        if lsprof_tests:
3430
 
            result_decorators.append(ProfileResult)
3431
2561
        return run_suite(suite, 'testbzr', verbose=verbose, pattern=pattern,
3432
2562
                     stop_on_failure=stop_on_failure,
3433
2563
                     transport=transport,
3437
2567
                     list_only=list_only,
3438
2568
                     random_seed=random_seed,
3439
2569
                     exclude_pattern=exclude_pattern,
3440
 
                     strict=strict,
3441
 
                     runner_class=runner_class,
3442
 
                     suite_decorators=suite_decorators,
3443
 
                     stream=stream,
3444
 
                     result_decorators=result_decorators,
3445
 
                     )
 
2570
                     strict=strict)
3446
2571
    finally:
3447
2572
        default_transport = old_transport
3448
2573
        selftest_debug_flags = old_debug_flags
3475
2600
    """Warns about tests not appearing or appearing more than once.
3476
2601
 
3477
2602
    :param test_suite: A TestSuite object.
3478
 
    :param test_id_list: The list of test ids that should be found in
 
2603
    :param test_id_list: The list of test ids that should be found in 
3479
2604
         test_suite.
3480
2605
 
3481
2606
    :return: (absents, duplicates) absents is a list containing the test found
3595
2720
# appear prefixed ('bzrlib.' is "replaced" by 'bzrlib.').
3596
2721
test_prefix_alias_registry.register('bzrlib', 'bzrlib')
3597
2722
 
3598
 
# Obvious highest levels prefixes, feel free to add your own via a plugin
 
2723
# Obvious higest levels prefixes, feel free to add your own via a plugin
3599
2724
test_prefix_alias_registry.register('bd', 'bzrlib.doc')
3600
2725
test_prefix_alias_registry.register('bu', 'bzrlib.utils')
3601
2726
test_prefix_alias_registry.register('bt', 'bzrlib.tests')
3603
2728
test_prefix_alias_registry.register('bp', 'bzrlib.plugins')
3604
2729
 
3605
2730
 
3606
 
def _test_suite_testmod_names():
3607
 
    """Return the standard list of test module names to test."""
3608
 
    return [
3609
 
        'bzrlib.doc',
3610
 
        'bzrlib.tests.blackbox',
3611
 
        'bzrlib.tests.commands',
3612
 
        'bzrlib.tests.per_branch',
3613
 
        'bzrlib.tests.per_bzrdir',
3614
 
        'bzrlib.tests.per_bzrdir_colo',
3615
 
        'bzrlib.tests.per_foreign_vcs',
3616
 
        'bzrlib.tests.per_interrepository',
3617
 
        'bzrlib.tests.per_intertree',
3618
 
        'bzrlib.tests.per_inventory',
3619
 
        'bzrlib.tests.per_interbranch',
3620
 
        'bzrlib.tests.per_lock',
3621
 
        'bzrlib.tests.per_merger',
3622
 
        'bzrlib.tests.per_transport',
3623
 
        'bzrlib.tests.per_tree',
3624
 
        'bzrlib.tests.per_pack_repository',
3625
 
        'bzrlib.tests.per_repository',
3626
 
        'bzrlib.tests.per_repository_chk',
3627
 
        'bzrlib.tests.per_repository_reference',
3628
 
        'bzrlib.tests.per_uifactory',
3629
 
        'bzrlib.tests.per_versionedfile',
3630
 
        'bzrlib.tests.per_workingtree',
3631
 
        'bzrlib.tests.test__annotator',
3632
 
        'bzrlib.tests.test__bencode',
3633
 
        'bzrlib.tests.test__chk_map',
3634
 
        'bzrlib.tests.test__dirstate_helpers',
3635
 
        'bzrlib.tests.test__groupcompress',
3636
 
        'bzrlib.tests.test__known_graph',
3637
 
        'bzrlib.tests.test__rio',
3638
 
        'bzrlib.tests.test__simple_set',
3639
 
        'bzrlib.tests.test__static_tuple',
3640
 
        'bzrlib.tests.test__walkdirs_win32',
3641
 
        'bzrlib.tests.test_ancestry',
3642
 
        'bzrlib.tests.test_annotate',
3643
 
        'bzrlib.tests.test_api',
3644
 
        'bzrlib.tests.test_atomicfile',
3645
 
        'bzrlib.tests.test_bad_files',
3646
 
        'bzrlib.tests.test_bisect_multi',
3647
 
        'bzrlib.tests.test_branch',
3648
 
        'bzrlib.tests.test_branchbuilder',
3649
 
        'bzrlib.tests.test_btree_index',
3650
 
        'bzrlib.tests.test_bugtracker',
3651
 
        'bzrlib.tests.test_bundle',
3652
 
        'bzrlib.tests.test_bzrdir',
3653
 
        'bzrlib.tests.test__chunks_to_lines',
3654
 
        'bzrlib.tests.test_cache_utf8',
3655
 
        'bzrlib.tests.test_chk_map',
3656
 
        'bzrlib.tests.test_chk_serializer',
3657
 
        'bzrlib.tests.test_chunk_writer',
3658
 
        'bzrlib.tests.test_clean_tree',
3659
 
        'bzrlib.tests.test_cleanup',
3660
 
        'bzrlib.tests.test_cmdline',
3661
 
        'bzrlib.tests.test_commands',
3662
 
        'bzrlib.tests.test_commit',
3663
 
        'bzrlib.tests.test_commit_merge',
3664
 
        'bzrlib.tests.test_config',
3665
 
        'bzrlib.tests.test_conflicts',
3666
 
        'bzrlib.tests.test_counted_lock',
3667
 
        'bzrlib.tests.test_crash',
3668
 
        'bzrlib.tests.test_decorators',
3669
 
        'bzrlib.tests.test_delta',
3670
 
        'bzrlib.tests.test_debug',
3671
 
        'bzrlib.tests.test_deprecated_graph',
3672
 
        'bzrlib.tests.test_diff',
3673
 
        'bzrlib.tests.test_directory_service',
3674
 
        'bzrlib.tests.test_dirstate',
3675
 
        'bzrlib.tests.test_email_message',
3676
 
        'bzrlib.tests.test_eol_filters',
3677
 
        'bzrlib.tests.test_errors',
3678
 
        'bzrlib.tests.test_export',
3679
 
        'bzrlib.tests.test_extract',
3680
 
        'bzrlib.tests.test_fetch',
3681
 
        'bzrlib.tests.test_fifo_cache',
3682
 
        'bzrlib.tests.test_filters',
3683
 
        'bzrlib.tests.test_ftp_transport',
3684
 
        'bzrlib.tests.test_foreign',
3685
 
        'bzrlib.tests.test_generate_docs',
3686
 
        'bzrlib.tests.test_generate_ids',
3687
 
        'bzrlib.tests.test_globbing',
3688
 
        'bzrlib.tests.test_gpg',
3689
 
        'bzrlib.tests.test_graph',
3690
 
        'bzrlib.tests.test_groupcompress',
3691
 
        'bzrlib.tests.test_hashcache',
3692
 
        'bzrlib.tests.test_help',
3693
 
        'bzrlib.tests.test_hooks',
3694
 
        'bzrlib.tests.test_http',
3695
 
        'bzrlib.tests.test_http_response',
3696
 
        'bzrlib.tests.test_https_ca_bundle',
3697
 
        'bzrlib.tests.test_identitymap',
3698
 
        'bzrlib.tests.test_ignores',
3699
 
        'bzrlib.tests.test_index',
3700
 
        'bzrlib.tests.test_import_tariff',
3701
 
        'bzrlib.tests.test_info',
3702
 
        'bzrlib.tests.test_inv',
3703
 
        'bzrlib.tests.test_inventory_delta',
3704
 
        'bzrlib.tests.test_knit',
3705
 
        'bzrlib.tests.test_lazy_import',
3706
 
        'bzrlib.tests.test_lazy_regex',
3707
 
        'bzrlib.tests.test_lock',
3708
 
        'bzrlib.tests.test_lockable_files',
3709
 
        'bzrlib.tests.test_lockdir',
3710
 
        'bzrlib.tests.test_log',
3711
 
        'bzrlib.tests.test_lru_cache',
3712
 
        'bzrlib.tests.test_lsprof',
3713
 
        'bzrlib.tests.test_mail_client',
3714
 
        'bzrlib.tests.test_memorytree',
3715
 
        'bzrlib.tests.test_merge',
3716
 
        'bzrlib.tests.test_merge3',
3717
 
        'bzrlib.tests.test_merge_core',
3718
 
        'bzrlib.tests.test_merge_directive',
3719
 
        'bzrlib.tests.test_missing',
3720
 
        'bzrlib.tests.test_msgeditor',
3721
 
        'bzrlib.tests.test_multiparent',
3722
 
        'bzrlib.tests.test_mutabletree',
3723
 
        'bzrlib.tests.test_nonascii',
3724
 
        'bzrlib.tests.test_options',
3725
 
        'bzrlib.tests.test_osutils',
3726
 
        'bzrlib.tests.test_osutils_encodings',
3727
 
        'bzrlib.tests.test_pack',
3728
 
        'bzrlib.tests.test_patch',
3729
 
        'bzrlib.tests.test_patches',
3730
 
        'bzrlib.tests.test_permissions',
3731
 
        'bzrlib.tests.test_plugins',
3732
 
        'bzrlib.tests.test_progress',
3733
 
        'bzrlib.tests.test_read_bundle',
3734
 
        'bzrlib.tests.test_reconcile',
3735
 
        'bzrlib.tests.test_reconfigure',
3736
 
        'bzrlib.tests.test_registry',
3737
 
        'bzrlib.tests.test_remote',
3738
 
        'bzrlib.tests.test_rename_map',
3739
 
        'bzrlib.tests.test_repository',
3740
 
        'bzrlib.tests.test_revert',
3741
 
        'bzrlib.tests.test_revision',
3742
 
        'bzrlib.tests.test_revisionspec',
3743
 
        'bzrlib.tests.test_revisiontree',
3744
 
        'bzrlib.tests.test_rio',
3745
 
        'bzrlib.tests.test_rules',
3746
 
        'bzrlib.tests.test_sampler',
3747
 
        'bzrlib.tests.test_script',
3748
 
        'bzrlib.tests.test_selftest',
3749
 
        'bzrlib.tests.test_serializer',
3750
 
        'bzrlib.tests.test_setup',
3751
 
        'bzrlib.tests.test_sftp_transport',
3752
 
        'bzrlib.tests.test_shelf',
3753
 
        'bzrlib.tests.test_shelf_ui',
3754
 
        'bzrlib.tests.test_smart',
3755
 
        'bzrlib.tests.test_smart_add',
3756
 
        'bzrlib.tests.test_smart_request',
3757
 
        'bzrlib.tests.test_smart_transport',
3758
 
        'bzrlib.tests.test_smtp_connection',
3759
 
        'bzrlib.tests.test_source',
3760
 
        'bzrlib.tests.test_ssh_transport',
3761
 
        'bzrlib.tests.test_status',
3762
 
        'bzrlib.tests.test_store',
3763
 
        'bzrlib.tests.test_strace',
3764
 
        'bzrlib.tests.test_subsume',
3765
 
        'bzrlib.tests.test_switch',
3766
 
        'bzrlib.tests.test_symbol_versioning',
3767
 
        'bzrlib.tests.test_tag',
3768
 
        'bzrlib.tests.test_testament',
3769
 
        'bzrlib.tests.test_textfile',
3770
 
        'bzrlib.tests.test_textmerge',
3771
 
        'bzrlib.tests.test_timestamp',
3772
 
        'bzrlib.tests.test_trace',
3773
 
        'bzrlib.tests.test_transactions',
3774
 
        'bzrlib.tests.test_transform',
3775
 
        'bzrlib.tests.test_transport',
3776
 
        'bzrlib.tests.test_transport_log',
3777
 
        'bzrlib.tests.test_tree',
3778
 
        'bzrlib.tests.test_treebuilder',
3779
 
        'bzrlib.tests.test_tsort',
3780
 
        'bzrlib.tests.test_tuned_gzip',
3781
 
        'bzrlib.tests.test_ui',
3782
 
        'bzrlib.tests.test_uncommit',
3783
 
        'bzrlib.tests.test_upgrade',
3784
 
        'bzrlib.tests.test_upgrade_stacked',
3785
 
        'bzrlib.tests.test_urlutils',
3786
 
        'bzrlib.tests.test_version',
3787
 
        'bzrlib.tests.test_version_info',
3788
 
        'bzrlib.tests.test_weave',
3789
 
        'bzrlib.tests.test_whitebox',
3790
 
        'bzrlib.tests.test_win32utils',
3791
 
        'bzrlib.tests.test_workingtree',
3792
 
        'bzrlib.tests.test_workingtree_4',
3793
 
        'bzrlib.tests.test_wsgi',
3794
 
        'bzrlib.tests.test_xml',
3795
 
        ]
3796
 
 
3797
 
 
3798
 
def _test_suite_modules_to_doctest():
3799
 
    """Return the list of modules to doctest."""   
3800
 
    return [
3801
 
        'bzrlib',
3802
 
        'bzrlib.branchbuilder',
3803
 
        'bzrlib.decorators',
3804
 
        'bzrlib.export',
3805
 
        'bzrlib.inventory',
3806
 
        'bzrlib.iterablefile',
3807
 
        'bzrlib.lockdir',
3808
 
        'bzrlib.merge3',
3809
 
        'bzrlib.option',
3810
 
        'bzrlib.symbol_versioning',
3811
 
        'bzrlib.tests',
3812
 
        'bzrlib.timestamp',
3813
 
        'bzrlib.version_info_formats.format_custom',
3814
 
        ]
3815
 
 
3816
 
 
3817
2731
def test_suite(keep_only=None, starting_with=None):
3818
2732
    """Build and return TestSuite for the whole of bzrlib.
3819
2733
 
3825
2739
    This function can be replaced if you need to change the default test
3826
2740
    suite on a global basis, but it is not encouraged.
3827
2741
    """
 
2742
    testmod_names = [
 
2743
                   'bzrlib.doc',
 
2744
                   'bzrlib.util.tests.test_bencode',
 
2745
                   'bzrlib.tests.blackbox',
 
2746
                   'bzrlib.tests.branch_implementations',
 
2747
                   'bzrlib.tests.bzrdir_implementations',
 
2748
                   'bzrlib.tests.commands',
 
2749
                   'bzrlib.tests.inventory_implementations',
 
2750
                   'bzrlib.tests.interrepository_implementations',
 
2751
                   'bzrlib.tests.intertree_implementations',
 
2752
                   'bzrlib.tests.per_lock',
 
2753
                   'bzrlib.tests.repository_implementations',
 
2754
                   'bzrlib.tests.test__dirstate_helpers',
 
2755
                   'bzrlib.tests.test_ancestry',
 
2756
                   'bzrlib.tests.test_annotate',
 
2757
                   'bzrlib.tests.test_api',
 
2758
                   'bzrlib.tests.test_atomicfile',
 
2759
                   'bzrlib.tests.test_bad_files',
 
2760
                   'bzrlib.tests.test_bisect_multi',
 
2761
                   'bzrlib.tests.test_branch',
 
2762
                   'bzrlib.tests.test_branchbuilder',
 
2763
                   'bzrlib.tests.test_btree_index',
 
2764
                   'bzrlib.tests.test_bugtracker',
 
2765
                   'bzrlib.tests.test_bundle',
 
2766
                   'bzrlib.tests.test_bzrdir',
 
2767
                   'bzrlib.tests.test_cache_utf8',
 
2768
                   'bzrlib.tests.test_chunk_writer',
 
2769
                   'bzrlib.tests.test_commands',
 
2770
                   'bzrlib.tests.test_commit',
 
2771
                   'bzrlib.tests.test_commit_merge',
 
2772
                   'bzrlib.tests.test_config',
 
2773
                   'bzrlib.tests.test_conflicts',
 
2774
                   'bzrlib.tests.test_counted_lock',
 
2775
                   'bzrlib.tests.test_decorators',
 
2776
                   'bzrlib.tests.test_delta',
 
2777
                   'bzrlib.tests.test_deprecated_graph',
 
2778
                   'bzrlib.tests.test_diff',
 
2779
                   'bzrlib.tests.test_dirstate',
 
2780
                   'bzrlib.tests.test_directory_service',
 
2781
                   'bzrlib.tests.test_email_message',
 
2782
                   'bzrlib.tests.test_errors',
 
2783
                   'bzrlib.tests.test_extract',
 
2784
                   'bzrlib.tests.test_fetch',
 
2785
                   'bzrlib.tests.test_ftp_transport',
 
2786
                   'bzrlib.tests.test_generate_docs',
 
2787
                   'bzrlib.tests.test_generate_ids',
 
2788
                   'bzrlib.tests.test_globbing',
 
2789
                   'bzrlib.tests.test_gpg',
 
2790
                   'bzrlib.tests.test_graph',
 
2791
                   'bzrlib.tests.test_hashcache',
 
2792
                   'bzrlib.tests.test_help',
 
2793
                   'bzrlib.tests.test_hooks',
 
2794
                   'bzrlib.tests.test_http',
 
2795
                   'bzrlib.tests.test_http_implementations',
 
2796
                   'bzrlib.tests.test_http_response',
 
2797
                   'bzrlib.tests.test_https_ca_bundle',
 
2798
                   'bzrlib.tests.test_identitymap',
 
2799
                   'bzrlib.tests.test_ignores',
 
2800
                   'bzrlib.tests.test_index',
 
2801
                   'bzrlib.tests.test_info',
 
2802
                   'bzrlib.tests.test_inv',
 
2803
                   'bzrlib.tests.test_knit',
 
2804
                   'bzrlib.tests.test_lazy_import',
 
2805
                   'bzrlib.tests.test_lazy_regex',
 
2806
                   'bzrlib.tests.test_lockdir',
 
2807
                   'bzrlib.tests.test_lockable_files',
 
2808
                   'bzrlib.tests.test_log',
 
2809
                   'bzrlib.tests.test_lsprof',
 
2810
                   'bzrlib.tests.test_lru_cache',
 
2811
                   'bzrlib.tests.test_mail_client',
 
2812
                   'bzrlib.tests.test_memorytree',
 
2813
                   'bzrlib.tests.test_merge',
 
2814
                   'bzrlib.tests.test_merge3',
 
2815
                   'bzrlib.tests.test_merge_core',
 
2816
                   'bzrlib.tests.test_merge_directive',
 
2817
                   'bzrlib.tests.test_missing',
 
2818
                   'bzrlib.tests.test_msgeditor',
 
2819
                   'bzrlib.tests.test_multiparent',
 
2820
                   'bzrlib.tests.test_mutabletree',
 
2821
                   'bzrlib.tests.test_nonascii',
 
2822
                   'bzrlib.tests.test_options',
 
2823
                   'bzrlib.tests.test_osutils',
 
2824
                   'bzrlib.tests.test_osutils_encodings',
 
2825
                   'bzrlib.tests.test_pack',
 
2826
                   'bzrlib.tests.test_pack_repository',
 
2827
                   'bzrlib.tests.test_patch',
 
2828
                   'bzrlib.tests.test_patches',
 
2829
                   'bzrlib.tests.test_permissions',
 
2830
                   'bzrlib.tests.test_plugins',
 
2831
                   'bzrlib.tests.test_progress',
 
2832
                   'bzrlib.tests.test_read_bundle',
 
2833
                   'bzrlib.tests.test_reconfigure',
 
2834
                   'bzrlib.tests.test_reconcile',
 
2835
                   'bzrlib.tests.test_registry',
 
2836
                   'bzrlib.tests.test_remote',
 
2837
                   'bzrlib.tests.test_repository',
 
2838
                   'bzrlib.tests.per_repository_reference',
 
2839
                   'bzrlib.tests.test_revert',
 
2840
                   'bzrlib.tests.test_revision',
 
2841
                   'bzrlib.tests.test_revisionspec',
 
2842
                   'bzrlib.tests.test_revisiontree',
 
2843
                   'bzrlib.tests.test_rio',
 
2844
                   'bzrlib.tests.test_rules',
 
2845
                   'bzrlib.tests.test_sampler',
 
2846
                   'bzrlib.tests.test_selftest',
 
2847
                   'bzrlib.tests.test_setup',
 
2848
                   'bzrlib.tests.test_sftp_transport',
 
2849
                   'bzrlib.tests.test_smart',
 
2850
                   'bzrlib.tests.test_smart_add',
 
2851
                   'bzrlib.tests.test_smart_transport',
 
2852
                   'bzrlib.tests.test_smtp_connection',
 
2853
                   'bzrlib.tests.test_source',
 
2854
                   'bzrlib.tests.test_ssh_transport',
 
2855
                   'bzrlib.tests.test_status',
 
2856
                   'bzrlib.tests.test_store',
 
2857
                   'bzrlib.tests.test_strace',
 
2858
                   'bzrlib.tests.test_subsume',
 
2859
                   'bzrlib.tests.test_switch',
 
2860
                   'bzrlib.tests.test_symbol_versioning',
 
2861
                   'bzrlib.tests.test_tag',
 
2862
                   'bzrlib.tests.test_testament',
 
2863
                   'bzrlib.tests.test_textfile',
 
2864
                   'bzrlib.tests.test_textmerge',
 
2865
                   'bzrlib.tests.test_timestamp',
 
2866
                   'bzrlib.tests.test_trace',
 
2867
                   'bzrlib.tests.test_transactions',
 
2868
                   'bzrlib.tests.test_transform',
 
2869
                   'bzrlib.tests.test_transport',
 
2870
                   'bzrlib.tests.test_transport_implementations',
 
2871
                   'bzrlib.tests.test_transport_log',
 
2872
                   'bzrlib.tests.test_tree',
 
2873
                   'bzrlib.tests.test_treebuilder',
 
2874
                   'bzrlib.tests.test_tsort',
 
2875
                   'bzrlib.tests.test_tuned_gzip',
 
2876
                   'bzrlib.tests.test_ui',
 
2877
                   'bzrlib.tests.test_uncommit',
 
2878
                   'bzrlib.tests.test_upgrade',
 
2879
                   'bzrlib.tests.test_upgrade_stacked',
 
2880
                   'bzrlib.tests.test_urlutils',
 
2881
                   'bzrlib.tests.test_versionedfile',
 
2882
                   'bzrlib.tests.test_version',
 
2883
                   'bzrlib.tests.test_version_info',
 
2884
                   'bzrlib.tests.test__walkdirs_win32',
 
2885
                   'bzrlib.tests.test_weave',
 
2886
                   'bzrlib.tests.test_whitebox',
 
2887
                   'bzrlib.tests.test_win32utils',
 
2888
                   'bzrlib.tests.test_workingtree',
 
2889
                   'bzrlib.tests.test_workingtree_4',
 
2890
                   'bzrlib.tests.test_wsgi',
 
2891
                   'bzrlib.tests.test_xml',
 
2892
                   'bzrlib.tests.tree_implementations',
 
2893
                   'bzrlib.tests.workingtree_implementations',
 
2894
                   ]
3828
2895
 
3829
2896
    loader = TestUtil.TestLoader()
3830
2897
 
3831
 
    if keep_only is not None:
3832
 
        id_filter = TestIdList(keep_only)
3833
2898
    if starting_with:
 
2899
        starting_with = [test_prefix_alias_registry.resolve_alias(start)
 
2900
                         for start in starting_with]
3834
2901
        # We take precedence over keep_only because *at loading time* using
3835
2902
        # both options means we will load less tests for the same final result.
3836
2903
        def interesting_module(name):
3846
2913
        loader = TestUtil.FilteredByModuleTestLoader(interesting_module)
3847
2914
 
3848
2915
    elif keep_only is not None:
 
2916
        id_filter = TestIdList(keep_only)
3849
2917
        loader = TestUtil.FilteredByModuleTestLoader(id_filter.refers_to)
3850
2918
        def interesting_module(name):
3851
2919
            return id_filter.refers_to(name)
3859
2927
    suite = loader.suiteClass()
3860
2928
 
3861
2929
    # modules building their suite with loadTestsFromModuleNames
3862
 
    suite.addTest(loader.loadTestsFromModuleNames(_test_suite_testmod_names()))
3863
 
 
3864
 
    for mod in _test_suite_modules_to_doctest():
 
2930
    suite.addTest(loader.loadTestsFromModuleNames(testmod_names))
 
2931
 
 
2932
    modules_to_doctest = [
 
2933
        'bzrlib',
 
2934
        'bzrlib.errors',
 
2935
        'bzrlib.export',
 
2936
        'bzrlib.inventory',
 
2937
        'bzrlib.iterablefile',
 
2938
        'bzrlib.lockdir',
 
2939
        'bzrlib.merge3',
 
2940
        'bzrlib.option',
 
2941
        'bzrlib.store',
 
2942
        'bzrlib.symbol_versioning',
 
2943
        'bzrlib.tests',
 
2944
        'bzrlib.timestamp',
 
2945
        'bzrlib.version_info_formats.format_custom',
 
2946
        ]
 
2947
 
 
2948
    for mod in modules_to_doctest:
3865
2949
        if not interesting_module(mod):
3866
2950
            # No tests to keep here, move along
3867
2951
            continue
3868
2952
        try:
3869
 
            # note that this really does mean "report only" -- doctest
3870
 
            # still runs the rest of the examples
3871
 
            doc_suite = doctest.DocTestSuite(mod,
3872
 
                optionflags=doctest.REPORT_ONLY_FIRST_FAILURE)
 
2953
            doc_suite = doctest.DocTestSuite(mod)
3873
2954
        except ValueError, e:
3874
2955
            print '**failed to get doctest for: %s\n%s' % (mod, e)
3875
2956
            raise
3876
 
        if len(doc_suite._tests) == 0:
3877
 
            raise errors.BzrError("no doctests found in %s" % (mod,))
3878
2957
        suite.addTest(doc_suite)
3879
2958
 
3880
2959
    default_encoding = sys.getdefaultencoding()
3896
2975
            reload(sys)
3897
2976
            sys.setdefaultencoding(default_encoding)
3898
2977
 
 
2978
    if starting_with:
 
2979
        suite = filter_suite_by_id_startswith(suite, starting_with)
 
2980
 
3899
2981
    if keep_only is not None:
3900
2982
        # Now that the referred modules have loaded their tests, keep only the
3901
2983
        # requested ones.
3918
3000
    return suite
3919
3001
 
3920
3002
 
 
3003
def multiply_tests_from_modules(module_name_list, scenario_iter, loader=None):
 
3004
    """Adapt all tests in some given modules to given scenarios.
 
3005
 
 
3006
    This is the recommended public interface for test parameterization.
 
3007
    Typically the test_suite() method for a per-implementation test
 
3008
    suite will call multiply_tests_from_modules and return the 
 
3009
    result.
 
3010
 
 
3011
    :param module_name_list: List of fully-qualified names of test
 
3012
        modules.
 
3013
    :param scenario_iter: Iterable of pairs of (scenario_name, 
 
3014
        scenario_param_dict).
 
3015
    :param loader: If provided, will be used instead of a new 
 
3016
        bzrlib.tests.TestLoader() instance.
 
3017
 
 
3018
    This returns a new TestSuite containing the cross product of
 
3019
    all the tests in all the modules, each repeated for each scenario.
 
3020
    Each test is adapted by adding the scenario name at the end 
 
3021
    of its name, and updating the test object's __dict__ with the
 
3022
    scenario_param_dict.
 
3023
 
 
3024
    >>> r = multiply_tests_from_modules(
 
3025
    ...     ['bzrlib.tests.test_sampler'],
 
3026
    ...     [('one', dict(param=1)), 
 
3027
    ...      ('two', dict(param=2))])
 
3028
    >>> tests = list(iter_suite_tests(r))
 
3029
    >>> len(tests)
 
3030
    2
 
3031
    >>> tests[0].id()
 
3032
    'bzrlib.tests.test_sampler.DemoTest.test_nothing(one)'
 
3033
    >>> tests[0].param
 
3034
    1
 
3035
    >>> tests[1].param
 
3036
    2
 
3037
    """
 
3038
    # XXX: Isn't load_tests() a better way to provide the same functionality
 
3039
    # without forcing a predefined TestScenarioApplier ? --vila 080215
 
3040
    if loader is None:
 
3041
        loader = TestUtil.TestLoader()
 
3042
 
 
3043
    suite = loader.suiteClass()
 
3044
 
 
3045
    adapter = TestScenarioApplier()
 
3046
    adapter.scenarios = list(scenario_iter)
 
3047
    adapt_modules(module_name_list, adapter, loader, suite)
 
3048
    return suite
 
3049
 
 
3050
 
3921
3051
def multiply_scenarios(scenarios_left, scenarios_right):
3922
3052
    """Multiply two sets of scenarios.
3923
3053
 
3932
3062
        for right_name, right_dict in scenarios_right]
3933
3063
 
3934
3064
 
3935
 
def multiply_tests(tests, scenarios, result):
3936
 
    """Multiply tests_list by scenarios into result.
3937
 
 
3938
 
    This is the core workhorse for test parameterisation.
3939
 
 
3940
 
    Typically the load_tests() method for a per-implementation test suite will
3941
 
    call multiply_tests and return the result.
3942
 
 
3943
 
    :param tests: The tests to parameterise.
3944
 
    :param scenarios: The scenarios to apply: pairs of (scenario_name,
3945
 
        scenario_param_dict).
3946
 
    :param result: A TestSuite to add created tests to.
3947
 
 
3948
 
    This returns the passed in result TestSuite with the cross product of all
3949
 
    the tests repeated once for each scenario.  Each test is adapted by adding
3950
 
    the scenario name at the end of its id(), and updating the test object's
3951
 
    __dict__ with the scenario_param_dict.
3952
 
 
3953
 
    >>> import bzrlib.tests.test_sampler
3954
 
    >>> r = multiply_tests(
3955
 
    ...     bzrlib.tests.test_sampler.DemoTest('test_nothing'),
3956
 
    ...     [('one', dict(param=1)),
3957
 
    ...      ('two', dict(param=2))],
3958
 
    ...     TestSuite())
3959
 
    >>> tests = list(iter_suite_tests(r))
3960
 
    >>> len(tests)
3961
 
    2
3962
 
    >>> tests[0].id()
3963
 
    'bzrlib.tests.test_sampler.DemoTest.test_nothing(one)'
3964
 
    >>> tests[0].param
3965
 
    1
3966
 
    >>> tests[1].param
3967
 
    2
3968
 
    """
3969
 
    for test in iter_suite_tests(tests):
3970
 
        apply_scenarios(test, scenarios, result)
3971
 
    return result
3972
 
 
3973
 
 
3974
 
def apply_scenarios(test, scenarios, result):
3975
 
    """Apply the scenarios in scenarios to test and add to result.
3976
 
 
3977
 
    :param test: The test to apply scenarios to.
3978
 
    :param scenarios: An iterable of scenarios to apply to test.
3979
 
    :return: result
3980
 
    :seealso: apply_scenario
3981
 
    """
3982
 
    for scenario in scenarios:
3983
 
        result.addTest(apply_scenario(test, scenario))
3984
 
    return result
3985
 
 
3986
 
 
3987
 
def apply_scenario(test, scenario):
3988
 
    """Copy test and apply scenario to it.
3989
 
 
3990
 
    :param test: A test to adapt.
3991
 
    :param scenario: A tuple describing the scenarion.
3992
 
        The first element of the tuple is the new test id.
3993
 
        The second element is a dict containing attributes to set on the
3994
 
        test.
3995
 
    :return: The adapted test.
3996
 
    """
3997
 
    new_id = "%s(%s)" % (test.id(), scenario[0])
3998
 
    new_test = clone_test(test, new_id)
3999
 
    for name, value in scenario[1].items():
4000
 
        setattr(new_test, name, value)
4001
 
    return new_test
4002
 
 
4003
 
 
4004
 
def clone_test(test, new_id):
4005
 
    """Clone a test giving it a new id.
4006
 
 
4007
 
    :param test: The test to clone.
4008
 
    :param new_id: The id to assign to it.
4009
 
    :return: The new test.
4010
 
    """
4011
 
    new_test = copy(test)
4012
 
    new_test.id = lambda: new_id
4013
 
    return new_test
4014
 
 
4015
 
 
4016
 
def permute_tests_for_extension(standard_tests, loader, py_module_name,
4017
 
                                ext_module_name):
4018
 
    """Helper for permutating tests against an extension module.
4019
 
 
4020
 
    This is meant to be used inside a modules 'load_tests()' function. It will
4021
 
    create 2 scenarios, and cause all tests in the 'standard_tests' to be run
4022
 
    against both implementations. Setting 'test.module' to the appropriate
4023
 
    module. See bzrlib.tests.test__chk_map.load_tests as an example.
4024
 
 
4025
 
    :param standard_tests: A test suite to permute
4026
 
    :param loader: A TestLoader
4027
 
    :param py_module_name: The python path to a python module that can always
4028
 
        be loaded, and will be considered the 'python' implementation. (eg
4029
 
        'bzrlib._chk_map_py')
4030
 
    :param ext_module_name: The python path to an extension module. If the
4031
 
        module cannot be loaded, a single test will be added, which notes that
4032
 
        the module is not available. If it can be loaded, all standard_tests
4033
 
        will be run against that module.
4034
 
    :return: (suite, feature) suite is a test-suite that has all the permuted
4035
 
        tests. feature is the Feature object that can be used to determine if
4036
 
        the module is available.
4037
 
    """
4038
 
 
4039
 
    py_module = __import__(py_module_name, {}, {}, ['NO_SUCH_ATTRIB'])
4040
 
    scenarios = [
4041
 
        ('python', {'module': py_module}),
4042
 
    ]
4043
 
    suite = loader.suiteClass()
4044
 
    feature = ModuleAvailableFeature(ext_module_name)
4045
 
    if feature.available():
4046
 
        scenarios.append(('C', {'module': feature.module}))
4047
 
    else:
4048
 
        # the compiled module isn't available, so we add a failing test
4049
 
        class FailWithoutFeature(TestCase):
4050
 
            def test_fail(self):
4051
 
                self.requireFeature(feature)
4052
 
        suite.addTest(loader.loadTestsFromTestCase(FailWithoutFeature))
4053
 
    result = multiply_tests(standard_tests, scenarios, suite)
4054
 
    return result, feature
4055
 
 
4056
 
 
4057
 
def _rmtree_temp_dir(dirname, test_id=None):
 
3065
 
 
3066
def adapt_modules(mods_list, adapter, loader, suite):
 
3067
    """Adapt the modules in mods_list using adapter and add to suite."""
 
3068
    tests = loader.loadTestsFromModuleNames(mods_list)
 
3069
    adapt_tests(tests, adapter, suite)
 
3070
 
 
3071
 
 
3072
def adapt_tests(tests_list, adapter, suite):
 
3073
    """Adapt the tests in tests_list using adapter and add to suite."""
 
3074
    for test in iter_suite_tests(tests_list):
 
3075
        suite.addTests(adapter.adapt(test))
 
3076
 
 
3077
 
 
3078
def _rmtree_temp_dir(dirname):
4058
3079
    # If LANG=C we probably have created some bogus paths
4059
3080
    # which rmtree(unicode) will fail to delete
4060
3081
    # so make sure we are using rmtree(str) to delete everything
4069
3090
    try:
4070
3091
        osutils.rmtree(dirname)
4071
3092
    except OSError, e:
4072
 
        # We don't want to fail here because some useful display will be lost
4073
 
        # otherwise. Polluting the tmp dir is bad, but not giving all the
4074
 
        # possible info to the test runner is even worse.
4075
 
        if test_id != None:
4076
 
            ui.ui_factory.clear_term()
4077
 
            sys.stderr.write('\nWhile running: %s\n' % (test_id,))
4078
 
        sys.stderr.write('Unable to remove testing dir %s\n%s'
4079
 
                         % (os.path.basename(dirname), e))
 
3093
        if sys.platform == 'win32' and e.errno == errno.EACCES:
 
3094
            sys.stderr.write(('Permission denied: '
 
3095
                                 'unable to remove testing dir '
 
3096
                                 '%s\n' % os.path.basename(dirname)))
 
3097
        else:
 
3098
            raise
4080
3099
 
4081
3100
 
4082
3101
class Feature(object):
4164
3183
UnicodeFilenameFeature = _UnicodeFilenameFeature()
4165
3184
 
4166
3185
 
4167
 
class _CompatabilityThunkFeature(Feature):
4168
 
    """This feature is just a thunk to another feature.
4169
 
 
4170
 
    It issues a deprecation warning if it is accessed, to let you know that you
4171
 
    should really use a different feature.
4172
 
    """
4173
 
 
4174
 
    def __init__(self, dep_version, module, name,
4175
 
                 replacement_name, replacement_module=None):
4176
 
        super(_CompatabilityThunkFeature, self).__init__()
4177
 
        self._module = module
4178
 
        if replacement_module is None:
4179
 
            replacement_module = module
4180
 
        self._replacement_module = replacement_module
4181
 
        self._name = name
4182
 
        self._replacement_name = replacement_name
4183
 
        self._dep_version = dep_version
4184
 
        self._feature = None
4185
 
 
4186
 
    def _ensure(self):
4187
 
        if self._feature is None:
4188
 
            depr_msg = self._dep_version % ('%s.%s'
4189
 
                                            % (self._module, self._name))
4190
 
            use_msg = ' Use %s.%s instead.' % (self._replacement_module,
4191
 
                                               self._replacement_name)
4192
 
            symbol_versioning.warn(depr_msg + use_msg, DeprecationWarning)
4193
 
            # Import the new feature and use it as a replacement for the
4194
 
            # deprecated one.
4195
 
            mod = __import__(self._replacement_module, {}, {},
4196
 
                             [self._replacement_name])
4197
 
            self._feature = getattr(mod, self._replacement_name)
4198
 
 
4199
 
    def _probe(self):
4200
 
        self._ensure()
4201
 
        return self._feature._probe()
4202
 
 
4203
 
 
4204
 
class ModuleAvailableFeature(Feature):
4205
 
    """This is a feature than describes a module we want to be available.
4206
 
 
4207
 
    Declare the name of the module in __init__(), and then after probing, the
4208
 
    module will be available as 'self.module'.
4209
 
 
4210
 
    :ivar module: The module if it is available, else None.
4211
 
    """
4212
 
 
4213
 
    def __init__(self, module_name):
4214
 
        super(ModuleAvailableFeature, self).__init__()
4215
 
        self.module_name = module_name
4216
 
 
4217
 
    def _probe(self):
4218
 
        try:
4219
 
            self._module = __import__(self.module_name, {}, {}, [''])
4220
 
            return True
4221
 
        except ImportError:
4222
 
            return False
4223
 
 
4224
 
    @property
4225
 
    def module(self):
4226
 
        if self.available(): # Make sure the probe has been done
4227
 
            return self._module
4228
 
        return None
4229
 
 
4230
 
    def feature_name(self):
4231
 
        return self.module_name
4232
 
 
4233
 
 
4234
 
# This is kept here for compatibility, it is recommended to use
4235
 
# 'bzrlib.tests.feature.paramiko' instead
4236
 
ParamikoFeature = _CompatabilityThunkFeature(
4237
 
    deprecated_in((2,1,0)),
4238
 
    'bzrlib.tests.features', 'ParamikoFeature', 'paramiko')
 
3186
class TestScenarioApplier(object):
 
3187
    """A tool to apply scenarios to tests."""
 
3188
 
 
3189
    def adapt(self, test):
 
3190
        """Return a TestSuite containing a copy of test for each scenario."""
 
3191
        result = unittest.TestSuite()
 
3192
        for scenario in self.scenarios:
 
3193
            result.addTest(self.adapt_test_to_scenario(test, scenario))
 
3194
        return result
 
3195
 
 
3196
    def adapt_test_to_scenario(self, test, scenario):
 
3197
        """Copy test and apply scenario to it.
 
3198
 
 
3199
        :param test: A test to adapt.
 
3200
        :param scenario: A tuple describing the scenarion.
 
3201
            The first element of the tuple is the new test id.
 
3202
            The second element is a dict containing attributes to set on the
 
3203
            test.
 
3204
        :return: The adapted test.
 
3205
        """
 
3206
        from copy import deepcopy
 
3207
        new_test = deepcopy(test)
 
3208
        for name, value in scenario[1].items():
 
3209
            setattr(new_test, name, value)
 
3210
        new_id = "%s(%s)" % (new_test.id(), scenario[0])
 
3211
        new_test.id = lambda: new_id
 
3212
        return new_test
4239
3213
 
4240
3214
 
4241
3215
def probe_unicode_in_user_encoding():
4247
3221
    possible_vals = [u'm\xb5', u'\xe1', u'\u0410']
4248
3222
    for uni_val in possible_vals:
4249
3223
        try:
4250
 
            str_val = uni_val.encode(osutils.get_user_encoding())
 
3224
            str_val = uni_val.encode(bzrlib.user_encoding)
4251
3225
        except UnicodeEncodeError:
4252
3226
            # Try a different character
4253
3227
            pass
4271
3245
    return None
4272
3246
 
4273
3247
 
4274
 
class _HTTPSServerFeature(Feature):
4275
 
    """Some tests want an https Server, check if one is available.
 
3248
class _FTPServerFeature(Feature):
 
3249
    """Some tests want an FTP Server, check if one is available.
4276
3250
 
4277
 
    Right now, the only way this is available is under python2.6 which provides
4278
 
    an ssl module.
 
3251
    Right now, the only way this is available is if 'medusa' is installed.
 
3252
    http://www.amk.ca/python/code/medusa.html
4279
3253
    """
4280
3254
 
4281
3255
    def _probe(self):
4282
3256
        try:
4283
 
            import ssl
 
3257
            import bzrlib.tests.ftp_server
4284
3258
            return True
4285
3259
        except ImportError:
4286
3260
            return False
4287
3261
 
4288
3262
    def feature_name(self):
4289
 
        return 'HTTPSServer'
4290
 
 
4291
 
 
4292
 
HTTPSServerFeature = _HTTPSServerFeature()
 
3263
        return 'FTPServer'
 
3264
 
 
3265
FTPServerFeature = _FTPServerFeature()
4293
3266
 
4294
3267
 
4295
3268
class _UnicodeFilename(Feature):
4323
3296
UTF8Filesystem = _UTF8Filesystem()
4324
3297
 
4325
3298
 
4326
 
class _BreakinFeature(Feature):
4327
 
    """Does this platform support the breakin feature?"""
4328
 
 
4329
 
    def _probe(self):
4330
 
        from bzrlib import breakin
4331
 
        if breakin.determine_signal() is None:
4332
 
            return False
4333
 
        if sys.platform == 'win32':
4334
 
            # Windows doesn't have os.kill, and we catch the SIGBREAK signal.
4335
 
            # We trigger SIGBREAK via a Console api so we need ctypes to
4336
 
            # access the function
4337
 
            try:
4338
 
                import ctypes
4339
 
            except OSError:
4340
 
                return False
4341
 
        return True
4342
 
 
4343
 
    def feature_name(self):
4344
 
        return "SIGQUIT or SIGBREAK w/ctypes on win32"
4345
 
 
4346
 
 
4347
 
BreakinFeature = _BreakinFeature()
4348
 
 
4349
 
 
4350
 
class _CaseInsCasePresFilenameFeature(Feature):
4351
 
    """Is the file-system case insensitive, but case-preserving?"""
4352
 
 
4353
 
    def _probe(self):
4354
 
        fileno, name = tempfile.mkstemp(prefix='MixedCase')
4355
 
        try:
4356
 
            # first check truly case-preserving for created files, then check
4357
 
            # case insensitive when opening existing files.
4358
 
            name = osutils.normpath(name)
4359
 
            base, rel = osutils.split(name)
4360
 
            found_rel = osutils.canonical_relpath(base, name)
4361
 
            return (found_rel == rel
4362
 
                    and os.path.isfile(name.upper())
4363
 
                    and os.path.isfile(name.lower()))
4364
 
        finally:
4365
 
            os.close(fileno)
4366
 
            os.remove(name)
4367
 
 
4368
 
    def feature_name(self):
4369
 
        return "case-insensitive case-preserving filesystem"
4370
 
 
4371
 
CaseInsCasePresFilenameFeature = _CaseInsCasePresFilenameFeature()
4372
 
 
4373
 
 
4374
3299
class _CaseInsensitiveFilesystemFeature(Feature):
4375
 
    """Check if underlying filesystem is case-insensitive but *not* case
4376
 
    preserving.
 
3300
    """Check if underlying filesystem is case-insensitive
 
3301
    (e.g. on Windows, Cygwin, MacOS)
4377
3302
    """
4378
 
    # Note that on Windows, Cygwin, MacOS etc, the file-systems are far
4379
 
    # more likely to be case preserving, so this case is rare.
4380
3303
 
4381
3304
    def _probe(self):
4382
 
        if CaseInsCasePresFilenameFeature.available():
4383
 
            return False
4384
 
 
4385
3305
        if TestCaseWithMemoryTransport.TEST_ROOT is None:
4386
3306
            root = osutils.mkdtemp(prefix='testbzr-', suffix='.tmp')
4387
3307
            TestCaseWithMemoryTransport.TEST_ROOT = root
4400
3320
        return 'case-insensitive filesystem'
4401
3321
 
4402
3322
CaseInsensitiveFilesystemFeature = _CaseInsensitiveFilesystemFeature()
4403
 
 
4404
 
 
4405
 
class _CaseSensitiveFilesystemFeature(Feature):
4406
 
 
4407
 
    def _probe(self):
4408
 
        if CaseInsCasePresFilenameFeature.available():
4409
 
            return False
4410
 
        elif CaseInsensitiveFilesystemFeature.available():
4411
 
            return False
4412
 
        else:
4413
 
            return True
4414
 
 
4415
 
    def feature_name(self):
4416
 
        return 'case-sensitive filesystem'
4417
 
 
4418
 
# new coding style is for feature instances to be lowercase
4419
 
case_sensitive_filesystem_feature = _CaseSensitiveFilesystemFeature()
4420
 
 
4421
 
 
4422
 
# Kept for compatibility, use bzrlib.tests.features.subunit instead
4423
 
SubUnitFeature = _CompatabilityThunkFeature(
4424
 
    deprecated_in((2,1,0)),
4425
 
    'bzrlib.tests.features', 'SubUnitFeature', 'subunit')
4426
 
# Only define SubUnitBzrRunner if subunit is available.
4427
 
try:
4428
 
    from subunit import TestProtocolClient
4429
 
    from subunit.test_results import AutoTimingTestResultDecorator
4430
 
    class SubUnitBzrRunner(TextTestRunner):
4431
 
        def run(self, test):
4432
 
            result = AutoTimingTestResultDecorator(
4433
 
                TestProtocolClient(self.stream))
4434
 
            test.run(result)
4435
 
            return result
4436
 
except ImportError:
4437
 
    pass