~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/__init__.py

  • Committer: Alexander Belchenko
  • Date: 2007-01-24 13:03:32 UTC
  • mto: This revision was merged to the branch mainline in revision 2242.
  • Revision ID: bialix@ukr.net-20070124130332-ane2eqz3eqrtm9u1
Use new API for testing

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
# Copyright (C) 2005, 2006 Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
 
 
18
# TODO: Perhaps there should be an API to find out if bzr running under the
 
19
# test suite -- some plugins might want to avoid making intrusive changes if
 
20
# this is the case.  However, we want behaviour under to test to diverge as
 
21
# little as possible, so this should be used rarely if it's added at all.
 
22
# (Suggestion from j-a-meinel, 2005-11-24)
 
23
 
 
24
# NOTE: Some classes in here use camelCaseNaming() rather than
 
25
# underscore_naming().  That's for consistency with unittest; it's not the
 
26
# general style of bzrlib.  Please continue that consistency when adding e.g.
 
27
# new assertFoo() methods.
 
28
 
 
29
import codecs
 
30
from cStringIO import StringIO
 
31
import difflib
 
32
import doctest
 
33
import errno
 
34
import logging
 
35
import os
 
36
import re
 
37
import shlex
 
38
import stat
 
39
from subprocess import Popen, PIPE
 
40
import sys
 
41
import tempfile
 
42
import unittest
 
43
import time
 
44
 
 
45
 
 
46
from bzrlib import (
 
47
    bzrdir,
 
48
    debug,
 
49
    errors,
 
50
    memorytree,
 
51
    osutils,
 
52
    progress,
 
53
    urlutils,
 
54
    )
 
55
import bzrlib.branch
 
56
import bzrlib.commands
 
57
import bzrlib.bundle.serializer
 
58
import bzrlib.export
 
59
import bzrlib.inventory
 
60
import bzrlib.iterablefile
 
61
import bzrlib.lockdir
 
62
try:
 
63
    import bzrlib.lsprof
 
64
except ImportError:
 
65
    # lsprof not available
 
66
    pass
 
67
from bzrlib.merge import merge_inner
 
68
import bzrlib.merge3
 
69
import bzrlib.osutils
 
70
import bzrlib.plugin
 
71
from bzrlib.revision import common_ancestor
 
72
import bzrlib.store
 
73
from bzrlib import symbol_versioning
 
74
import bzrlib.trace
 
75
from bzrlib.transport import get_transport
 
76
import bzrlib.transport
 
77
from bzrlib.transport.local import LocalURLServer
 
78
from bzrlib.transport.memory import MemoryServer
 
79
from bzrlib.transport.readonly import ReadonlyServer
 
80
from bzrlib.trace import mutter, note
 
81
from bzrlib.tests import TestUtil
 
82
from bzrlib.tests.HttpServer import HttpServer
 
83
from bzrlib.tests.TestUtil import (
 
84
                          TestSuite,
 
85
                          TestLoader,
 
86
                          )
 
87
from bzrlib.tests.treeshape import build_tree_contents
 
88
from bzrlib.workingtree import WorkingTree, WorkingTreeFormat2
 
89
 
 
90
default_transport = LocalURLServer
 
91
 
 
92
MODULES_TO_TEST = []
 
93
MODULES_TO_DOCTEST = [
 
94
                      bzrlib.bundle.serializer,
 
95
                      bzrlib.errors,
 
96
                      bzrlib.export,
 
97
                      bzrlib.inventory,
 
98
                      bzrlib.iterablefile,
 
99
                      bzrlib.lockdir,
 
100
                      bzrlib.merge3,
 
101
                      bzrlib.option,
 
102
                      bzrlib.store,
 
103
                      ]
 
104
 
 
105
 
 
106
def packages_to_test():
 
107
    """Return a list of packages to test.
 
108
 
 
109
    The packages are not globally imported so that import failures are
 
110
    triggered when running selftest, not when importing the command.
 
111
    """
 
112
    import bzrlib.doc
 
113
    import bzrlib.tests.blackbox
 
114
    import bzrlib.tests.branch_implementations
 
115
    import bzrlib.tests.bzrdir_implementations
 
116
    import bzrlib.tests.interrepository_implementations
 
117
    import bzrlib.tests.interversionedfile_implementations
 
118
    import bzrlib.tests.intertree_implementations
 
119
    import bzrlib.tests.repository_implementations
 
120
    import bzrlib.tests.revisionstore_implementations
 
121
    import bzrlib.tests.tree_implementations
 
122
    import bzrlib.tests.workingtree_implementations
 
123
    return [
 
124
            bzrlib.doc,
 
125
            bzrlib.tests.blackbox,
 
126
            bzrlib.tests.branch_implementations,
 
127
            bzrlib.tests.bzrdir_implementations,
 
128
            bzrlib.tests.interrepository_implementations,
 
129
            bzrlib.tests.interversionedfile_implementations,
 
130
            bzrlib.tests.intertree_implementations,
 
131
            bzrlib.tests.repository_implementations,
 
132
            bzrlib.tests.revisionstore_implementations,
 
133
            bzrlib.tests.tree_implementations,
 
134
            bzrlib.tests.workingtree_implementations,
 
135
            ]
 
136
 
 
137
 
 
138
class ExtendedTestResult(unittest._TextTestResult):
 
139
    """Accepts, reports and accumulates the results of running tests.
 
140
 
 
141
    Compared to this unittest version this class adds support for profiling,
 
142
    benchmarking, stopping as soon as a test fails,  and skipping tests.
 
143
    There are further-specialized subclasses for different types of display.
 
144
    """
 
145
 
 
146
    stop_early = False
 
147
    
 
148
    def __init__(self, stream, descriptions, verbosity,
 
149
                 bench_history=None,
 
150
                 num_tests=None,
 
151
                 ):
 
152
        """Construct new TestResult.
 
153
 
 
154
        :param bench_history: Optionally, a writable file object to accumulate
 
155
            benchmark results.
 
156
        """
 
157
        unittest._TextTestResult.__init__(self, stream, descriptions, verbosity)
 
158
        if bench_history is not None:
 
159
            from bzrlib.version import _get_bzr_source_tree
 
160
            src_tree = _get_bzr_source_tree()
 
161
            if src_tree:
 
162
                try:
 
163
                    revision_id = src_tree.get_parent_ids()[0]
 
164
                except IndexError:
 
165
                    # XXX: if this is a brand new tree, do the same as if there
 
166
                    # is no branch.
 
167
                    revision_id = ''
 
168
            else:
 
169
                # XXX: If there's no branch, what should we do?
 
170
                revision_id = ''
 
171
            bench_history.write("--date %s %s\n" % (time.time(), revision_id))
 
172
        self._bench_history = bench_history
 
173
        self.ui = bzrlib.ui.ui_factory
 
174
        self.num_tests = num_tests
 
175
        self.error_count = 0
 
176
        self.failure_count = 0
 
177
        self.skip_count = 0
 
178
        self.count = 0
 
179
        self._overall_start_time = time.time()
 
180
    
 
181
    def extractBenchmarkTime(self, testCase):
 
182
        """Add a benchmark time for the current test case."""
 
183
        self._benchmarkTime = getattr(testCase, "_benchtime", None)
 
184
    
 
185
    def _elapsedTestTimeString(self):
 
186
        """Return a time string for the overall time the current test has taken."""
 
187
        return self._formatTime(time.time() - self._start_time)
 
188
 
 
189
    def _testTimeString(self):
 
190
        if self._benchmarkTime is not None:
 
191
            return "%s/%s" % (
 
192
                self._formatTime(self._benchmarkTime),
 
193
                self._elapsedTestTimeString())
 
194
        else:
 
195
            return "           %s" % self._elapsedTestTimeString()
 
196
 
 
197
    def _formatTime(self, seconds):
 
198
        """Format seconds as milliseconds with leading spaces."""
 
199
        # some benchmarks can take thousands of seconds to run, so we need 8
 
200
        # places
 
201
        return "%8dms" % (1000 * seconds)
 
202
 
 
203
    def _shortened_test_description(self, test):
 
204
        what = test.id()
 
205
        what = re.sub(r'^bzrlib\.(tests|benchmarks)\.', '', what)
 
206
        return what
 
207
 
 
208
    def startTest(self, test):
 
209
        unittest.TestResult.startTest(self, test)
 
210
        self.report_test_start(test)
 
211
        self._recordTestStartTime()
 
212
 
 
213
    def _recordTestStartTime(self):
 
214
        """Record that a test has started."""
 
215
        self._start_time = time.time()
 
216
 
 
217
    def addError(self, test, err):
 
218
        if isinstance(err[1], TestSkipped):
 
219
            return self.addSkipped(test, err)    
 
220
        unittest.TestResult.addError(self, test, err)
 
221
        # We can only do this if we have one of our TestCases, not if
 
222
        # we have a doctest.
 
223
        setKeepLogfile = getattr(test, 'setKeepLogfile', None)
 
224
        if setKeepLogfile is not None:
 
225
            setKeepLogfile()
 
226
        self.extractBenchmarkTime(test)
 
227
        self.report_error(test, err)
 
228
        if self.stop_early:
 
229
            self.stop()
 
230
 
 
231
    def addFailure(self, test, err):
 
232
        unittest.TestResult.addFailure(self, test, err)
 
233
        # We can only do this if we have one of our TestCases, not if
 
234
        # we have a doctest.
 
235
        setKeepLogfile = getattr(test, 'setKeepLogfile', None)
 
236
        if setKeepLogfile is not None:
 
237
            setKeepLogfile()
 
238
        self.extractBenchmarkTime(test)
 
239
        self.report_failure(test, err)
 
240
        if self.stop_early:
 
241
            self.stop()
 
242
 
 
243
    def addSuccess(self, test):
 
244
        self.extractBenchmarkTime(test)
 
245
        if self._bench_history is not None:
 
246
            if self._benchmarkTime is not None:
 
247
                self._bench_history.write("%s %s\n" % (
 
248
                    self._formatTime(self._benchmarkTime),
 
249
                    test.id()))
 
250
        self.report_success(test)
 
251
        unittest.TestResult.addSuccess(self, test)
 
252
 
 
253
    def addSkipped(self, test, skip_excinfo):
 
254
        self.extractBenchmarkTime(test)
 
255
        self.report_skip(test, skip_excinfo)
 
256
        # seems best to treat this as success from point-of-view of unittest
 
257
        # -- it actually does nothing so it barely matters :)
 
258
        try:
 
259
            test.tearDown()
 
260
        except KeyboardInterrupt:
 
261
            raise
 
262
        except:
 
263
            self.addError(test, test.__exc_info())
 
264
        else:
 
265
            unittest.TestResult.addSuccess(self, test)
 
266
 
 
267
    def printErrorList(self, flavour, errors):
 
268
        for test, err in errors:
 
269
            self.stream.writeln(self.separator1)
 
270
            self.stream.writeln("%s: %s" % (flavour, self.getDescription(test)))
 
271
            if getattr(test, '_get_log', None) is not None:
 
272
                print >>self.stream
 
273
                print >>self.stream, \
 
274
                        ('vvvv[log from %s]' % test.id()).ljust(78,'-')
 
275
                print >>self.stream, test._get_log()
 
276
                print >>self.stream, \
 
277
                        ('^^^^[log from %s]' % test.id()).ljust(78,'-')
 
278
            self.stream.writeln(self.separator2)
 
279
            self.stream.writeln("%s" % err)
 
280
 
 
281
    def finished(self):
 
282
        pass
 
283
 
 
284
    def report_cleaning_up(self):
 
285
        pass
 
286
 
 
287
    def report_success(self, test):
 
288
        pass
 
289
 
 
290
 
 
291
class TextTestResult(ExtendedTestResult):
 
292
    """Displays progress and results of tests in text form"""
 
293
 
 
294
    def __init__(self, *args, **kw):
 
295
        ExtendedTestResult.__init__(self, *args, **kw)
 
296
        self.pb = self.ui.nested_progress_bar()
 
297
        self.pb.show_pct = False
 
298
        self.pb.show_spinner = False
 
299
        self.pb.show_eta = False, 
 
300
        self.pb.show_count = False
 
301
        self.pb.show_bar = False
 
302
 
 
303
    def report_starting(self):
 
304
        self.pb.update('[test 0/%d] starting...' % (self.num_tests))
 
305
 
 
306
    def _progress_prefix_text(self):
 
307
        a = '[%d' % self.count
 
308
        if self.num_tests is not None:
 
309
            a +='/%d' % self.num_tests
 
310
        a += ' in %ds' % (time.time() - self._overall_start_time)
 
311
        if self.error_count:
 
312
            a += ', %d errors' % self.error_count
 
313
        if self.failure_count:
 
314
            a += ', %d failed' % self.failure_count
 
315
        if self.skip_count:
 
316
            a += ', %d skipped' % self.skip_count
 
317
        a += ']'
 
318
        return a
 
319
 
 
320
    def report_test_start(self, test):
 
321
        self.count += 1
 
322
        self.pb.update(
 
323
                self._progress_prefix_text()
 
324
                + ' ' 
 
325
                + self._shortened_test_description(test))
 
326
 
 
327
    def report_error(self, test, err):
 
328
        self.error_count += 1
 
329
        self.pb.note('ERROR: %s\n    %s\n', 
 
330
            self._shortened_test_description(test),
 
331
            err[1],
 
332
            )
 
333
 
 
334
    def report_failure(self, test, err):
 
335
        self.failure_count += 1
 
336
        self.pb.note('FAIL: %s\n    %s\n', 
 
337
            self._shortened_test_description(test),
 
338
            err[1],
 
339
            )
 
340
 
 
341
    def report_skip(self, test, skip_excinfo):
 
342
        self.skip_count += 1
 
343
        if False:
 
344
            # at the moment these are mostly not things we can fix
 
345
            # and so they just produce stipple; use the verbose reporter
 
346
            # to see them.
 
347
            if False:
 
348
                # show test and reason for skip
 
349
                self.pb.note('SKIP: %s\n    %s\n', 
 
350
                    self._shortened_test_description(test),
 
351
                    skip_excinfo[1])
 
352
            else:
 
353
                # since the class name was left behind in the still-visible
 
354
                # progress bar...
 
355
                self.pb.note('SKIP: %s', skip_excinfo[1])
 
356
 
 
357
    def report_cleaning_up(self):
 
358
        self.pb.update('cleaning up...')
 
359
 
 
360
    def finished(self):
 
361
        self.pb.finished()
 
362
 
 
363
 
 
364
class VerboseTestResult(ExtendedTestResult):
 
365
    """Produce long output, with one line per test run plus times"""
 
366
 
 
367
    def _ellipsize_to_right(self, a_string, final_width):
 
368
        """Truncate and pad a string, keeping the right hand side"""
 
369
        if len(a_string) > final_width:
 
370
            result = '...' + a_string[3-final_width:]
 
371
        else:
 
372
            result = a_string
 
373
        return result.ljust(final_width)
 
374
 
 
375
    def report_starting(self):
 
376
        self.stream.write('running %d tests...\n' % self.num_tests)
 
377
 
 
378
    def report_test_start(self, test):
 
379
        self.count += 1
 
380
        name = self._shortened_test_description(test)
 
381
        # width needs space for 6 char status, plus 1 for slash, plus 2 10-char
 
382
        # numbers, plus a trailing blank
 
383
        self.stream.write(self._ellipsize_to_right(name,
 
384
                            osutils.terminal_width()-30))
 
385
        self.stream.flush()
 
386
 
 
387
    def report_error(self, test, err):
 
388
        self.error_count += 1
 
389
        self.stream.writeln('ERROR %s\n    %s' 
 
390
                % (self._testTimeString(), err[1]))
 
391
 
 
392
    def report_failure(self, test, err):
 
393
        self.failure_count += 1
 
394
        self.stream.writeln(' FAIL %s\n    %s'
 
395
                % (self._testTimeString(), err[1]))
 
396
 
 
397
    def report_success(self, test):
 
398
        self.stream.writeln('   OK %s' % self._testTimeString())
 
399
        for bench_called, stats in getattr(test, '_benchcalls', []):
 
400
            self.stream.writeln('LSProf output for %s(%s, %s)' % bench_called)
 
401
            stats.pprint(file=self.stream)
 
402
        self.stream.flush()
 
403
 
 
404
    def report_skip(self, test, skip_excinfo):
 
405
        print >>self.stream, ' SKIP %s' % self._testTimeString()
 
406
        print >>self.stream, '     %s' % skip_excinfo[1]
 
407
 
 
408
 
 
409
class TextTestRunner(object):
 
410
    stop_on_failure = False
 
411
 
 
412
    def __init__(self,
 
413
                 stream=sys.stderr,
 
414
                 descriptions=0,
 
415
                 verbosity=1,
 
416
                 keep_output=False,
 
417
                 bench_history=None):
 
418
        self.stream = unittest._WritelnDecorator(stream)
 
419
        self.descriptions = descriptions
 
420
        self.verbosity = verbosity
 
421
        self.keep_output = keep_output
 
422
        self._bench_history = bench_history
 
423
 
 
424
    def run(self, test):
 
425
        "Run the given test case or test suite."
 
426
        startTime = time.time()
 
427
        if self.verbosity == 1:
 
428
            result_class = TextTestResult
 
429
        elif self.verbosity >= 2:
 
430
            result_class = VerboseTestResult
 
431
        result = result_class(self.stream,
 
432
                              self.descriptions,
 
433
                              self.verbosity,
 
434
                              bench_history=self._bench_history,
 
435
                              num_tests=test.countTestCases(),
 
436
                              )
 
437
        result.stop_early = self.stop_on_failure
 
438
        result.report_starting()
 
439
        test.run(result)
 
440
        stopTime = time.time()
 
441
        timeTaken = stopTime - startTime
 
442
        result.printErrors()
 
443
        self.stream.writeln(result.separator2)
 
444
        run = result.testsRun
 
445
        self.stream.writeln("Ran %d test%s in %.3fs" %
 
446
                            (run, run != 1 and "s" or "", timeTaken))
 
447
        self.stream.writeln()
 
448
        if not result.wasSuccessful():
 
449
            self.stream.write("FAILED (")
 
450
            failed, errored = map(len, (result.failures, result.errors))
 
451
            if failed:
 
452
                self.stream.write("failures=%d" % failed)
 
453
            if errored:
 
454
                if failed: self.stream.write(", ")
 
455
                self.stream.write("errors=%d" % errored)
 
456
            self.stream.writeln(")")
 
457
        else:
 
458
            self.stream.writeln("OK")
 
459
        result.report_cleaning_up()
 
460
        # This is still a little bogus, 
 
461
        # but only a little. Folk not using our testrunner will
 
462
        # have to delete their temp directories themselves.
 
463
        test_root = TestCaseWithMemoryTransport.TEST_ROOT
 
464
        if result.wasSuccessful() or not self.keep_output:
 
465
            if test_root is not None:
 
466
                # If LANG=C we probably have created some bogus paths
 
467
                # which rmtree(unicode) will fail to delete
 
468
                # so make sure we are using rmtree(str) to delete everything
 
469
                # except on win32, where rmtree(str) will fail
 
470
                # since it doesn't have the property of byte-stream paths
 
471
                # (they are either ascii or mbcs)
 
472
                if sys.platform == 'win32':
 
473
                    # make sure we are using the unicode win32 api
 
474
                    test_root = unicode(test_root)
 
475
                else:
 
476
                    test_root = test_root.encode(
 
477
                        sys.getfilesystemencoding())
 
478
                osutils.rmtree(test_root)
 
479
        else:
 
480
            note("Failed tests working directories are in '%s'\n", test_root)
 
481
        TestCaseWithMemoryTransport.TEST_ROOT = None
 
482
        result.finished()
 
483
        return result
 
484
 
 
485
 
 
486
def iter_suite_tests(suite):
 
487
    """Return all tests in a suite, recursing through nested suites"""
 
488
    for item in suite._tests:
 
489
        if isinstance(item, unittest.TestCase):
 
490
            yield item
 
491
        elif isinstance(item, unittest.TestSuite):
 
492
            for r in iter_suite_tests(item):
 
493
                yield r
 
494
        else:
 
495
            raise Exception('unknown object %r inside test suite %r'
 
496
                            % (item, suite))
 
497
 
 
498
 
 
499
class TestSkipped(Exception):
 
500
    """Indicates that a test was intentionally skipped, rather than failing."""
 
501
 
 
502
 
 
503
class CommandFailed(Exception):
 
504
    pass
 
505
 
 
506
 
 
507
class StringIOWrapper(object):
 
508
    """A wrapper around cStringIO which just adds an encoding attribute.
 
509
    
 
510
    Internally we can check sys.stdout to see what the output encoding
 
511
    should be. However, cStringIO has no encoding attribute that we can
 
512
    set. So we wrap it instead.
 
513
    """
 
514
    encoding='ascii'
 
515
    _cstring = None
 
516
 
 
517
    def __init__(self, s=None):
 
518
        if s is not None:
 
519
            self.__dict__['_cstring'] = StringIO(s)
 
520
        else:
 
521
            self.__dict__['_cstring'] = StringIO()
 
522
 
 
523
    def __getattr__(self, name, getattr=getattr):
 
524
        return getattr(self.__dict__['_cstring'], name)
 
525
 
 
526
    def __setattr__(self, name, val):
 
527
        if name == 'encoding':
 
528
            self.__dict__['encoding'] = val
 
529
        else:
 
530
            return setattr(self._cstring, name, val)
 
531
 
 
532
 
 
533
class TestCase(unittest.TestCase):
 
534
    """Base class for bzr unit tests.
 
535
    
 
536
    Tests that need access to disk resources should subclass 
 
537
    TestCaseInTempDir not TestCase.
 
538
 
 
539
    Error and debug log messages are redirected from their usual
 
540
    location into a temporary file, the contents of which can be
 
541
    retrieved by _get_log().  We use a real OS file, not an in-memory object,
 
542
    so that it can also capture file IO.  When the test completes this file
 
543
    is read into memory and removed from disk.
 
544
       
 
545
    There are also convenience functions to invoke bzr's command-line
 
546
    routine, and to build and check bzr trees.
 
547
   
 
548
    In addition to the usual method of overriding tearDown(), this class also
 
549
    allows subclasses to register functions into the _cleanups list, which is
 
550
    run in order as the object is torn down.  It's less likely this will be
 
551
    accidentally overlooked.
 
552
    """
 
553
 
 
554
    _log_file_name = None
 
555
    _log_contents = ''
 
556
    _keep_log_file = False
 
557
    # record lsprof data when performing benchmark calls.
 
558
    _gather_lsprof_in_benchmarks = False
 
559
 
 
560
    def __init__(self, methodName='testMethod'):
 
561
        super(TestCase, self).__init__(methodName)
 
562
        self._cleanups = []
 
563
 
 
564
    def setUp(self):
 
565
        unittest.TestCase.setUp(self)
 
566
        self._cleanEnvironment()
 
567
        bzrlib.trace.disable_default_logging()
 
568
        self._silenceUI()
 
569
        self._startLogFile()
 
570
        self._benchcalls = []
 
571
        self._benchtime = None
 
572
 
 
573
    def _silenceUI(self):
 
574
        """Turn off UI for duration of test"""
 
575
        # by default the UI is off; tests can turn it on if they want it.
 
576
        saved = bzrlib.ui.ui_factory
 
577
        def _restore():
 
578
            bzrlib.ui.ui_factory = saved
 
579
        bzrlib.ui.ui_factory = bzrlib.ui.SilentUIFactory()
 
580
        self.addCleanup(_restore)
 
581
 
 
582
    def _ndiff_strings(self, a, b):
 
583
        """Return ndiff between two strings containing lines.
 
584
        
 
585
        A trailing newline is added if missing to make the strings
 
586
        print properly."""
 
587
        if b and b[-1] != '\n':
 
588
            b += '\n'
 
589
        if a and a[-1] != '\n':
 
590
            a += '\n'
 
591
        difflines = difflib.ndiff(a.splitlines(True),
 
592
                                  b.splitlines(True),
 
593
                                  linejunk=lambda x: False,
 
594
                                  charjunk=lambda x: False)
 
595
        return ''.join(difflines)
 
596
 
 
597
    def assertEqualDiff(self, a, b, message=None):
 
598
        """Assert two texts are equal, if not raise an exception.
 
599
        
 
600
        This is intended for use with multi-line strings where it can 
 
601
        be hard to find the differences by eye.
 
602
        """
 
603
        # TODO: perhaps override assertEquals to call this for strings?
 
604
        if a == b:
 
605
            return
 
606
        if message is None:
 
607
            message = "texts not equal:\n"
 
608
        raise AssertionError(message + 
 
609
                             self._ndiff_strings(a, b))      
 
610
        
 
611
    def assertEqualMode(self, mode, mode_test):
 
612
        self.assertEqual(mode, mode_test,
 
613
                         'mode mismatch %o != %o' % (mode, mode_test))
 
614
 
 
615
    def assertStartsWith(self, s, prefix):
 
616
        if not s.startswith(prefix):
 
617
            raise AssertionError('string %r does not start with %r' % (s, prefix))
 
618
 
 
619
    def assertEndsWith(self, s, suffix):
 
620
        """Asserts that s ends with suffix."""
 
621
        if not s.endswith(suffix):
 
622
            raise AssertionError('string %r does not end with %r' % (s, suffix))
 
623
 
 
624
    def assertContainsRe(self, haystack, needle_re):
 
625
        """Assert that a contains something matching a regular expression."""
 
626
        if not re.search(needle_re, haystack):
 
627
            raise AssertionError('pattern "%s" not found in "%s"'
 
628
                    % (needle_re, haystack))
 
629
 
 
630
    def assertNotContainsRe(self, haystack, needle_re):
 
631
        """Assert that a does not match a regular expression"""
 
632
        if re.search(needle_re, haystack):
 
633
            raise AssertionError('pattern "%s" found in "%s"'
 
634
                    % (needle_re, haystack))
 
635
 
 
636
    def assertSubset(self, sublist, superlist):
 
637
        """Assert that every entry in sublist is present in superlist."""
 
638
        missing = []
 
639
        for entry in sublist:
 
640
            if entry not in superlist:
 
641
                missing.append(entry)
 
642
        if len(missing) > 0:
 
643
            raise AssertionError("value(s) %r not present in container %r" % 
 
644
                                 (missing, superlist))
 
645
 
 
646
    def assertListRaises(self, excClass, func, *args, **kwargs):
 
647
        """Fail unless excClass is raised when the iterator from func is used.
 
648
        
 
649
        Many functions can return generators this makes sure
 
650
        to wrap them in a list() call to make sure the whole generator
 
651
        is run, and that the proper exception is raised.
 
652
        """
 
653
        try:
 
654
            list(func(*args, **kwargs))
 
655
        except excClass:
 
656
            return
 
657
        else:
 
658
            if getattr(excClass,'__name__', None) is not None:
 
659
                excName = excClass.__name__
 
660
            else:
 
661
                excName = str(excClass)
 
662
            raise self.failureException, "%s not raised" % excName
 
663
 
 
664
    def assertIs(self, left, right):
 
665
        if not (left is right):
 
666
            raise AssertionError("%r is not %r." % (left, right))
 
667
 
 
668
    def assertTransportMode(self, transport, path, mode):
 
669
        """Fail if a path does not have mode mode.
 
670
        
 
671
        If modes are not supported on this transport, the assertion is ignored.
 
672
        """
 
673
        if not transport._can_roundtrip_unix_modebits():
 
674
            return
 
675
        path_stat = transport.stat(path)
 
676
        actual_mode = stat.S_IMODE(path_stat.st_mode)
 
677
        self.assertEqual(mode, actual_mode,
 
678
            'mode of %r incorrect (%o != %o)' % (path, mode, actual_mode))
 
679
 
 
680
    def assertIsInstance(self, obj, kls):
 
681
        """Fail if obj is not an instance of kls"""
 
682
        if not isinstance(obj, kls):
 
683
            self.fail("%r is an instance of %s rather than %s" % (
 
684
                obj, obj.__class__, kls))
 
685
 
 
686
    def _capture_warnings(self, a_callable, *args, **kwargs):
 
687
        """A helper for callDeprecated and applyDeprecated.
 
688
 
 
689
        :param a_callable: A callable to call.
 
690
        :param args: The positional arguments for the callable
 
691
        :param kwargs: The keyword arguments for the callable
 
692
        :return: A tuple (warnings, result). result is the result of calling
 
693
            a_callable(*args, **kwargs).
 
694
        """
 
695
        local_warnings = []
 
696
        def capture_warnings(msg, cls=None, stacklevel=None):
 
697
            # we've hooked into a deprecation specific callpath,
 
698
            # only deprecations should getting sent via it.
 
699
            self.assertEqual(cls, DeprecationWarning)
 
700
            local_warnings.append(msg)
 
701
        original_warning_method = symbol_versioning.warn
 
702
        symbol_versioning.set_warning_method(capture_warnings)
 
703
        try:
 
704
            result = a_callable(*args, **kwargs)
 
705
        finally:
 
706
            symbol_versioning.set_warning_method(original_warning_method)
 
707
        return (local_warnings, result)
 
708
 
 
709
    def applyDeprecated(self, deprecation_format, a_callable, *args, **kwargs):
 
710
        """Call a deprecated callable without warning the user.
 
711
 
 
712
        :param deprecation_format: The deprecation format that the callable
 
713
            should have been deprecated with. This is the same type as the 
 
714
            parameter to deprecated_method/deprecated_function. If the 
 
715
            callable is not deprecated with this format, an assertion error
 
716
            will be raised.
 
717
        :param a_callable: A callable to call. This may be a bound method or
 
718
            a regular function. It will be called with *args and **kwargs.
 
719
        :param args: The positional arguments for the callable
 
720
        :param kwargs: The keyword arguments for the callable
 
721
        :return: The result of a_callable(*args, **kwargs)
 
722
        """
 
723
        call_warnings, result = self._capture_warnings(a_callable,
 
724
            *args, **kwargs)
 
725
        expected_first_warning = symbol_versioning.deprecation_string(
 
726
            a_callable, deprecation_format)
 
727
        if len(call_warnings) == 0:
 
728
            self.fail("No assertion generated by call to %s" %
 
729
                a_callable)
 
730
        self.assertEqual(expected_first_warning, call_warnings[0])
 
731
        return result
 
732
 
 
733
    def callDeprecated(self, expected, callable, *args, **kwargs):
 
734
        """Assert that a callable is deprecated in a particular way.
 
735
 
 
736
        This is a very precise test for unusual requirements. The 
 
737
        applyDeprecated helper function is probably more suited for most tests
 
738
        as it allows you to simply specify the deprecation format being used
 
739
        and will ensure that that is issued for the function being called.
 
740
 
 
741
        :param expected: a list of the deprecation warnings expected, in order
 
742
        :param callable: The callable to call
 
743
        :param args: The positional arguments for the callable
 
744
        :param kwargs: The keyword arguments for the callable
 
745
        """
 
746
        call_warnings, result = self._capture_warnings(callable,
 
747
            *args, **kwargs)
 
748
        self.assertEqual(expected, call_warnings)
 
749
        return result
 
750
 
 
751
    def _startLogFile(self):
 
752
        """Send bzr and test log messages to a temporary file.
 
753
 
 
754
        The file is removed as the test is torn down.
 
755
        """
 
756
        fileno, name = tempfile.mkstemp(suffix='.log', prefix='testbzr')
 
757
        self._log_file = os.fdopen(fileno, 'w+')
 
758
        self._log_nonce = bzrlib.trace.enable_test_log(self._log_file)
 
759
        self._log_file_name = name
 
760
        self.addCleanup(self._finishLogFile)
 
761
 
 
762
    def _finishLogFile(self):
 
763
        """Finished with the log file.
 
764
 
 
765
        Close the file and delete it, unless setKeepLogfile was called.
 
766
        """
 
767
        if self._log_file is None:
 
768
            return
 
769
        bzrlib.trace.disable_test_log(self._log_nonce)
 
770
        self._log_file.close()
 
771
        self._log_file = None
 
772
        if not self._keep_log_file:
 
773
            os.remove(self._log_file_name)
 
774
            self._log_file_name = None
 
775
 
 
776
    def setKeepLogfile(self):
 
777
        """Make the logfile not be deleted when _finishLogFile is called."""
 
778
        self._keep_log_file = True
 
779
 
 
780
    def addCleanup(self, callable):
 
781
        """Arrange to run a callable when this case is torn down.
 
782
 
 
783
        Callables are run in the reverse of the order they are registered, 
 
784
        ie last-in first-out.
 
785
        """
 
786
        if callable in self._cleanups:
 
787
            raise ValueError("cleanup function %r already registered on %s" 
 
788
                    % (callable, self))
 
789
        self._cleanups.append(callable)
 
790
 
 
791
    def _cleanEnvironment(self):
 
792
        new_env = {
 
793
            'BZR_HOME': None, # Don't inherit BZR_HOME to all the tests.
 
794
            'HOME': os.getcwd(),
 
795
            'APPDATA': os.getcwd(),
 
796
            'BZR_EMAIL': None,
 
797
            'BZREMAIL': None, # may still be present in the environment
 
798
            'EMAIL': None,
 
799
            'BZR_PROGRESS_BAR': None,
 
800
            # Proxies
 
801
            'http_proxy': None,
 
802
            'HTTP_PROXY': None,
 
803
            'https_proxy': None,
 
804
            'HTTPS_PROXY': None,
 
805
            'no_proxy': None,
 
806
            'NO_PROXY': None,
 
807
            'all_proxy': None,
 
808
            'ALL_PROXY': None,
 
809
            # Nobody cares about these ones AFAIK. So far at
 
810
            # least. If you do (care), please update this comment
 
811
            # -- vila 20061212
 
812
            'ftp_proxy': None,
 
813
            'FTP_PROXY': None,
 
814
        }
 
815
        self.__old_env = {}
 
816
        self.addCleanup(self._restoreEnvironment)
 
817
        for name, value in new_env.iteritems():
 
818
            self._captureVar(name, value)
 
819
 
 
820
    def _captureVar(self, name, newvalue):
 
821
        """Set an environment variable, and reset it when finished."""
 
822
        self.__old_env[name] = osutils.set_or_unset_env(name, newvalue)
 
823
 
 
824
    def _restoreEnvironment(self):
 
825
        for name, value in self.__old_env.iteritems():
 
826
            osutils.set_or_unset_env(name, value)
 
827
 
 
828
    def tearDown(self):
 
829
        self._runCleanups()
 
830
        unittest.TestCase.tearDown(self)
 
831
 
 
832
    def time(self, callable, *args, **kwargs):
 
833
        """Run callable and accrue the time it takes to the benchmark time.
 
834
        
 
835
        If lsprofiling is enabled (i.e. by --lsprof-time to bzr selftest) then
 
836
        this will cause lsprofile statistics to be gathered and stored in
 
837
        self._benchcalls.
 
838
        """
 
839
        if self._benchtime is None:
 
840
            self._benchtime = 0
 
841
        start = time.time()
 
842
        try:
 
843
            if not self._gather_lsprof_in_benchmarks:
 
844
                return callable(*args, **kwargs)
 
845
            else:
 
846
                # record this benchmark
 
847
                ret, stats = bzrlib.lsprof.profile(callable, *args, **kwargs)
 
848
                stats.sort()
 
849
                self._benchcalls.append(((callable, args, kwargs), stats))
 
850
                return ret
 
851
        finally:
 
852
            self._benchtime += time.time() - start
 
853
 
 
854
    def _runCleanups(self):
 
855
        """Run registered cleanup functions. 
 
856
 
 
857
        This should only be called from TestCase.tearDown.
 
858
        """
 
859
        # TODO: Perhaps this should keep running cleanups even if 
 
860
        # one of them fails?
 
861
        for cleanup_fn in reversed(self._cleanups):
 
862
            cleanup_fn()
 
863
 
 
864
    def log(self, *args):
 
865
        mutter(*args)
 
866
 
 
867
    def _get_log(self, keep_log_file=False):
 
868
        """Return as a string the log for this test. If the file is still
 
869
        on disk and keep_log_file=False, delete the log file and store the
 
870
        content in self._log_contents."""
 
871
        # flush the log file, to get all content
 
872
        import bzrlib.trace
 
873
        bzrlib.trace._trace_file.flush()
 
874
        if self._log_contents:
 
875
            return self._log_contents
 
876
        if self._log_file_name is not None:
 
877
            logfile = open(self._log_file_name)
 
878
            try:
 
879
                log_contents = logfile.read()
 
880
            finally:
 
881
                logfile.close()
 
882
            if not keep_log_file:
 
883
                self._log_contents = log_contents
 
884
                os.remove(self._log_file_name)
 
885
            return log_contents
 
886
        else:
 
887
            return "DELETED log file to reduce memory footprint"
 
888
 
 
889
    def capture(self, cmd, retcode=0):
 
890
        """Shortcut that splits cmd into words, runs, and returns stdout"""
 
891
        return self.run_bzr_captured(cmd.split(), retcode=retcode)[0]
 
892
 
 
893
    def run_bzr_captured(self, argv, retcode=0, encoding=None, stdin=None,
 
894
                         working_dir=None):
 
895
        """Invoke bzr and return (stdout, stderr).
 
896
 
 
897
        Useful for code that wants to check the contents of the
 
898
        output, the way error messages are presented, etc.
 
899
 
 
900
        This should be the main method for tests that want to exercise the
 
901
        overall behavior of the bzr application (rather than a unit test
 
902
        or a functional test of the library.)
 
903
 
 
904
        Much of the old code runs bzr by forking a new copy of Python, but
 
905
        that is slower, harder to debug, and generally not necessary.
 
906
 
 
907
        This runs bzr through the interface that catches and reports
 
908
        errors, and with logging set to something approximating the
 
909
        default, so that error reporting can be checked.
 
910
 
 
911
        :param argv: arguments to invoke bzr
 
912
        :param retcode: expected return code, or None for don't-care.
 
913
        :param encoding: encoding for sys.stdout and sys.stderr
 
914
        :param stdin: A string to be used as stdin for the command.
 
915
        :param working_dir: Change to this directory before running
 
916
        """
 
917
        if encoding is None:
 
918
            encoding = bzrlib.user_encoding
 
919
        if stdin is not None:
 
920
            stdin = StringIO(stdin)
 
921
        stdout = StringIOWrapper()
 
922
        stderr = StringIOWrapper()
 
923
        stdout.encoding = encoding
 
924
        stderr.encoding = encoding
 
925
 
 
926
        self.log('run bzr: %r', argv)
 
927
        # FIXME: don't call into logging here
 
928
        handler = logging.StreamHandler(stderr)
 
929
        handler.setLevel(logging.INFO)
 
930
        logger = logging.getLogger('')
 
931
        logger.addHandler(handler)
 
932
        old_ui_factory = bzrlib.ui.ui_factory
 
933
        bzrlib.ui.ui_factory = bzrlib.tests.blackbox.TestUIFactory(
 
934
            stdout=stdout,
 
935
            stderr=stderr)
 
936
        bzrlib.ui.ui_factory.stdin = stdin
 
937
 
 
938
        cwd = None
 
939
        if working_dir is not None:
 
940
            cwd = osutils.getcwd()
 
941
            os.chdir(working_dir)
 
942
 
 
943
        try:
 
944
            saved_debug_flags = frozenset(debug.debug_flags)
 
945
            debug.debug_flags.clear()
 
946
            try:
 
947
                result = self.apply_redirected(stdin, stdout, stderr,
 
948
                                               bzrlib.commands.run_bzr_catch_errors,
 
949
                                               argv)
 
950
            finally:
 
951
                debug.debug_flags.update(saved_debug_flags)
 
952
        finally:
 
953
            logger.removeHandler(handler)
 
954
            bzrlib.ui.ui_factory = old_ui_factory
 
955
            if cwd is not None:
 
956
                os.chdir(cwd)
 
957
 
 
958
        out = stdout.getvalue()
 
959
        err = stderr.getvalue()
 
960
        if out:
 
961
            self.log('output:\n%r', out)
 
962
        if err:
 
963
            self.log('errors:\n%r', err)
 
964
        if retcode is not None:
 
965
            self.assertEquals(retcode, result)
 
966
        return out, err
 
967
 
 
968
    def run_bzr(self, *args, **kwargs):
 
969
        """Invoke bzr, as if it were run from the command line.
 
970
 
 
971
        This should be the main method for tests that want to exercise the
 
972
        overall behavior of the bzr application (rather than a unit test
 
973
        or a functional test of the library.)
 
974
 
 
975
        This sends the stdout/stderr results into the test's log,
 
976
        where it may be useful for debugging.  See also run_captured.
 
977
 
 
978
        :param stdin: A string to be used as stdin for the command.
 
979
        """
 
980
        retcode = kwargs.pop('retcode', 0)
 
981
        encoding = kwargs.pop('encoding', None)
 
982
        stdin = kwargs.pop('stdin', None)
 
983
        working_dir = kwargs.pop('working_dir', None)
 
984
        return self.run_bzr_captured(args, retcode=retcode, encoding=encoding,
 
985
                                     stdin=stdin, working_dir=working_dir)
 
986
 
 
987
    def run_bzr_decode(self, *args, **kwargs):
 
988
        if 'encoding' in kwargs:
 
989
            encoding = kwargs['encoding']
 
990
        else:
 
991
            encoding = bzrlib.user_encoding
 
992
        return self.run_bzr(*args, **kwargs)[0].decode(encoding)
 
993
 
 
994
    def run_bzr_error(self, error_regexes, *args, **kwargs):
 
995
        """Run bzr, and check that stderr contains the supplied regexes
 
996
        
 
997
        :param error_regexes: Sequence of regular expressions which 
 
998
            must each be found in the error output. The relative ordering
 
999
            is not enforced.
 
1000
        :param args: command-line arguments for bzr
 
1001
        :param kwargs: Keyword arguments which are interpreted by run_bzr
 
1002
            This function changes the default value of retcode to be 3,
 
1003
            since in most cases this is run when you expect bzr to fail.
 
1004
        :return: (out, err) The actual output of running the command (in case you
 
1005
                 want to do more inspection)
 
1006
 
 
1007
        Examples of use:
 
1008
            # Make sure that commit is failing because there is nothing to do
 
1009
            self.run_bzr_error(['no changes to commit'],
 
1010
                               'commit', '-m', 'my commit comment')
 
1011
            # Make sure --strict is handling an unknown file, rather than
 
1012
            # giving us the 'nothing to do' error
 
1013
            self.build_tree(['unknown'])
 
1014
            self.run_bzr_error(['Commit refused because there are unknown files'],
 
1015
                               'commit', '--strict', '-m', 'my commit comment')
 
1016
        """
 
1017
        kwargs.setdefault('retcode', 3)
 
1018
        out, err = self.run_bzr(*args, **kwargs)
 
1019
        for regex in error_regexes:
 
1020
            self.assertContainsRe(err, regex)
 
1021
        return out, err
 
1022
 
 
1023
    def run_bzr_subprocess(self, *args, **kwargs):
 
1024
        """Run bzr in a subprocess for testing.
 
1025
 
 
1026
        This starts a new Python interpreter and runs bzr in there. 
 
1027
        This should only be used for tests that have a justifiable need for
 
1028
        this isolation: e.g. they are testing startup time, or signal
 
1029
        handling, or early startup code, etc.  Subprocess code can't be 
 
1030
        profiled or debugged so easily.
 
1031
 
 
1032
        :param retcode: The status code that is expected.  Defaults to 0.  If
 
1033
            None is supplied, the status code is not checked.
 
1034
        :param env_changes: A dictionary which lists changes to environment
 
1035
            variables. A value of None will unset the env variable.
 
1036
            The values must be strings. The change will only occur in the
 
1037
            child, so you don't need to fix the environment after running.
 
1038
        :param universal_newlines: Convert CRLF => LF
 
1039
        :param allow_plugins: By default the subprocess is run with
 
1040
            --no-plugins to ensure test reproducibility. Also, it is possible
 
1041
            for system-wide plugins to create unexpected output on stderr,
 
1042
            which can cause unnecessary test failures.
 
1043
        """
 
1044
        env_changes = kwargs.get('env_changes', {})
 
1045
        working_dir = kwargs.get('working_dir', None)
 
1046
        allow_plugins = kwargs.get('allow_plugins', False)
 
1047
        process = self.start_bzr_subprocess(args, env_changes=env_changes,
 
1048
                                            working_dir=working_dir,
 
1049
                                            allow_plugins=allow_plugins)
 
1050
        # We distinguish between retcode=None and retcode not passed.
 
1051
        supplied_retcode = kwargs.get('retcode', 0)
 
1052
        return self.finish_bzr_subprocess(process, retcode=supplied_retcode,
 
1053
            universal_newlines=kwargs.get('universal_newlines', False),
 
1054
            process_args=args)
 
1055
 
 
1056
    def start_bzr_subprocess(self, process_args, env_changes=None,
 
1057
                             skip_if_plan_to_signal=False,
 
1058
                             working_dir=None,
 
1059
                             allow_plugins=False):
 
1060
        """Start bzr in a subprocess for testing.
 
1061
 
 
1062
        This starts a new Python interpreter and runs bzr in there.
 
1063
        This should only be used for tests that have a justifiable need for
 
1064
        this isolation: e.g. they are testing startup time, or signal
 
1065
        handling, or early startup code, etc.  Subprocess code can't be
 
1066
        profiled or debugged so easily.
 
1067
 
 
1068
        :param process_args: a list of arguments to pass to the bzr executable,
 
1069
            for example `['--version']`.
 
1070
        :param env_changes: A dictionary which lists changes to environment
 
1071
            variables. A value of None will unset the env variable.
 
1072
            The values must be strings. The change will only occur in the
 
1073
            child, so you don't need to fix the environment after running.
 
1074
        :param skip_if_plan_to_signal: raise TestSkipped when true and os.kill
 
1075
            is not available.
 
1076
        :param allow_plugins: If False (default) pass --no-plugins to bzr.
 
1077
 
 
1078
        :returns: Popen object for the started process.
 
1079
        """
 
1080
        if skip_if_plan_to_signal:
 
1081
            if not getattr(os, 'kill', None):
 
1082
                raise TestSkipped("os.kill not available.")
 
1083
 
 
1084
        if env_changes is None:
 
1085
            env_changes = {}
 
1086
        old_env = {}
 
1087
 
 
1088
        def cleanup_environment():
 
1089
            for env_var, value in env_changes.iteritems():
 
1090
                old_env[env_var] = osutils.set_or_unset_env(env_var, value)
 
1091
 
 
1092
        def restore_environment():
 
1093
            for env_var, value in old_env.iteritems():
 
1094
                osutils.set_or_unset_env(env_var, value)
 
1095
 
 
1096
        bzr_path = self.get_bzr_path()
 
1097
 
 
1098
        cwd = None
 
1099
        if working_dir is not None:
 
1100
            cwd = osutils.getcwd()
 
1101
            os.chdir(working_dir)
 
1102
 
 
1103
        try:
 
1104
            # win32 subprocess doesn't support preexec_fn
 
1105
            # so we will avoid using it on all platforms, just to
 
1106
            # make sure the code path is used, and we don't break on win32
 
1107
            cleanup_environment()
 
1108
            command = [sys.executable, bzr_path]
 
1109
            if not allow_plugins:
 
1110
                command.append('--no-plugins')
 
1111
            command.extend(process_args)
 
1112
            process = self._popen(command, stdin=PIPE, stdout=PIPE, stderr=PIPE)
 
1113
        finally:
 
1114
            restore_environment()
 
1115
            if cwd is not None:
 
1116
                os.chdir(cwd)
 
1117
 
 
1118
        return process
 
1119
 
 
1120
    def _popen(self, *args, **kwargs):
 
1121
        """Place a call to Popen.
 
1122
 
 
1123
        Allows tests to override this method to intercept the calls made to
 
1124
        Popen for introspection.
 
1125
        """
 
1126
        return Popen(*args, **kwargs)
 
1127
 
 
1128
    def get_bzr_path(self):
 
1129
        """Return the path of the 'bzr' executable for this test suite."""
 
1130
        bzr_path = os.path.dirname(os.path.dirname(bzrlib.__file__))+'/bzr'
 
1131
        if not os.path.isfile(bzr_path):
 
1132
            # We are probably installed. Assume sys.argv is the right file
 
1133
            bzr_path = sys.argv[0]
 
1134
        return bzr_path
 
1135
 
 
1136
    def finish_bzr_subprocess(self, process, retcode=0, send_signal=None,
 
1137
                              universal_newlines=False, process_args=None):
 
1138
        """Finish the execution of process.
 
1139
 
 
1140
        :param process: the Popen object returned from start_bzr_subprocess.
 
1141
        :param retcode: The status code that is expected.  Defaults to 0.  If
 
1142
            None is supplied, the status code is not checked.
 
1143
        :param send_signal: an optional signal to send to the process.
 
1144
        :param universal_newlines: Convert CRLF => LF
 
1145
        :returns: (stdout, stderr)
 
1146
        """
 
1147
        if send_signal is not None:
 
1148
            os.kill(process.pid, send_signal)
 
1149
        out, err = process.communicate()
 
1150
 
 
1151
        if universal_newlines:
 
1152
            out = out.replace('\r\n', '\n')
 
1153
            err = err.replace('\r\n', '\n')
 
1154
 
 
1155
        if retcode is not None and retcode != process.returncode:
 
1156
            if process_args is None:
 
1157
                process_args = "(unknown args)"
 
1158
            mutter('Output of bzr %s:\n%s', process_args, out)
 
1159
            mutter('Error for bzr %s:\n%s', process_args, err)
 
1160
            self.fail('Command bzr %s failed with retcode %s != %s'
 
1161
                      % (process_args, retcode, process.returncode))
 
1162
        return [out, err]
 
1163
 
 
1164
    def check_inventory_shape(self, inv, shape):
 
1165
        """Compare an inventory to a list of expected names.
 
1166
 
 
1167
        Fail if they are not precisely equal.
 
1168
        """
 
1169
        extras = []
 
1170
        shape = list(shape)             # copy
 
1171
        for path, ie in inv.entries():
 
1172
            name = path.replace('\\', '/')
 
1173
            if ie.kind == 'dir':
 
1174
                name = name + '/'
 
1175
            if name in shape:
 
1176
                shape.remove(name)
 
1177
            else:
 
1178
                extras.append(name)
 
1179
        if shape:
 
1180
            self.fail("expected paths not found in inventory: %r" % shape)
 
1181
        if extras:
 
1182
            self.fail("unexpected paths found in inventory: %r" % extras)
 
1183
 
 
1184
    def apply_redirected(self, stdin=None, stdout=None, stderr=None,
 
1185
                         a_callable=None, *args, **kwargs):
 
1186
        """Call callable with redirected std io pipes.
 
1187
 
 
1188
        Returns the return code."""
 
1189
        if not callable(a_callable):
 
1190
            raise ValueError("a_callable must be callable.")
 
1191
        if stdin is None:
 
1192
            stdin = StringIO("")
 
1193
        if stdout is None:
 
1194
            if getattr(self, "_log_file", None) is not None:
 
1195
                stdout = self._log_file
 
1196
            else:
 
1197
                stdout = StringIO()
 
1198
        if stderr is None:
 
1199
            if getattr(self, "_log_file", None is not None):
 
1200
                stderr = self._log_file
 
1201
            else:
 
1202
                stderr = StringIO()
 
1203
        real_stdin = sys.stdin
 
1204
        real_stdout = sys.stdout
 
1205
        real_stderr = sys.stderr
 
1206
        try:
 
1207
            sys.stdout = stdout
 
1208
            sys.stderr = stderr
 
1209
            sys.stdin = stdin
 
1210
            return a_callable(*args, **kwargs)
 
1211
        finally:
 
1212
            sys.stdout = real_stdout
 
1213
            sys.stderr = real_stderr
 
1214
            sys.stdin = real_stdin
 
1215
 
 
1216
    @symbol_versioning.deprecated_method(symbol_versioning.zero_eleven)
 
1217
    def merge(self, branch_from, wt_to):
 
1218
        """A helper for tests to do a ui-less merge.
 
1219
 
 
1220
        This should move to the main library when someone has time to integrate
 
1221
        it in.
 
1222
        """
 
1223
        # minimal ui-less merge.
 
1224
        wt_to.branch.fetch(branch_from)
 
1225
        base_rev = common_ancestor(branch_from.last_revision(),
 
1226
                                   wt_to.branch.last_revision(),
 
1227
                                   wt_to.branch.repository)
 
1228
        merge_inner(wt_to.branch, branch_from.basis_tree(),
 
1229
                    wt_to.branch.repository.revision_tree(base_rev),
 
1230
                    this_tree=wt_to)
 
1231
        wt_to.add_parent_tree_id(branch_from.last_revision())
 
1232
 
 
1233
 
 
1234
BzrTestBase = TestCase
 
1235
 
 
1236
 
 
1237
class TestCaseWithMemoryTransport(TestCase):
 
1238
    """Common test class for tests that do not need disk resources.
 
1239
 
 
1240
    Tests that need disk resources should derive from TestCaseWithTransport.
 
1241
 
 
1242
    TestCaseWithMemoryTransport sets the TEST_ROOT variable for all bzr tests.
 
1243
 
 
1244
    For TestCaseWithMemoryTransport the test_home_dir is set to the name of
 
1245
    a directory which does not exist. This serves to help ensure test isolation
 
1246
    is preserved. test_dir is set to the TEST_ROOT, as is cwd, because they
 
1247
    must exist. However, TestCaseWithMemoryTransport does not offer local
 
1248
    file defaults for the transport in tests, nor does it obey the command line
 
1249
    override, so tests that accidentally write to the common directory should
 
1250
    be rare.
 
1251
    """
 
1252
 
 
1253
    TEST_ROOT = None
 
1254
    _TEST_NAME = 'test'
 
1255
 
 
1256
 
 
1257
    def __init__(self, methodName='runTest'):
 
1258
        # allow test parameterisation after test construction and before test
 
1259
        # execution. Variables that the parameteriser sets need to be 
 
1260
        # ones that are not set by setUp, or setUp will trash them.
 
1261
        super(TestCaseWithMemoryTransport, self).__init__(methodName)
 
1262
        self.transport_server = default_transport
 
1263
        self.transport_readonly_server = None
 
1264
 
 
1265
    def get_transport(self):
 
1266
        """Return a writeable transport for the test scratch space"""
 
1267
        t = get_transport(self.get_url())
 
1268
        self.assertFalse(t.is_readonly())
 
1269
        return t
 
1270
 
 
1271
    def get_readonly_transport(self):
 
1272
        """Return a readonly transport for the test scratch space
 
1273
        
 
1274
        This can be used to test that operations which should only need
 
1275
        readonly access in fact do not try to write.
 
1276
        """
 
1277
        t = get_transport(self.get_readonly_url())
 
1278
        self.assertTrue(t.is_readonly())
 
1279
        return t
 
1280
 
 
1281
    def create_transport_readonly_server(self):
 
1282
        """Create a transport server from class defined at init.
 
1283
 
 
1284
        This is mostly a hook for daughter classes.
 
1285
        """
 
1286
        return self.transport_readonly_server()
 
1287
 
 
1288
    def get_readonly_server(self):
 
1289
        """Get the server instance for the readonly transport
 
1290
 
 
1291
        This is useful for some tests with specific servers to do diagnostics.
 
1292
        """
 
1293
        if self.__readonly_server is None:
 
1294
            if self.transport_readonly_server is None:
 
1295
                # readonly decorator requested
 
1296
                # bring up the server
 
1297
                self.get_url()
 
1298
                self.__readonly_server = ReadonlyServer()
 
1299
                self.__readonly_server.setUp(self.__server)
 
1300
            else:
 
1301
                self.__readonly_server = self.create_transport_readonly_server()
 
1302
                self.__readonly_server.setUp()
 
1303
            self.addCleanup(self.__readonly_server.tearDown)
 
1304
        return self.__readonly_server
 
1305
 
 
1306
    def get_readonly_url(self, relpath=None):
 
1307
        """Get a URL for the readonly transport.
 
1308
 
 
1309
        This will either be backed by '.' or a decorator to the transport 
 
1310
        used by self.get_url()
 
1311
        relpath provides for clients to get a path relative to the base url.
 
1312
        These should only be downwards relative, not upwards.
 
1313
        """
 
1314
        base = self.get_readonly_server().get_url()
 
1315
        if relpath is not None:
 
1316
            if not base.endswith('/'):
 
1317
                base = base + '/'
 
1318
            base = base + relpath
 
1319
        return base
 
1320
 
 
1321
    def get_server(self):
 
1322
        """Get the read/write server instance.
 
1323
 
 
1324
        This is useful for some tests with specific servers that need
 
1325
        diagnostics.
 
1326
 
 
1327
        For TestCaseWithMemoryTransport this is always a MemoryServer, and there
 
1328
        is no means to override it.
 
1329
        """
 
1330
        if self.__server is None:
 
1331
            self.__server = MemoryServer()
 
1332
            self.__server.setUp()
 
1333
            self.addCleanup(self.__server.tearDown)
 
1334
        return self.__server
 
1335
 
 
1336
    def get_url(self, relpath=None):
 
1337
        """Get a URL (or maybe a path) for the readwrite transport.
 
1338
 
 
1339
        This will either be backed by '.' or to an equivalent non-file based
 
1340
        facility.
 
1341
        relpath provides for clients to get a path relative to the base url.
 
1342
        These should only be downwards relative, not upwards.
 
1343
        """
 
1344
        base = self.get_server().get_url()
 
1345
        if relpath is not None and relpath != '.':
 
1346
            if not base.endswith('/'):
 
1347
                base = base + '/'
 
1348
            # XXX: Really base should be a url; we did after all call
 
1349
            # get_url()!  But sometimes it's just a path (from
 
1350
            # LocalAbspathServer), and it'd be wrong to append urlescaped data
 
1351
            # to a non-escaped local path.
 
1352
            if base.startswith('./') or base.startswith('/'):
 
1353
                base += relpath
 
1354
            else:
 
1355
                base += urlutils.escape(relpath)
 
1356
        return base
 
1357
 
 
1358
    def _make_test_root(self):
 
1359
        if TestCaseWithMemoryTransport.TEST_ROOT is not None:
 
1360
            return
 
1361
        i = 0
 
1362
        while True:
 
1363
            root = u'test%04d.tmp' % i
 
1364
            try:
 
1365
                os.mkdir(root)
 
1366
            except OSError, e:
 
1367
                if e.errno == errno.EEXIST:
 
1368
                    i += 1
 
1369
                    continue
 
1370
                else:
 
1371
                    raise
 
1372
            # successfully created
 
1373
            TestCaseWithMemoryTransport.TEST_ROOT = osutils.abspath(root)
 
1374
            break
 
1375
        # make a fake bzr directory there to prevent any tests propagating
 
1376
        # up onto the source directory's real branch
 
1377
        bzrdir.BzrDir.create_standalone_workingtree(
 
1378
            TestCaseWithMemoryTransport.TEST_ROOT)
 
1379
 
 
1380
    def makeAndChdirToTestDir(self):
 
1381
        """Create a temporary directories for this one test.
 
1382
        
 
1383
        This must set self.test_home_dir and self.test_dir and chdir to
 
1384
        self.test_dir.
 
1385
        
 
1386
        For TestCaseWithMemoryTransport we chdir to the TEST_ROOT for this test.
 
1387
        """
 
1388
        os.chdir(TestCaseWithMemoryTransport.TEST_ROOT)
 
1389
        self.test_dir = TestCaseWithMemoryTransport.TEST_ROOT
 
1390
        self.test_home_dir = self.test_dir + "/MemoryTransportMissingHomeDir"
 
1391
        
 
1392
    def make_branch(self, relpath, format=None):
 
1393
        """Create a branch on the transport at relpath."""
 
1394
        repo = self.make_repository(relpath, format=format)
 
1395
        return repo.bzrdir.create_branch()
 
1396
 
 
1397
    def make_bzrdir(self, relpath, format=None):
 
1398
        try:
 
1399
            # might be a relative or absolute path
 
1400
            maybe_a_url = self.get_url(relpath)
 
1401
            segments = maybe_a_url.rsplit('/', 1)
 
1402
            t = get_transport(maybe_a_url)
 
1403
            if len(segments) > 1 and segments[-1] not in ('', '.'):
 
1404
                try:
 
1405
                    t.mkdir('.')
 
1406
                except errors.FileExists:
 
1407
                    pass
 
1408
            if isinstance(format, basestring):
 
1409
                format = bzrdir.format_registry.make_bzrdir(format)
 
1410
            elif format is None:
 
1411
                format = bzrlib.bzrdir.BzrDirFormat.get_default_format()
 
1412
            return format.initialize_on_transport(t)
 
1413
        except errors.UninitializableFormat:
 
1414
            raise TestSkipped("Format %s is not initializable." % format)
 
1415
 
 
1416
    def make_repository(self, relpath, shared=False, format=None):
 
1417
        """Create a repository on our default transport at relpath."""
 
1418
        made_control = self.make_bzrdir(relpath, format=format)
 
1419
        return made_control.create_repository(shared=shared)
 
1420
 
 
1421
    def make_branch_and_memory_tree(self, relpath, format=None):
 
1422
        """Create a branch on the default transport and a MemoryTree for it."""
 
1423
        b = self.make_branch(relpath, format=format)
 
1424
        return memorytree.MemoryTree.create_on_branch(b)
 
1425
 
 
1426
    def overrideEnvironmentForTesting(self):
 
1427
        os.environ['HOME'] = self.test_home_dir
 
1428
        os.environ['APPDATA'] = self.test_home_dir
 
1429
        
 
1430
    def setUp(self):
 
1431
        super(TestCaseWithMemoryTransport, self).setUp()
 
1432
        self._make_test_root()
 
1433
        _currentdir = os.getcwdu()
 
1434
        def _leaveDirectory():
 
1435
            os.chdir(_currentdir)
 
1436
        self.addCleanup(_leaveDirectory)
 
1437
        self.makeAndChdirToTestDir()
 
1438
        self.overrideEnvironmentForTesting()
 
1439
        self.__readonly_server = None
 
1440
        self.__server = None
 
1441
 
 
1442
     
 
1443
class TestCaseInTempDir(TestCaseWithMemoryTransport):
 
1444
    """Derived class that runs a test within a temporary directory.
 
1445
 
 
1446
    This is useful for tests that need to create a branch, etc.
 
1447
 
 
1448
    The directory is created in a slightly complex way: for each
 
1449
    Python invocation, a new temporary top-level directory is created.
 
1450
    All test cases create their own directory within that.  If the
 
1451
    tests complete successfully, the directory is removed.
 
1452
 
 
1453
    InTempDir is an old alias for FunctionalTestCase.
 
1454
    """
 
1455
 
 
1456
    OVERRIDE_PYTHON = 'python'
 
1457
 
 
1458
    def check_file_contents(self, filename, expect):
 
1459
        self.log("check contents of file %s" % filename)
 
1460
        contents = file(filename, 'r').read()
 
1461
        if contents != expect:
 
1462
            self.log("expected: %r" % expect)
 
1463
            self.log("actually: %r" % contents)
 
1464
            self.fail("contents of %s not as expected" % filename)
 
1465
 
 
1466
    def makeAndChdirToTestDir(self):
 
1467
        """See TestCaseWithMemoryTransport.makeAndChdirToTestDir().
 
1468
        
 
1469
        For TestCaseInTempDir we create a temporary directory based on the test
 
1470
        name and then create two subdirs - test and home under it.
 
1471
        """
 
1472
        # shorten the name, to avoid test failures due to path length
 
1473
        short_id = self.id().replace('bzrlib.tests.', '') \
 
1474
                   .replace('__main__.', '')[-100:]
 
1475
        # it's possible the same test class is run several times for
 
1476
        # parameterized tests, so make sure the names don't collide.  
 
1477
        i = 0
 
1478
        while True:
 
1479
            if i > 0:
 
1480
                candidate_dir = '%s/%s.%d' % (self.TEST_ROOT, short_id, i)
 
1481
            else:
 
1482
                candidate_dir = '%s/%s' % (self.TEST_ROOT, short_id)
 
1483
            if os.path.exists(candidate_dir):
 
1484
                i = i + 1
 
1485
                continue
 
1486
            else:
 
1487
                os.mkdir(candidate_dir)
 
1488
                self.test_home_dir = candidate_dir + '/home'
 
1489
                os.mkdir(self.test_home_dir)
 
1490
                self.test_dir = candidate_dir + '/work'
 
1491
                os.mkdir(self.test_dir)
 
1492
                os.chdir(self.test_dir)
 
1493
                break
 
1494
 
 
1495
    def build_tree(self, shape, line_endings='binary', transport=None):
 
1496
        """Build a test tree according to a pattern.
 
1497
 
 
1498
        shape is a sequence of file specifications.  If the final
 
1499
        character is '/', a directory is created.
 
1500
 
 
1501
        This assumes that all the elements in the tree being built are new.
 
1502
 
 
1503
        This doesn't add anything to a branch.
 
1504
        :param line_endings: Either 'binary' or 'native'
 
1505
                             in binary mode, exact contents are written
 
1506
                             in native mode, the line endings match the
 
1507
                             default platform endings.
 
1508
 
 
1509
        :param transport: A transport to write to, for building trees on 
 
1510
                          VFS's. If the transport is readonly or None,
 
1511
                          "." is opened automatically.
 
1512
        """
 
1513
        # It's OK to just create them using forward slashes on windows.
 
1514
        if transport is None or transport.is_readonly():
 
1515
            transport = get_transport(".")
 
1516
        for name in shape:
 
1517
            self.assert_(isinstance(name, basestring))
 
1518
            if name[-1] == '/':
 
1519
                transport.mkdir(urlutils.escape(name[:-1]))
 
1520
            else:
 
1521
                if line_endings == 'binary':
 
1522
                    end = '\n'
 
1523
                elif line_endings == 'native':
 
1524
                    end = os.linesep
 
1525
                else:
 
1526
                    raise errors.BzrError(
 
1527
                        'Invalid line ending request %r' % line_endings)
 
1528
                content = "contents of %s%s" % (name.encode('utf-8'), end)
 
1529
                transport.put_bytes_non_atomic(urlutils.escape(name), content)
 
1530
 
 
1531
    def build_tree_contents(self, shape):
 
1532
        build_tree_contents(shape)
 
1533
 
 
1534
    def assertFileEqual(self, content, path):
 
1535
        """Fail if path does not contain 'content'."""
 
1536
        self.failUnlessExists(path)
 
1537
        # TODO: jam 20060427 Shouldn't this be 'rb'?
 
1538
        self.assertEqualDiff(content, open(path, 'r').read())
 
1539
 
 
1540
    def failUnlessExists(self, path):
 
1541
        """Fail unless path, which may be abs or relative, exists."""
 
1542
        self.failUnless(osutils.lexists(path))
 
1543
 
 
1544
    def failIfExists(self, path):
 
1545
        """Fail if path, which may be abs or relative, exists."""
 
1546
        self.failIf(osutils.lexists(path))
 
1547
 
 
1548
 
 
1549
class TestCaseWithTransport(TestCaseInTempDir):
 
1550
    """A test case that provides get_url and get_readonly_url facilities.
 
1551
 
 
1552
    These back onto two transport servers, one for readonly access and one for
 
1553
    read write access.
 
1554
 
 
1555
    If no explicit class is provided for readonly access, a
 
1556
    ReadonlyTransportDecorator is used instead which allows the use of non disk
 
1557
    based read write transports.
 
1558
 
 
1559
    If an explicit class is provided for readonly access, that server and the 
 
1560
    readwrite one must both define get_url() as resolving to os.getcwd().
 
1561
    """
 
1562
 
 
1563
    def create_transport_server(self):
 
1564
        """Create a transport server from class defined at init.
 
1565
 
 
1566
        This is mostly a hook for daughter classes.
 
1567
        """
 
1568
        return self.transport_server()
 
1569
 
 
1570
    def get_server(self):
 
1571
        """See TestCaseWithMemoryTransport.
 
1572
 
 
1573
        This is useful for some tests with specific servers that need
 
1574
        diagnostics.
 
1575
        """
 
1576
        if self.__server is None:
 
1577
            self.__server = self.create_transport_server()
 
1578
            self.__server.setUp()
 
1579
            self.addCleanup(self.__server.tearDown)
 
1580
        return self.__server
 
1581
 
 
1582
    def make_branch_and_tree(self, relpath, format=None):
 
1583
        """Create a branch on the transport and a tree locally.
 
1584
 
 
1585
        If the transport is not a LocalTransport, the Tree can't be created on
 
1586
        the transport.  In that case the working tree is created in the local
 
1587
        directory, and the returned tree's branch and repository will also be
 
1588
        accessed locally.
 
1589
 
 
1590
        This will fail if the original default transport for this test
 
1591
        case wasn't backed by the working directory, as the branch won't
 
1592
        be on disk for us to open it.  
 
1593
 
 
1594
        :param format: The BzrDirFormat.
 
1595
        :returns: the WorkingTree.
 
1596
        """
 
1597
        # TODO: always use the local disk path for the working tree,
 
1598
        # this obviously requires a format that supports branch references
 
1599
        # so check for that by checking bzrdir.BzrDirFormat.get_default_format()
 
1600
        # RBC 20060208
 
1601
        b = self.make_branch(relpath, format=format)
 
1602
        try:
 
1603
            return b.bzrdir.create_workingtree()
 
1604
        except errors.NotLocalUrl:
 
1605
            # We can only make working trees locally at the moment.  If the
 
1606
            # transport can't support them, then reopen the branch on a local
 
1607
            # transport, and create the working tree there.  
 
1608
            #
 
1609
            # Possibly we should instead keep
 
1610
            # the non-disk-backed branch and create a local checkout?
 
1611
            bd = bzrdir.BzrDir.open(relpath)
 
1612
            return bd.create_workingtree()
 
1613
 
 
1614
    def assertIsDirectory(self, relpath, transport):
 
1615
        """Assert that relpath within transport is a directory.
 
1616
 
 
1617
        This may not be possible on all transports; in that case it propagates
 
1618
        a TransportNotPossible.
 
1619
        """
 
1620
        try:
 
1621
            mode = transport.stat(relpath).st_mode
 
1622
        except errors.NoSuchFile:
 
1623
            self.fail("path %s is not a directory; no such file"
 
1624
                      % (relpath))
 
1625
        if not stat.S_ISDIR(mode):
 
1626
            self.fail("path %s is not a directory; has mode %#o"
 
1627
                      % (relpath, mode))
 
1628
 
 
1629
    def setUp(self):
 
1630
        super(TestCaseWithTransport, self).setUp()
 
1631
        self.__server = None
 
1632
 
 
1633
 
 
1634
class ChrootedTestCase(TestCaseWithTransport):
 
1635
    """A support class that provides readonly urls outside the local namespace.
 
1636
 
 
1637
    This is done by checking if self.transport_server is a MemoryServer. if it
 
1638
    is then we are chrooted already, if it is not then an HttpServer is used
 
1639
    for readonly urls.
 
1640
 
 
1641
    TODO RBC 20060127: make this an option to TestCaseWithTransport so it can
 
1642
                       be used without needed to redo it when a different 
 
1643
                       subclass is in use ?
 
1644
    """
 
1645
 
 
1646
    def setUp(self):
 
1647
        super(ChrootedTestCase, self).setUp()
 
1648
        if not self.transport_server == MemoryServer:
 
1649
            self.transport_readonly_server = HttpServer
 
1650
 
 
1651
 
 
1652
def filter_suite_by_re(suite, pattern):
 
1653
    result = TestUtil.TestSuite()
 
1654
    filter_re = re.compile(pattern)
 
1655
    for test in iter_suite_tests(suite):
 
1656
        if filter_re.search(test.id()):
 
1657
            result.addTest(test)
 
1658
    return result
 
1659
 
 
1660
 
 
1661
def sort_suite_by_re(suite, pattern):
 
1662
    first = []
 
1663
    second = []
 
1664
    filter_re = re.compile(pattern)
 
1665
    for test in iter_suite_tests(suite):
 
1666
        if filter_re.search(test.id()):
 
1667
            first.append(test)
 
1668
        else:
 
1669
            second.append(test)
 
1670
    return TestUtil.TestSuite(first + second)
 
1671
 
 
1672
 
 
1673
def run_suite(suite, name='test', verbose=False, pattern=".*",
 
1674
              stop_on_failure=False, keep_output=False,
 
1675
              transport=None, lsprof_timed=None, bench_history=None,
 
1676
              matching_tests_first=None):
 
1677
    TestCase._gather_lsprof_in_benchmarks = lsprof_timed
 
1678
    if verbose:
 
1679
        verbosity = 2
 
1680
    else:
 
1681
        verbosity = 1
 
1682
    runner = TextTestRunner(stream=sys.stdout,
 
1683
                            descriptions=0,
 
1684
                            verbosity=verbosity,
 
1685
                            keep_output=keep_output,
 
1686
                            bench_history=bench_history)
 
1687
    runner.stop_on_failure=stop_on_failure
 
1688
    if pattern != '.*':
 
1689
        if matching_tests_first:
 
1690
            suite = sort_suite_by_re(suite, pattern)
 
1691
        else:
 
1692
            suite = filter_suite_by_re(suite, pattern)
 
1693
    result = runner.run(suite)
 
1694
    return result.wasSuccessful()
 
1695
 
 
1696
 
 
1697
def selftest(verbose=False, pattern=".*", stop_on_failure=True,
 
1698
             keep_output=False,
 
1699
             transport=None,
 
1700
             test_suite_factory=None,
 
1701
             lsprof_timed=None,
 
1702
             bench_history=None,
 
1703
             matching_tests_first=None):
 
1704
    """Run the whole test suite under the enhanced runner"""
 
1705
    # XXX: Very ugly way to do this...
 
1706
    # Disable warning about old formats because we don't want it to disturb
 
1707
    # any blackbox tests.
 
1708
    from bzrlib import repository
 
1709
    repository._deprecation_warning_done = True
 
1710
 
 
1711
    global default_transport
 
1712
    if transport is None:
 
1713
        transport = default_transport
 
1714
    old_transport = default_transport
 
1715
    default_transport = transport
 
1716
    try:
 
1717
        if test_suite_factory is None:
 
1718
            suite = test_suite()
 
1719
        else:
 
1720
            suite = test_suite_factory()
 
1721
        return run_suite(suite, 'testbzr', verbose=verbose, pattern=pattern,
 
1722
                     stop_on_failure=stop_on_failure, keep_output=keep_output,
 
1723
                     transport=transport,
 
1724
                     lsprof_timed=lsprof_timed,
 
1725
                     bench_history=bench_history,
 
1726
                     matching_tests_first=matching_tests_first)
 
1727
    finally:
 
1728
        default_transport = old_transport
 
1729
 
 
1730
 
 
1731
def test_suite():
 
1732
    """Build and return TestSuite for the whole of bzrlib.
 
1733
    
 
1734
    This function can be replaced if you need to change the default test
 
1735
    suite on a global basis, but it is not encouraged.
 
1736
    """
 
1737
    testmod_names = [
 
1738
                   'bzrlib.tests.test_ancestry',
 
1739
                   'bzrlib.tests.test_annotate',
 
1740
                   'bzrlib.tests.test_api',
 
1741
                   'bzrlib.tests.test_atomicfile',
 
1742
                   'bzrlib.tests.test_bad_files',
 
1743
                   'bzrlib.tests.test_branch',
 
1744
                   'bzrlib.tests.test_bundle',
 
1745
                   'bzrlib.tests.test_bzrdir',
 
1746
                   'bzrlib.tests.test_cache_utf8',
 
1747
                   'bzrlib.tests.test_commands',
 
1748
                   'bzrlib.tests.test_commit',
 
1749
                   'bzrlib.tests.test_commit_merge',
 
1750
                   'bzrlib.tests.test_config',
 
1751
                   'bzrlib.tests.test_conflicts',
 
1752
                   'bzrlib.tests.test_decorators',
 
1753
                   'bzrlib.tests.test_diff',
 
1754
                   'bzrlib.tests.test_doc_generate',
 
1755
                   'bzrlib.tests.test_errors',
 
1756
                   'bzrlib.tests.test_escaped_store',
 
1757
                   'bzrlib.tests.test_fetch',
 
1758
                   'bzrlib.tests.test_ftp_transport',
 
1759
                   'bzrlib.tests.test_generate_docs',
 
1760
                   'bzrlib.tests.test_generate_ids',
 
1761
                   'bzrlib.tests.test_globbing',
 
1762
                   'bzrlib.tests.test_gpg',
 
1763
                   'bzrlib.tests.test_graph',
 
1764
                   'bzrlib.tests.test_hashcache',
 
1765
                   'bzrlib.tests.test_http',
 
1766
                   'bzrlib.tests.test_http_response',
 
1767
                   'bzrlib.tests.test_identitymap',
 
1768
                   'bzrlib.tests.test_ignores',
 
1769
                   'bzrlib.tests.test_inv',
 
1770
                   'bzrlib.tests.test_knit',
 
1771
                   'bzrlib.tests.test_lazy_import',
 
1772
                   'bzrlib.tests.test_lazy_regex',
 
1773
                   'bzrlib.tests.test_lockdir',
 
1774
                   'bzrlib.tests.test_lockable_files',
 
1775
                   'bzrlib.tests.test_log',
 
1776
                   'bzrlib.tests.test_memorytree',
 
1777
                   'bzrlib.tests.test_merge',
 
1778
                   'bzrlib.tests.test_merge3',
 
1779
                   'bzrlib.tests.test_merge_core',
 
1780
                   'bzrlib.tests.test_missing',
 
1781
                   'bzrlib.tests.test_msgeditor',
 
1782
                   'bzrlib.tests.test_nonascii',
 
1783
                   'bzrlib.tests.test_options',
 
1784
                   'bzrlib.tests.test_osutils',
 
1785
                   'bzrlib.tests.test_osutils_encodings',
 
1786
                   'bzrlib.tests.test_patch',
 
1787
                   'bzrlib.tests.test_patches',
 
1788
                   'bzrlib.tests.test_permissions',
 
1789
                   'bzrlib.tests.test_plugins',
 
1790
                   'bzrlib.tests.test_progress',
 
1791
                   'bzrlib.tests.test_reconcile',
 
1792
                   'bzrlib.tests.test_registry',
 
1793
                   'bzrlib.tests.test_repository',
 
1794
                   'bzrlib.tests.test_revert',
 
1795
                   'bzrlib.tests.test_revision',
 
1796
                   'bzrlib.tests.test_revisionnamespaces',
 
1797
                   'bzrlib.tests.test_revisiontree',
 
1798
                   'bzrlib.tests.test_rio',
 
1799
                   'bzrlib.tests.test_sampler',
 
1800
                   'bzrlib.tests.test_selftest',
 
1801
                   'bzrlib.tests.test_setup',
 
1802
                   'bzrlib.tests.test_sftp_transport',
 
1803
                   'bzrlib.tests.test_smart_add',
 
1804
                   'bzrlib.tests.test_smart_transport',
 
1805
                   'bzrlib.tests.test_source',
 
1806
                   'bzrlib.tests.test_status',
 
1807
                   'bzrlib.tests.test_store',
 
1808
                   'bzrlib.tests.test_symbol_versioning',
 
1809
                   'bzrlib.tests.test_testament',
 
1810
                   'bzrlib.tests.test_textfile',
 
1811
                   'bzrlib.tests.test_textmerge',
 
1812
                   'bzrlib.tests.test_trace',
 
1813
                   'bzrlib.tests.test_transactions',
 
1814
                   'bzrlib.tests.test_transform',
 
1815
                   'bzrlib.tests.test_transport',
 
1816
                   'bzrlib.tests.test_tree',
 
1817
                   'bzrlib.tests.test_treebuilder',
 
1818
                   'bzrlib.tests.test_tsort',
 
1819
                   'bzrlib.tests.test_tuned_gzip',
 
1820
                   'bzrlib.tests.test_ui',
 
1821
                   'bzrlib.tests.test_upgrade',
 
1822
                   'bzrlib.tests.test_urlutils',
 
1823
                   'bzrlib.tests.test_versionedfile',
 
1824
                   'bzrlib.tests.test_version',
 
1825
                   'bzrlib.tests.test_version_info',
 
1826
                   'bzrlib.tests.test_weave',
 
1827
                   'bzrlib.tests.test_whitebox',
 
1828
                   'bzrlib.tests.test_workingtree',
 
1829
                   'bzrlib.tests.test_wsgi',
 
1830
                   'bzrlib.tests.test_xml',
 
1831
                   ]
 
1832
    test_transport_implementations = [
 
1833
        'bzrlib.tests.test_transport_implementations',
 
1834
        'bzrlib.tests.test_read_bundle',
 
1835
        ]
 
1836
    suite = TestUtil.TestSuite()
 
1837
    loader = TestUtil.TestLoader()
 
1838
    suite.addTest(loader.loadTestsFromModuleNames(testmod_names))
 
1839
    from bzrlib.transport import TransportTestProviderAdapter
 
1840
    adapter = TransportTestProviderAdapter()
 
1841
    adapt_modules(test_transport_implementations, adapter, loader, suite)
 
1842
    for package in packages_to_test():
 
1843
        suite.addTest(package.test_suite())
 
1844
    for m in MODULES_TO_TEST:
 
1845
        suite.addTest(loader.loadTestsFromModule(m))
 
1846
    for m in MODULES_TO_DOCTEST:
 
1847
        try:
 
1848
            suite.addTest(doctest.DocTestSuite(m))
 
1849
        except ValueError, e:
 
1850
            print '**failed to get doctest for: %s\n%s' %(m,e)
 
1851
            raise
 
1852
    for name, plugin in bzrlib.plugin.all_plugins().items():
 
1853
        if getattr(plugin, 'test_suite', None) is not None:
 
1854
            suite.addTest(plugin.test_suite())
 
1855
    return suite
 
1856
 
 
1857
 
 
1858
def adapt_modules(mods_list, adapter, loader, suite):
 
1859
    """Adapt the modules in mods_list using adapter and add to suite."""
 
1860
    for test in iter_suite_tests(loader.loadTestsFromModuleNames(mods_list)):
 
1861
        suite.addTests(adapter.adapt(test))
 
1862
 
 
1863
 
 
1864
def clean_selftest_output(root=None, quiet=False):
 
1865
    """Remove all selftest output directories from root directory.
 
1866
 
 
1867
    :param  root:   root directory for clean
 
1868
                    (if ommitted or None then clean current directory).
 
1869
    :param  quiet:  suppress report about deleting directories
 
1870
    """
 
1871
    import re
 
1872
    import shutil
 
1873
 
 
1874
    re_dir = re.compile(r'''test\d\d\d\d\.tmp''')
 
1875
    if root is None:
 
1876
        root = u'.'
 
1877
    for i in os.listdir(root):
 
1878
        if os.path.isdir(i) and re_dir.match(i):
 
1879
            if not quiet:
 
1880
                print 'delete directory:', i
 
1881
            shutil.rmtree(i)