/breezy/unstable

To get this branch, use:
bzr branch https://code.breezy-vcs.org/breezy/unstable

« back to all changes in this revision

Viewing changes to breezy/tests/__init__.py

  • Committer: Jelmer Vernooij
  • Date: 2017-05-24 01:39:33 UTC
  • mfrom: (3815.3776.6)
  • Revision ID: jelmer@jelmer.uk-20170524013933-ir4y4tqtrsiz2ka2
New upstream snapshot.

Show diffs side-by-side

added added

removed removed

Lines of Context:
20
20
 
21
21
# NOTE: Some classes in here use camelCaseNaming() rather than
22
22
# underscore_naming().  That's for consistency with unittest; it's not the
23
 
# general style of bzrlib.  Please continue that consistency when adding e.g.
 
23
# general style of breezy.  Please continue that consistency when adding e.g.
24
24
# new assertFoo() methods.
25
25
 
26
26
import atexit
27
27
import codecs
28
28
import copy
29
 
from cStringIO import StringIO
30
29
import difflib
31
30
import doctest
32
31
import errno
58
57
        % (testtools.__file__, _testtools_version))
59
58
from testtools import content
60
59
 
61
 
import bzrlib
62
 
from bzrlib import (
 
60
import breezy
 
61
from .. import (
63
62
    branchbuilder,
64
63
    controldir,
65
64
    chk_map,
84
83
    workingtree,
85
84
    )
86
85
try:
87
 
    import bzrlib.lsprof
 
86
    import breezy.lsprof
88
87
except ImportError:
89
88
    # lsprof not available
90
89
    pass
91
 
from bzrlib.smart import client, request
92
 
from bzrlib.transport import (
 
90
from ..sixish import (
 
91
    BytesIO,
 
92
    string_types,
 
93
    text_type,
 
94
    )
 
95
from ..smart import client, request
 
96
from ..symbol_versioning import (
 
97
    deprecated_function,
 
98
    deprecated_in,
 
99
    deprecated_method,
 
100
    )
 
101
from ..transport import (
93
102
    memory,
94
103
    pathfilter,
95
104
    )
96
 
from bzrlib.symbol_versioning import (
 
105
from ..symbol_versioning import (
97
106
    deprecated_function,
98
107
    deprecated_in,
99
108
    )
100
 
from bzrlib.tests import (
 
109
from ..tests import (
101
110
    fixtures,
102
111
    test_server,
103
112
    TestUtil,
104
113
    treeshape,
 
114
    ui_testing,
105
115
    )
106
 
from bzrlib.ui import NullProgressView
107
 
from bzrlib.ui.text import TextUIFactory
108
 
from bzrlib.tests.features import _CompatabilityThunkFeature
 
116
from ..tests.features import _CompatabilityThunkFeature
109
117
 
110
118
# Mark this python module as being part of the implementation
111
119
# of unittest: this gives us better tracebacks where the last
124
132
SUBUNIT_SEEK_CUR = 1
125
133
 
126
134
# These are intentionally brought into this namespace. That way plugins, etc
127
 
# can just "from bzrlib.tests import TestCase, TestLoader, etc"
 
135
# can just "from breezy.tests import TestCase, TestLoader, etc"
128
136
TestSuite = TestUtil.TestSuite
129
137
TestLoader = TestUtil.TestLoader
130
138
 
136
144
# the tests should start without this variable in the environment. There are a
137
145
# few exceptions but you shouldn't violate this rule lightly.
138
146
isolated_environ = {
139
 
    'BZR_HOME': None,
 
147
    'BRZ_HOME': None,
140
148
    'HOME': None,
141
149
    'XDG_CONFIG_HOME': None,
142
 
    # bzr now uses the Win32 API and doesn't rely on APPDATA, but the
 
150
    # brz now uses the Win32 API and doesn't rely on APPDATA, but the
143
151
    # tests do check our impls match APPDATA
144
 
    'BZR_EDITOR': None, # test_msgeditor manipulates this variable
 
152
    'BRZ_EDITOR': None, # test_msgeditor manipulates this variable
145
153
    'VISUAL': None,
146
154
    'EDITOR': None,
147
 
    'BZR_EMAIL': None,
 
155
    'BRZ_EMAIL': None,
148
156
    'BZREMAIL': None, # may still be present in the environment
149
 
    'EMAIL': 'jrandom@example.com', # set EMAIL as bzr does not guess
150
 
    'BZR_PROGRESS_BAR': None,
151
 
    # This should trap leaks to ~/.bzr.log. This occurs when tests use TestCase
 
157
    'EMAIL': 'jrandom@example.com', # set EMAIL as brz does not guess
 
158
    'BRZ_PROGRESS_BAR': None,
 
159
    # This should trap leaks to ~/.brz.log. This occurs when tests use TestCase
152
160
    # as a base class instead of TestCaseInTempDir. Tests inheriting from
153
 
    # TestCase should not use disk resources, BZR_LOG is one.
154
 
    'BZR_LOG': '/you-should-use-TestCaseInTempDir-if-you-need-a-log-file',
155
 
    'BZR_PLUGIN_PATH': None,
156
 
    'BZR_DISABLE_PLUGINS': None,
157
 
    'BZR_PLUGINS_AT': None,
158
 
    'BZR_CONCURRENCY': None,
 
161
    # TestCase should not use disk resources, BRZ_LOG is one.
 
162
    'BRZ_LOG': '/you-should-use-TestCaseInTempDir-if-you-need-a-log-file',
 
163
    'BRZ_PLUGIN_PATH': None,
 
164
    'BRZ_DISABLE_PLUGINS': None,
 
165
    'BRZ_PLUGINS_AT': None,
 
166
    'BRZ_CONCURRENCY': None,
159
167
    # Make sure that any text ui tests are consistent regardless of
160
168
    # the environment the test case is run in; you may want tests that
161
169
    # test other combinations.  'dumb' is a reasonable guess for tests
162
 
    # going to a pipe or a StringIO.
 
170
    # going to a pipe or a BytesIO.
163
171
    'TERM': 'dumb',
164
172
    'LINES': '25',
165
173
    'COLUMNS': '80',
166
 
    'BZR_COLUMNS': '80',
 
174
    'BRZ_COLUMNS': '80',
167
175
    # Disable SSH Agent
168
176
    'SSH_AUTH_SOCK': None,
169
177
    # Proxies
198
206
    """
199
207
    if env is None:
200
208
        env = isolated_environ
201
 
    test._original_os_environ = dict([(var, value)
202
 
                                      for var, value in os.environ.iteritems()])
203
 
    for var, value in env.iteritems():
204
 
        osutils.set_or_unset_env(var, value)
 
209
    test._original_os_environ = dict(**os.environ)
 
210
    for var in env:
 
211
        osutils.set_or_unset_env(var, env[var])
205
212
        if var not in test._original_os_environ:
206
213
            # The var is new, add it with a value of None, so
207
214
            # restore_os_environ will delete it
213
220
 
214
221
    :param test: A test instance previously passed to override_os_environ.
215
222
    """
216
 
    for var, value in test._original_os_environ.iteritems():
 
223
    for var, value in test._original_os_environ.items():
217
224
        # Restore the original value (or delete it if the value has been set to
218
225
        # None in override_os_environ).
219
226
        osutils.set_or_unset_env(var, value)
269
276
        """
270
277
        testtools.TextTestResult.__init__(self, stream)
271
278
        if bench_history is not None:
272
 
            from bzrlib.version import _get_bzr_source_tree
 
279
            from breezy.version import _get_bzr_source_tree
273
280
            src_tree = _get_bzr_source_tree()
274
281
            if src_tree:
275
282
                try:
389
396
 
390
397
    def _shortened_test_description(self, test):
391
398
        what = test.id()
392
 
        what = re.sub(r'^bzrlib\.tests\.', '', what)
 
399
        what = re.sub(r'^breezy\.tests\.', '', what)
393
400
        return what
394
401
 
395
402
    # GZ 2010-10-04: Cloned tests may end up harmlessly calling this method
412
419
        addOnException = getattr(test, "addOnException", None)
413
420
        if addOnException is not None:
414
421
            addOnException(self._record_traceback_from_test)
415
 
        # Only check for thread leaks on bzrlib derived test cases
 
422
        # Only check for thread leaks on breezy derived test cases
416
423
        if isinstance(test, TestCase):
417
424
            test.addCleanup(self._check_leaked_threads, test)
418
425
 
535
542
 
536
543
    def _post_mortem(self, tb=None):
537
544
        """Start a PDB post mortem session."""
538
 
        if os.environ.get('BZR_TEST_PDB', None):
 
545
        if os.environ.get('BRZ_TEST_PDB', None):
539
546
            import pdb
540
547
            pdb.post_mortem(tb)
541
548
 
555
562
        else:
556
563
            bzr_path = sys.executable
557
564
        self.stream.write(
558
 
            'bzr selftest: %s\n' % (bzr_path,))
 
565
            'brz selftest: %s\n' % (bzr_path,))
559
566
        self.stream.write(
560
567
            '   %s\n' % (
561
 
                    bzrlib.__path__[0],))
 
568
                    breezy.__path__[0],))
562
569
        self.stream.write(
563
570
            '   bzr-%s python-%s %s\n' % (
564
 
                    bzrlib.version_string,
565
 
                    bzrlib._format_version_tuple(sys.version_info),
 
571
                    breezy.version_string,
 
572
                    breezy._format_version_tuple(sys.version_info),
566
573
                    platform.platform(aliased=1),
567
574
                    ))
568
575
        self.stream.write('\n')
792
799
        # to encode using ascii.
793
800
        new_encoding = osutils.get_terminal_encoding()
794
801
        codec = codecs.lookup(new_encoding)
795
 
        if type(codec) is tuple:
 
802
        if isinstance(codec, tuple):
796
803
            # Python 2.4
797
804
            encode = codec[0]
798
805
        else:
890
897
    """
891
898
 
892
899
 
893
 
class StringIOWrapper(object):
894
 
    """A wrapper around cStringIO which just adds an encoding attribute.
895
 
 
896
 
    Internally we can check sys.stdout to see what the output encoding
897
 
    should be. However, cStringIO has no encoding attribute that we can
898
 
    set. So we wrap it instead.
899
 
    """
900
 
    encoding='ascii'
901
 
    _cstring = None
902
 
 
 
900
class StringIOWrapper(ui_testing.BytesIOWithEncoding):
 
901
 
 
902
    @deprecated_method(deprecated_in((3, 0)))
903
903
    def __init__(self, s=None):
904
 
        if s is not None:
905
 
            self.__dict__['_cstring'] = StringIO(s)
906
 
        else:
907
 
            self.__dict__['_cstring'] = StringIO()
908
 
 
909
 
    def __getattr__(self, name, getattr=getattr):
910
 
        return getattr(self.__dict__['_cstring'], name)
911
 
 
912
 
    def __setattr__(self, name, val):
913
 
        if name == 'encoding':
914
 
            self.__dict__['encoding'] = val
915
 
        else:
916
 
            return setattr(self._cstring, name, val)
917
 
 
918
 
 
919
 
class TestUIFactory(TextUIFactory):
920
 
    """A UI Factory for testing.
921
 
 
922
 
    Hide the progress bar but emit note()s.
923
 
    Redirect stdin.
924
 
    Allows get_password to be tested without real tty attached.
925
 
 
926
 
    See also CannedInputUIFactory which lets you provide programmatic input in
927
 
    a structured way.
928
 
    """
929
 
    # TODO: Capture progress events at the model level and allow them to be
930
 
    # observed by tests that care.
931
 
    #
932
 
    # XXX: Should probably unify more with CannedInputUIFactory or a
933
 
    # particular configuration of TextUIFactory, or otherwise have a clearer
934
 
    # idea of how they're supposed to be different.
935
 
    # See https://bugs.launchpad.net/bzr/+bug/408213
936
 
 
937
 
    def __init__(self, stdout=None, stderr=None, stdin=None):
938
 
        if stdin is not None:
939
 
            # We use a StringIOWrapper to be able to test various
940
 
            # encodings, but the user is still responsible to
941
 
            # encode the string and to set the encoding attribute
942
 
            # of StringIOWrapper.
943
 
            stdin = StringIOWrapper(stdin)
944
 
        super(TestUIFactory, self).__init__(stdin, stdout, stderr)
945
 
 
946
 
    def get_non_echoed_password(self):
947
 
        """Get password from stdin without trying to handle the echo mode"""
948
 
        password = self.stdin.readline()
949
 
        if not password:
950
 
            raise EOFError
951
 
        if password[-1] == '\n':
952
 
            password = password[:-1]
953
 
        return password
954
 
 
955
 
    def make_progress_view(self):
956
 
        return NullProgressView()
 
904
        super(StringIOWrapper, self).__init__(s)
 
905
 
 
906
 
 
907
TestUIFactory = ui_testing.TestUIFactory
957
908
 
958
909
 
959
910
def isolated_doctest_setUp(test):
960
911
    override_os_environ(test)
 
912
    test._orig_ui_factory = ui.ui_factory
 
913
    ui.ui_factory = ui.SilentUIFactory()
961
914
 
962
915
 
963
916
def isolated_doctest_tearDown(test):
964
917
    restore_os_environ(test)
 
918
    ui.ui_factory = test._orig_ui_factory
965
919
 
966
920
 
967
921
def IsolatedDocTestSuite(*args, **kwargs):
976
930
 
977
931
 
978
932
class TestCase(testtools.TestCase):
979
 
    """Base class for bzr unit tests.
 
933
    """Base class for brz unit tests.
980
934
 
981
935
    Tests that need access to disk resources should subclass
982
936
    TestCaseInTempDir not TestCase.
988
942
    is read into memory and removed from disk.
989
943
 
990
944
    There are also convenience functions to invoke bzr's command-line
991
 
    routine, and to build and check bzr trees.
 
945
    routine, and to build and check brz trees.
992
946
 
993
947
    In addition to the usual method of overriding tearDown(), this class also
994
948
    allows subclasses to register cleanup functions via addCleanup, which are
1011
965
    def setUp(self):
1012
966
        super(TestCase, self).setUp()
1013
967
 
1014
 
        # At this point we're still accessing the config files in $BZR_HOME (as
 
968
        # At this point we're still accessing the config files in $BRZ_HOME (as
1015
969
        # set by the user running selftest).
1016
970
        timeout = config.GlobalStack().get('selftest.timeout')
1017
971
        if timeout:
1023
977
            self.requireFeature(feature)
1024
978
        self._cleanEnvironment()
1025
979
 
1026
 
        if bzrlib.global_state is not None:
1027
 
            self.overrideAttr(bzrlib.global_state, 'cmdline_overrides',
 
980
        if breezy.global_state is not None:
 
981
            self.overrideAttr(breezy.global_state, 'cmdline_overrides',
1028
982
                              config.CommandLineStore())
1029
983
 
1030
984
        self._silenceUI()
1038
992
        # Isolate global verbosity level, to make sure it's reproducible
1039
993
        # between tests.  We should get rid of this altogether: bug 656694. --
1040
994
        # mbp 20101008
1041
 
        self.overrideAttr(bzrlib.trace, '_verbosity_level', 0)
 
995
        self.overrideAttr(breezy.trace, '_verbosity_level', 0)
1042
996
        self._log_files = set()
1043
997
        # Each key in the ``_counters`` dict holds a value for a different
1044
998
        # counter. When the test ends, addDetail() should be used to output the
1059
1013
    def discardDetail(self, name):
1060
1014
        """Extend the addDetail, getDetails api so we can remove a detail.
1061
1015
 
1062
 
        eg. bzr always adds the 'log' detail at startup, but we don't want to
 
1016
        eg. brz always adds the 'log' detail at startup, but we don't want to
1063
1017
        include it for skipped, xfail, etc tests.
1064
1018
 
1065
1019
        It is safe to call this for a detail that doesn't exist, in case this
1087
1041
        _counters = self._counters # Avoid closing over self
1088
1042
        if counter_name is None:
1089
1043
            counter_name = name
1090
 
        if _counters.has_key(counter_name):
 
1044
        if counter_name in _counters:
1091
1045
            raise AssertionError('%s is already used as a counter name'
1092
1046
                                  % (counter_name,))
1093
1047
        _counters[counter_name] = 0
1184
1138
                (acquired_locks, released_locks, broken_locks))
1185
1139
            if not self._lock_check_thorough:
1186
1140
                # Rather than fail, just warn
1187
 
                print "Broken test %s: %s" % (self, message)
 
1141
                print("Broken test %s: %s" % (self, message))
1188
1142
                return
1189
1143
            self.fail(message)
1190
1144
 
1221
1175
 
1222
1176
    def permit_url(self, url):
1223
1177
        """Declare that url is an ok url to use in this test.
1224
 
        
 
1178
 
1225
1179
        Do this for memory transports, temporary test directory etc.
1226
 
        
 
1180
 
1227
1181
        Do not do this for the current working directory, /tmp, or any other
1228
1182
        preexisting non isolated url.
1229
1183
        """
1232
1186
        self._bzr_selftest_roots.append(url)
1233
1187
 
1234
1188
    def permit_source_tree_branch_repo(self):
1235
 
        """Permit the source tree bzr is running from to be opened.
 
1189
        """Permit the source tree brz is running from to be opened.
1236
1190
 
1237
 
        Some code such as bzrlib.version attempts to read from the bzr branch
1238
 
        that bzr is executing from (if any). This method permits that directory
 
1191
        Some code such as breezy.version attempts to read from the brz branch
 
1192
        that brz is executing from (if any). This method permits that directory
1239
1193
        to be used in the test suite.
1240
1194
        """
1241
1195
        path = self.get_source_path()
1244
1198
            try:
1245
1199
                workingtree.WorkingTree.open(path)
1246
1200
            except (errors.NotBranchError, errors.NoWorkingTree):
1247
 
                raise TestSkipped('Needs a working tree of bzr sources')
 
1201
                raise TestSkipped('Needs a working tree of brz sources')
1248
1202
        finally:
1249
1203
            self.enable_directory_isolation()
1250
1204
 
1282
1236
 
1283
1237
    def record_directory_isolation(self):
1284
1238
        """Gather accessed directories to permit later access.
1285
 
        
1286
 
        This is used for tests that access the branch bzr is running from.
 
1239
 
 
1240
        This is used for tests that access the branch brz is running from.
1287
1241
        """
1288
1242
        self._directory_isolation = "record"
1289
1243
 
1334
1288
        # TestCase has no safe place it can write to.
1335
1289
        self._bzr_selftest_roots = []
1336
1290
        # Currently the easiest way to be sure that nothing is going on is to
1337
 
        # hook into bzr dir opening. This leaves a small window of error for
 
1291
        # hook into brz dir opening. This leaves a small window of error for
1338
1292
        # transport tests, but they are well known, and we can improve on this
1339
1293
        # step.
1340
1294
        controldir.ControlDir.hooks.install_named_hook("pre_open",
1341
 
            self._preopen_isolate_transport, "Check bzr directories are safe.")
 
1295
            self._preopen_isolate_transport, "Check brz directories are safe.")
1342
1296
 
1343
1297
    def _ndiff_strings(self, a, b):
1344
1298
        """Return ndiff between two strings containing lines.
1359
1313
        try:
1360
1314
            if a == b:
1361
1315
                return
1362
 
        except UnicodeError, e:
 
1316
        except UnicodeError as e:
1363
1317
            # If we can't compare without getting a UnicodeError, then
1364
1318
            # obviously they are different
1365
1319
            trace.mutter('UnicodeError: %s', e)
1508
1462
        """
1509
1463
        try:
1510
1464
            list(func(*args, **kwargs))
1511
 
        except excClass, e:
 
1465
        except excClass as e:
1512
1466
            return e
1513
1467
        else:
1514
1468
            if getattr(excClass,'__name__', None) is not None:
1515
1469
                excName = excClass.__name__
1516
1470
            else:
1517
1471
                excName = str(excClass)
1518
 
            raise self.failureException, "%s not raised" % excName
 
1472
            raise self.failureException("%s not raised" % excName)
1519
1473
 
1520
1474
    def assertRaises(self, excClass, callableObj, *args, **kwargs):
1521
1475
        """Assert that a callable raises a particular exception.
1529
1483
        """
1530
1484
        try:
1531
1485
            callableObj(*args, **kwargs)
1532
 
        except excClass, e:
 
1486
        except excClass as e:
1533
1487
            return e
1534
1488
        else:
1535
1489
            if getattr(excClass,'__name__', None) is not None:
1537
1491
            else:
1538
1492
                # probably a tuple
1539
1493
                excName = str(excClass)
1540
 
            raise self.failureException, "%s not raised" % excName
 
1494
            raise self.failureException("%s not raised" % excName)
1541
1495
 
1542
1496
    def assertIs(self, left, right, message=None):
1543
1497
        if not (left is right):
1744
1698
 
1745
1699
    def _startLogFile(self):
1746
1700
        """Setup a in-memory target for bzr and testcase log messages"""
1747
 
        pseudo_log_file = StringIO()
 
1701
        pseudo_log_file = BytesIO()
1748
1702
        def _get_log_contents_for_weird_testtools_api():
1749
1703
            return [pseudo_log_file.getvalue().decode(
1750
1704
                "utf-8", "replace").encode("utf-8")]
1840
1794
        return calls
1841
1795
 
1842
1796
    def _cleanEnvironment(self):
1843
 
        for name, value in isolated_environ.iteritems():
 
1797
        for name, value in isolated_environ.items():
1844
1798
            self.overrideEnv(name, value)
1845
1799
 
1846
1800
    def _restoreHooks(self):
1847
1801
        for klass, (name, hooks) in self._preserved_hooks.items():
1848
1802
            setattr(klass, name, hooks)
1849
1803
        self._preserved_hooks.clear()
1850
 
        bzrlib.hooks._lazy_hooks = self._preserved_lazy_hooks
 
1804
        breezy.hooks._lazy_hooks = self._preserved_lazy_hooks
1851
1805
        self._preserved_lazy_hooks.clear()
1852
1806
 
1853
1807
    def knownFailure(self, reason):
1945
1899
    def time(self, callable, *args, **kwargs):
1946
1900
        """Run callable and accrue the time it takes to the benchmark time.
1947
1901
 
1948
 
        If lsprofiling is enabled (i.e. by --lsprof-time to bzr selftest) then
 
1902
        If lsprofiling is enabled (i.e. by --lsprof-time to brz selftest) then
1949
1903
        this will cause lsprofile statistics to be gathered and stored in
1950
1904
        self._benchcalls.
1951
1905
        """
1959
1913
                return callable(*args, **kwargs)
1960
1914
            else:
1961
1915
                # record this benchmark
1962
 
                ret, stats = bzrlib.lsprof.profile(callable, *args, **kwargs)
 
1916
                ret, stats = breezy.lsprof.profile(callable, *args, **kwargs)
1963
1917
                stats.sort()
1964
1918
                self._benchcalls.append(((callable, args, kwargs), stats))
1965
1919
                return ret
1970
1924
        trace.mutter(*args)
1971
1925
 
1972
1926
    def get_log(self):
1973
 
        """Get a unicode string containing the log from bzrlib.trace.
 
1927
        """Get a unicode string containing the log from breezy.trace.
1974
1928
 
1975
1929
        Undecodable characters are replaced.
1976
1930
        """
1987
1941
    def _run_bzr_autosplit(self, args, retcode, encoding, stdin,
1988
1942
            working_dir):
1989
1943
        """Run bazaar command line, splitting up a string command line."""
1990
 
        if isinstance(args, basestring):
1991
 
            # shlex don't understand unicode strings,
1992
 
            # so args should be plain string (bialix 20070906)
1993
 
            args = list(shlex.split(str(args)))
 
1944
        if isinstance(args, string_types):
 
1945
            args = shlex.split(args)
1994
1946
        return self._run_bzr_core(args, retcode=retcode,
1995
1947
                encoding=encoding, stdin=stdin, working_dir=working_dir,
1996
1948
                )
2002
1954
        chk_map.clear_cache()
2003
1955
        if encoding is None:
2004
1956
            encoding = osutils.get_user_encoding()
2005
 
        stdout = StringIOWrapper()
2006
 
        stderr = StringIOWrapper()
2007
 
        stdout.encoding = encoding
2008
 
        stderr.encoding = encoding
2009
 
 
2010
 
        self.log('run bzr: %r', args)
 
1957
 
 
1958
        self.log('run brz: %r', args)
 
1959
 
 
1960
        stdout = ui_testing.BytesIOWithEncoding()
 
1961
        stderr = ui_testing.BytesIOWithEncoding()
 
1962
        stdout.encoding = stderr.encoding = encoding
 
1963
 
2011
1964
        # FIXME: don't call into logging here
2012
 
        handler = trace.EncodedStreamHandler(stderr, errors="replace",
2013
 
            level=logging.INFO)
 
1965
        handler = trace.EncodedStreamHandler(
 
1966
            stderr, errors="replace", level=logging.INFO)
2014
1967
        logger = logging.getLogger('')
2015
1968
        logger.addHandler(handler)
 
1969
 
 
1970
        self._last_cmd_stdout = codecs.getwriter(encoding)(stdout)
 
1971
        self._last_cmd_stderr = codecs.getwriter(encoding)(stderr)
 
1972
 
2016
1973
        old_ui_factory = ui.ui_factory
2017
 
        ui.ui_factory = TestUIFactory(stdin=stdin, stdout=stdout, stderr=stderr)
 
1974
        ui.ui_factory = ui_testing.TestUIFactory(
 
1975
            stdin=stdin,
 
1976
            stdout=self._last_cmd_stdout,
 
1977
            stderr=self._last_cmd_stderr)
2018
1978
 
2019
1979
        cwd = None
2020
1980
        if working_dir is not None:
2022
1982
            os.chdir(working_dir)
2023
1983
 
2024
1984
        try:
2025
 
            try:
2026
 
                result = self.apply_redirected(
2027
 
                    ui.ui_factory.stdin,
2028
 
                    stdout, stderr,
2029
 
                    _mod_commands.run_bzr_catch_user_errors,
2030
 
                    args)
2031
 
            except KeyboardInterrupt:
2032
 
                # Reraise KeyboardInterrupt with contents of redirected stdout
2033
 
                # and stderr as arguments, for tests which are interested in
2034
 
                # stdout and stderr and are expecting the exception.
2035
 
                out = stdout.getvalue()
2036
 
                err = stderr.getvalue()
2037
 
                if out:
2038
 
                    self.log('output:\n%r', out)
2039
 
                if err:
2040
 
                    self.log('errors:\n%r', err)
2041
 
                raise KeyboardInterrupt(out, err)
 
1985
            result = self.apply_redirected(
 
1986
                ui.ui_factory.stdin,
 
1987
                stdout, stderr,
 
1988
                _mod_commands.run_bzr_catch_user_errors,
 
1989
                args)
2042
1990
        finally:
2043
1991
            logger.removeHandler(handler)
2044
1992
            ui.ui_factory = old_ui_factory
2056
2004
                              message='Unexpected return code')
2057
2005
        return result, out, err
2058
2006
 
2059
 
    def run_bzr(self, args, retcode=0, encoding=None, stdin=None,
2060
 
                working_dir=None, error_regexes=[], output_encoding=None):
2061
 
        """Invoke bzr, as if it were run from the command line.
 
2007
    def run_bzr(self, args, retcode=0, stdin=None, encoding=None,
 
2008
                working_dir=None, error_regexes=[]):
 
2009
        """Invoke brz, as if it were run from the command line.
2062
2010
 
2063
 
        The argument list should not include the bzr program name - the
2064
 
        first argument is normally the bzr command.  Arguments may be
 
2011
        The argument list should not include the brz program name - the
 
2012
        first argument is normally the brz command.  Arguments may be
2065
2013
        passed in three ways:
2066
2014
 
2067
2015
        1- A list of strings, eg ["commit", "a"].  This is recommended
2071
2019
        2- A single string, eg "add a".  This is the most convenient
2072
2020
        for hardcoded commands.
2073
2021
 
2074
 
        This runs bzr through the interface that catches and reports
 
2022
        This runs brz through the interface that catches and reports
2075
2023
        errors, and with logging set to something approximating the
2076
2024
        default, so that error reporting can be checked.
2077
2025
 
2078
2026
        This should be the main method for tests that want to exercise the
2079
 
        overall behavior of the bzr application (rather than a unit test
 
2027
        overall behavior of the brz application (rather than a unit test
2080
2028
        or a functional test of the library.)
2081
2029
 
2082
2030
        This sends the stdout/stderr results into the test's log,
2102
2050
        return out, err
2103
2051
 
2104
2052
    def run_bzr_error(self, error_regexes, *args, **kwargs):
2105
 
        """Run bzr, and check that stderr contains the supplied regexes
 
2053
        """Run brz, and check that stderr contains the supplied regexes
2106
2054
 
2107
2055
        :param error_regexes: Sequence of regular expressions which
2108
2056
            must each be found in the error output. The relative ordering
2109
2057
            is not enforced.
2110
 
        :param args: command-line arguments for bzr
2111
 
        :param kwargs: Keyword arguments which are interpreted by run_bzr
 
2058
        :param args: command-line arguments for brz
 
2059
        :param kwargs: Keyword arguments which are interpreted by run_brz
2112
2060
            This function changes the default value of retcode to be 3,
2113
 
            since in most cases this is run when you expect bzr to fail.
 
2061
            since in most cases this is run when you expect brz to fail.
2114
2062
 
2115
2063
        :return: (out, err) The actual output of running the command (in case
2116
2064
            you want to do more inspection)
2132
2080
        return out, err
2133
2081
 
2134
2082
    def run_bzr_subprocess(self, *args, **kwargs):
2135
 
        """Run bzr in a subprocess for testing.
 
2083
        """Run brz in a subprocess for testing.
2136
2084
 
2137
 
        This starts a new Python interpreter and runs bzr in there.
 
2085
        This starts a new Python interpreter and runs brz in there.
2138
2086
        This should only be used for tests that have a justifiable need for
2139
2087
        this isolation: e.g. they are testing startup time, or signal
2140
2088
        handling, or early startup code, etc.  Subprocess code can't be
2175
2123
                             skip_if_plan_to_signal=False,
2176
2124
                             working_dir=None,
2177
2125
                             allow_plugins=False, stderr=subprocess.PIPE):
2178
 
        """Start bzr in a subprocess for testing.
 
2126
        """Start brz in a subprocess for testing.
2179
2127
 
2180
 
        This starts a new Python interpreter and runs bzr in there.
 
2128
        This starts a new Python interpreter and runs brz in there.
2181
2129
        This should only be used for tests that have a justifiable need for
2182
2130
        this isolation: e.g. they are testing startup time, or signal
2183
2131
        handling, or early startup code, etc.  Subprocess code can't be
2184
2132
        profiled or debugged so easily.
2185
2133
 
2186
 
        :param process_args: a list of arguments to pass to the bzr executable,
 
2134
        :param process_args: a list of arguments to pass to the brz executable,
2187
2135
            for example ``['--version']``.
2188
2136
        :param env_changes: A dictionary which lists changes to environment
2189
2137
            variables. A value of None will unset the env variable.
2191
2139
            child, so you don't need to fix the environment after running.
2192
2140
        :param skip_if_plan_to_signal: raise TestSkipped when true and system
2193
2141
            doesn't support signalling subprocesses.
2194
 
        :param allow_plugins: If False (default) pass --no-plugins to bzr.
 
2142
        :param allow_plugins: If False (default) pass --no-plugins to brz.
2195
2143
        :param stderr: file to use for the subprocess's stderr.  Valid values
2196
2144
            are those valid for the stderr argument of `subprocess.Popen`.
2197
2145
            Default value is ``subprocess.PIPE``.
2212
2160
        old_env = {}
2213
2161
 
2214
2162
        def cleanup_environment():
2215
 
            for env_var, value in env_changes.iteritems():
 
2163
            for env_var, value in env_changes.items():
2216
2164
                old_env[env_var] = osutils.set_or_unset_env(env_var, value)
2217
2165
 
2218
2166
        def restore_environment():
2219
 
            for env_var, value in old_env.iteritems():
 
2167
            for env_var, value in old_env.items():
2220
2168
                osutils.set_or_unset_env(env_var, value)
2221
2169
 
2222
 
        bzr_path = self.get_bzr_path()
 
2170
        bzr_path = self.get_brz_path()
2223
2171
 
2224
2172
        cwd = None
2225
2173
        if working_dir is not None:
2233
2181
            cleanup_environment()
2234
2182
            # Include the subprocess's log file in the test details, in case
2235
2183
            # the test fails due to an error in the subprocess.
2236
 
            self._add_subprocess_log(trace._get_bzr_log_filename())
 
2184
            self._add_subprocess_log(trace._get_brz_log_filename())
2237
2185
            command = [sys.executable]
2238
2186
            # frozen executables don't need the path to bzr
2239
2187
            if getattr(sys, "frozen", None) is None:
2287
2235
        return subprocess.Popen(*args, **kwargs)
2288
2236
 
2289
2237
    def get_source_path(self):
2290
 
        """Return the path of the directory containing bzrlib."""
2291
 
        return os.path.dirname(os.path.dirname(bzrlib.__file__))
 
2238
        """Return the path of the directory containing breezy."""
 
2239
        return os.path.dirname(os.path.dirname(breezy.__file__))
2292
2240
 
2293
 
    def get_bzr_path(self):
2294
 
        """Return the path of the 'bzr' executable for this test suite."""
2295
 
        bzr_path = os.path.join(self.get_source_path(), "bzr")
2296
 
        if not os.path.isfile(bzr_path):
 
2241
    def get_brz_path(self):
 
2242
        """Return the path of the 'brz' executable for this test suite."""
 
2243
        brz_path = os.path.join(self.get_source_path(), "brz")
 
2244
        if not os.path.isfile(brz_path):
2297
2245
            # We are probably installed. Assume sys.argv is the right file
2298
 
            bzr_path = sys.argv[0]
2299
 
        return bzr_path
 
2246
            brz_path = sys.argv[0]
 
2247
        return brz_path
2300
2248
 
2301
2249
    def finish_bzr_subprocess(self, process, retcode=0, send_signal=None,
2302
2250
                              universal_newlines=False, process_args=None):
2320
2268
        if retcode is not None and retcode != process.returncode:
2321
2269
            if process_args is None:
2322
2270
                process_args = "(unknown args)"
2323
 
            trace.mutter('Output of bzr %s:\n%s', process_args, out)
2324
 
            trace.mutter('Error for bzr %s:\n%s', process_args, err)
2325
 
            self.fail('Command bzr %s failed with retcode %s != %s'
 
2271
            trace.mutter('Output of brz %s:\n%s', process_args, out)
 
2272
            trace.mutter('Error for brz %s:\n%s', process_args, err)
 
2273
            self.fail('Command brz %s failed with retcode %s != %s'
2326
2274
                      % (process_args, retcode, process.returncode))
2327
2275
        return [out, err]
2328
2276
 
2356
2304
        if not callable(a_callable):
2357
2305
            raise ValueError("a_callable must be callable.")
2358
2306
        if stdin is None:
2359
 
            stdin = StringIO("")
 
2307
            stdin = BytesIO("")
2360
2308
        if stdout is None:
2361
2309
            if getattr(self, "_log_file", None) is not None:
2362
2310
                stdout = self._log_file
2363
2311
            else:
2364
 
                stdout = StringIO()
 
2312
                stdout = BytesIO()
2365
2313
        if stderr is None:
2366
2314
            if getattr(self, "_log_file", None is not None):
2367
2315
                stderr = self._log_file
2368
2316
            else:
2369
 
                stderr = StringIO()
 
2317
                stderr = BytesIO()
2370
2318
        real_stdin = sys.stdin
2371
2319
        real_stdout = sys.stdout
2372
2320
        real_stderr = sys.stderr
2389
2337
        self.overrideAttr(lockdir, '_DEFAULT_TIMEOUT_SECONDS', 0)
2390
2338
 
2391
2339
    def make_utf8_encoded_stringio(self, encoding_type=None):
2392
 
        """Return a StringIOWrapper instance, that will encode Unicode
2393
 
        input to UTF-8.
2394
 
        """
 
2340
        """Return a wrapped BytesIO, that will encode text input to UTF-8."""
2395
2341
        if encoding_type is None:
2396
2342
            encoding_type = 'strict'
2397
 
        sio = StringIO()
 
2343
        bio = BytesIO()
2398
2344
        output_encoding = 'utf-8'
2399
 
        sio = codecs.getwriter(output_encoding)(sio, errors=encoding_type)
 
2345
        sio = codecs.getwriter(output_encoding)(bio, errors=encoding_type)
2400
2346
        sio.encoding = output_encoding
2401
2347
        return sio
2402
2348
 
2403
2349
    def disable_verb(self, verb):
2404
2350
        """Disable a smart server verb for one test."""
2405
 
        from bzrlib.smart import request
 
2351
        from breezy.smart import request
2406
2352
        request_handlers = request.request_handlers
2407
2353
        orig_method = request_handlers.get(verb)
2408
2354
        orig_info = request_handlers.get_info(verb)
2410
2356
        self.addCleanup(request_handlers.register, verb, orig_method,
2411
2357
            info=orig_info)
2412
2358
 
 
2359
    def __hash__(self):
 
2360
        return id(self)
 
2361
 
2413
2362
 
2414
2363
class CapturedCall(object):
2415
2364
    """A helper for capturing smart server calls for easy debug analysis."""
2440
2389
    Tests that need disk resources should derive from TestCaseInTempDir
2441
2390
    orTestCaseWithTransport.
2442
2391
 
2443
 
    TestCaseWithMemoryTransport sets the TEST_ROOT variable for all bzr tests.
 
2392
    TestCaseWithMemoryTransport sets the TEST_ROOT variable for all brz tests.
2444
2393
 
2445
2394
    For TestCaseWithMemoryTransport the ``test_home_dir`` is set to the name of
2446
2395
    a directory which does not exist. This serves to help ensure test isolation
2484
2433
            _add_disconnect_cleanup, None)
2485
2434
 
2486
2435
        self._make_test_root()
2487
 
        self.addCleanup(os.chdir, os.getcwdu())
 
2436
        self.addCleanup(os.chdir, osutils.getcwd())
2488
2437
        self.makeAndChdirToTestDir()
2489
2438
        self.overrideEnvironmentForTesting()
2490
2439
        self.__readonly_server = None
2644
2593
        """
2645
2594
        root = TestCaseWithMemoryTransport.TEST_ROOT
2646
2595
        try:
2647
 
            # Make sure we get a readable and accessible home for .bzr.log
 
2596
            # Make sure we get a readable and accessible home for .brz.log
2648
2597
            # and/or config files, and not fallback to weird defaults (see
2649
2598
            # http://pad.lv/825027).
2650
 
            self.assertIs(None, os.environ.get('BZR_HOME', None))
2651
 
            os.environ['BZR_HOME'] = root
 
2599
            self.assertIs(None, os.environ.get('BRZ_HOME', None))
 
2600
            os.environ['BRZ_HOME'] = root
2652
2601
            wt = controldir.ControlDir.create_standalone_workingtree(root)
2653
 
            del os.environ['BZR_HOME']
2654
 
        except Exception, e:
 
2602
            del os.environ['BRZ_HOME']
 
2603
        except Exception as e:
2655
2604
            self.fail("Fail to initialize the safety net: %r\n" % (e,))
2656
2605
        # Hack for speed: remember the raw bytes of the dirstate file so that
2657
2606
        # we don't need to re-open the wt to check it hasn't changed.
2776
2725
 
2777
2726
    def overrideEnvironmentForTesting(self):
2778
2727
        test_home_dir = self.test_home_dir
2779
 
        if isinstance(test_home_dir, unicode):
 
2728
        if isinstance(test_home_dir, text_type):
2780
2729
            test_home_dir = test_home_dir.encode(sys.getfilesystemencoding())
2781
2730
        self.overrideEnv('HOME', test_home_dir)
2782
 
        self.overrideEnv('BZR_HOME', test_home_dir)
 
2731
        self.overrideEnv('BRZ_HOME', test_home_dir)
2783
2732
 
2784
2733
    def setup_smart_server_with_call_log(self):
2785
2734
        """Sets up a smart server as the transport server with a call log."""
2831
2780
        super(TestCaseInTempDir, self).setUp()
2832
2781
        # Remove the protection set in isolated_environ, we have a proper
2833
2782
        # access to disk resources now.
2834
 
        self.overrideEnv('BZR_LOG', None)
 
2783
        self.overrideEnv('BRZ_LOG', None)
2835
2784
 
2836
2785
    def check_file_contents(self, filename, expect):
2837
2786
        self.log("check contents of file %s" % filename)
3087
3036
    """
3088
3037
 
3089
3038
    def setUp(self):
3090
 
        from bzrlib.tests import http_server
 
3039
        from breezy.tests import http_server
3091
3040
        super(ChrootedTestCase, self).setUp()
3092
3041
        if not self.vfs_transport_factory == memory.MemoryServer:
3093
3042
            self.transport_readonly_server = http_server.HttpServer
3295
3244
              stream=None,
3296
3245
              result_decorators=None,
3297
3246
              ):
3298
 
    """Run a test suite for bzr selftest.
 
3247
    """Run a test suite for brz selftest.
3299
3248
 
3300
3249
    :param runner_class: The class of runner to use. Must support the
3301
3250
        constructor arguments passed by run_suite which are more than standard
3399
3348
 
3400
3349
def random_order(random_seed, runner):
3401
3350
    """Return a test suite decorator factory for randomising tests order.
3402
 
    
3403
 
    :param random_seed: now, a string which casts to a long, or a long.
 
3351
 
 
3352
    :param random_seed: now, a string which casts to an integer, or an integer.
3404
3353
    :param runner: A test runner with a stream attribute to report on.
3405
3354
    """
3406
3355
    if random_seed is None:
3478
3427
    @staticmethod
3479
3428
    def actual_seed(seed):
3480
3429
        if seed == "now":
3481
 
            # We convert the seed to a long to make it reuseable across
 
3430
            # We convert the seed to an integer to make it reuseable across
3482
3431
            # invocations (because the user can reenter it).
3483
 
            return long(time.time())
 
3432
            return int(time.time())
3484
3433
        else:
3485
 
            # Convert the seed to a long if we can
 
3434
            # Convert the seed to an integer if we can
3486
3435
            try:
3487
 
                return long(seed)
 
3436
                return int(seed)
3488
3437
            except (TypeError, ValueError):
3489
3438
                pass
3490
3439
        return seed
3615
3564
    test_blocks = partition_tests(suite, concurrency)
3616
3565
    for process_tests in test_blocks:
3617
3566
        # ugly; currently reimplement rather than reuses TestCase methods.
3618
 
        bzr_path = os.path.dirname(os.path.dirname(bzrlib.__file__))+'/bzr'
 
3567
        bzr_path = os.path.dirname(os.path.dirname(breezy.__file__))+'/bzr'
3619
3568
        if not os.path.isfile(bzr_path):
3620
3569
            # We are probably installed. Assume sys.argv is the right file
3621
3570
            bzr_path = sys.argv[0]
3660
3609
    """
3661
3610
 
3662
3611
    def startTest(self, test):
3663
 
        self.profiler = bzrlib.lsprof.BzrProfiler()
 
3612
        self.profiler = breezy.lsprof.BzrProfiler()
3664
3613
        # Prevent deadlocks in tests that use lsprof: those tests will
3665
3614
        # unavoidably fail.
3666
 
        bzrlib.lsprof.BzrProfiler.profiler_block = 0
 
3615
        breezy.lsprof.BzrProfiler.profiler_block = 0
3667
3616
        self.profiler.start()
3668
3617
        testtools.ExtendedToOriginalDecorator.startTest(self, test)
3669
3618
 
3682
3631
        self.profiler = None
3683
3632
 
3684
3633
 
3685
 
# Controlled by "bzr selftest -E=..." option
 
3634
# Controlled by "brz selftest -E=..." option
3686
3635
# Currently supported:
3687
3636
#   -Eallow_debug           Will no longer clear debug.debug_flags() so it
3688
3637
#                           preserves any flags supplied at the command line.
3720
3669
    # XXX: Very ugly way to do this...
3721
3670
    # Disable warning about old formats because we don't want it to disturb
3722
3671
    # any blackbox tests.
3723
 
    from bzrlib import repository
 
3672
    from breezy import repository
3724
3673
    repository._deprecation_warning_done = True
3725
3674
 
3726
3675
    global default_transport
3783
3732
    test_list = []
3784
3733
    try:
3785
3734
        ftest = open(file_name, 'rt')
3786
 
    except IOError, e:
 
3735
    except IOError as e:
3787
3736
        if e.errno != errno.ENOENT:
3788
3737
            raise
3789
3738
        else:
3868
3817
 
3869
3818
    def refers_to(self, module_name):
3870
3819
        """Is there tests for the module or one of its sub modules."""
3871
 
        return self.modules.has_key(module_name)
 
3820
        return module_name in self.modules
3872
3821
 
3873
3822
    def includes(self, test_id):
3874
 
        return self.tests.has_key(test_id)
 
3823
        return test_id in self.tests
3875
3824
 
3876
3825
 
3877
3826
class TestPrefixAliasRegistry(registry.Registry):
3917
3866
 
3918
3867
 
3919
3868
# This alias allows to detect typos ('bzrlin.') by making all valid test ids
3920
 
# appear prefixed ('bzrlib.' is "replaced" by 'bzrlib.').
3921
 
test_prefix_alias_registry.register('bzrlib', 'bzrlib')
 
3869
# appear prefixed ('breezy.' is "replaced" by 'breezy.').
 
3870
test_prefix_alias_registry.register('breezy', 'breezy')
3922
3871
 
3923
3872
# Obvious highest levels prefixes, feel free to add your own via a plugin
3924
 
test_prefix_alias_registry.register('bd', 'bzrlib.doc')
3925
 
test_prefix_alias_registry.register('bu', 'bzrlib.utils')
3926
 
test_prefix_alias_registry.register('bt', 'bzrlib.tests')
3927
 
test_prefix_alias_registry.register('bb', 'bzrlib.tests.blackbox')
3928
 
test_prefix_alias_registry.register('bp', 'bzrlib.plugins')
 
3873
test_prefix_alias_registry.register('bd', 'breezy.doc')
 
3874
test_prefix_alias_registry.register('bu', 'breezy.utils')
 
3875
test_prefix_alias_registry.register('bt', 'breezy.tests')
 
3876
test_prefix_alias_registry.register('bb', 'breezy.tests.blackbox')
 
3877
test_prefix_alias_registry.register('bp', 'breezy.plugins')
3929
3878
 
3930
3879
 
3931
3880
def _test_suite_testmod_names():
3932
3881
    """Return the standard list of test module names to test."""
3933
3882
    return [
3934
 
        'bzrlib.doc',
3935
 
        'bzrlib.tests.blackbox',
3936
 
        'bzrlib.tests.commands',
3937
 
        'bzrlib.tests.per_branch',
3938
 
        'bzrlib.tests.per_bzrdir',
3939
 
        'bzrlib.tests.per_controldir',
3940
 
        'bzrlib.tests.per_controldir_colo',
3941
 
        'bzrlib.tests.per_foreign_vcs',
3942
 
        'bzrlib.tests.per_interrepository',
3943
 
        'bzrlib.tests.per_intertree',
3944
 
        'bzrlib.tests.per_inventory',
3945
 
        'bzrlib.tests.per_interbranch',
3946
 
        'bzrlib.tests.per_lock',
3947
 
        'bzrlib.tests.per_merger',
3948
 
        'bzrlib.tests.per_transport',
3949
 
        'bzrlib.tests.per_tree',
3950
 
        'bzrlib.tests.per_pack_repository',
3951
 
        'bzrlib.tests.per_repository',
3952
 
        'bzrlib.tests.per_repository_chk',
3953
 
        'bzrlib.tests.per_repository_reference',
3954
 
        'bzrlib.tests.per_repository_vf',
3955
 
        'bzrlib.tests.per_uifactory',
3956
 
        'bzrlib.tests.per_versionedfile',
3957
 
        'bzrlib.tests.per_workingtree',
3958
 
        'bzrlib.tests.test__annotator',
3959
 
        'bzrlib.tests.test__bencode',
3960
 
        'bzrlib.tests.test__btree_serializer',
3961
 
        'bzrlib.tests.test__chk_map',
3962
 
        'bzrlib.tests.test__dirstate_helpers',
3963
 
        'bzrlib.tests.test__groupcompress',
3964
 
        'bzrlib.tests.test__known_graph',
3965
 
        'bzrlib.tests.test__rio',
3966
 
        'bzrlib.tests.test__simple_set',
3967
 
        'bzrlib.tests.test__static_tuple',
3968
 
        'bzrlib.tests.test__walkdirs_win32',
3969
 
        'bzrlib.tests.test_ancestry',
3970
 
        'bzrlib.tests.test_annotate',
3971
 
        'bzrlib.tests.test_api',
3972
 
        'bzrlib.tests.test_atomicfile',
3973
 
        'bzrlib.tests.test_bad_files',
3974
 
        'bzrlib.tests.test_bisect_multi',
3975
 
        'bzrlib.tests.test_branch',
3976
 
        'bzrlib.tests.test_branchbuilder',
3977
 
        'bzrlib.tests.test_btree_index',
3978
 
        'bzrlib.tests.test_bugtracker',
3979
 
        'bzrlib.tests.test_bundle',
3980
 
        'bzrlib.tests.test_bzrdir',
3981
 
        'bzrlib.tests.test__chunks_to_lines',
3982
 
        'bzrlib.tests.test_cache_utf8',
3983
 
        'bzrlib.tests.test_chk_map',
3984
 
        'bzrlib.tests.test_chk_serializer',
3985
 
        'bzrlib.tests.test_chunk_writer',
3986
 
        'bzrlib.tests.test_clean_tree',
3987
 
        'bzrlib.tests.test_cleanup',
3988
 
        'bzrlib.tests.test_cmdline',
3989
 
        'bzrlib.tests.test_commands',
3990
 
        'bzrlib.tests.test_commit',
3991
 
        'bzrlib.tests.test_commit_merge',
3992
 
        'bzrlib.tests.test_config',
3993
 
        'bzrlib.tests.test_conflicts',
3994
 
        'bzrlib.tests.test_controldir',
3995
 
        'bzrlib.tests.test_counted_lock',
3996
 
        'bzrlib.tests.test_crash',
3997
 
        'bzrlib.tests.test_decorators',
3998
 
        'bzrlib.tests.test_delta',
3999
 
        'bzrlib.tests.test_debug',
4000
 
        'bzrlib.tests.test_diff',
4001
 
        'bzrlib.tests.test_directory_service',
4002
 
        'bzrlib.tests.test_dirstate',
4003
 
        'bzrlib.tests.test_email_message',
4004
 
        'bzrlib.tests.test_eol_filters',
4005
 
        'bzrlib.tests.test_errors',
4006
 
        'bzrlib.tests.test_estimate_compressed_size',
4007
 
        'bzrlib.tests.test_export',
4008
 
        'bzrlib.tests.test_export_pot',
4009
 
        'bzrlib.tests.test_extract',
4010
 
        'bzrlib.tests.test_features',
4011
 
        'bzrlib.tests.test_fetch',
4012
 
        'bzrlib.tests.test_fixtures',
4013
 
        'bzrlib.tests.test_fifo_cache',
4014
 
        'bzrlib.tests.test_filters',
4015
 
        'bzrlib.tests.test_filter_tree',
4016
 
        'bzrlib.tests.test_ftp_transport',
4017
 
        'bzrlib.tests.test_foreign',
4018
 
        'bzrlib.tests.test_generate_docs',
4019
 
        'bzrlib.tests.test_generate_ids',
4020
 
        'bzrlib.tests.test_globbing',
4021
 
        'bzrlib.tests.test_gpg',
4022
 
        'bzrlib.tests.test_graph',
4023
 
        'bzrlib.tests.test_groupcompress',
4024
 
        'bzrlib.tests.test_hashcache',
4025
 
        'bzrlib.tests.test_help',
4026
 
        'bzrlib.tests.test_hooks',
4027
 
        'bzrlib.tests.test_http',
4028
 
        'bzrlib.tests.test_http_response',
4029
 
        'bzrlib.tests.test_https_ca_bundle',
4030
 
        'bzrlib.tests.test_https_urllib',
4031
 
        'bzrlib.tests.test_i18n',
4032
 
        'bzrlib.tests.test_identitymap',
4033
 
        'bzrlib.tests.test_ignores',
4034
 
        'bzrlib.tests.test_index',
4035
 
        'bzrlib.tests.test_import_tariff',
4036
 
        'bzrlib.tests.test_info',
4037
 
        'bzrlib.tests.test_inv',
4038
 
        'bzrlib.tests.test_inventory_delta',
4039
 
        'bzrlib.tests.test_knit',
4040
 
        'bzrlib.tests.test_lazy_import',
4041
 
        'bzrlib.tests.test_lazy_regex',
4042
 
        'bzrlib.tests.test_library_state',
4043
 
        'bzrlib.tests.test_lock',
4044
 
        'bzrlib.tests.test_lockable_files',
4045
 
        'bzrlib.tests.test_lockdir',
4046
 
        'bzrlib.tests.test_log',
4047
 
        'bzrlib.tests.test_lru_cache',
4048
 
        'bzrlib.tests.test_lsprof',
4049
 
        'bzrlib.tests.test_mail_client',
4050
 
        'bzrlib.tests.test_matchers',
4051
 
        'bzrlib.tests.test_memorytree',
4052
 
        'bzrlib.tests.test_merge',
4053
 
        'bzrlib.tests.test_merge3',
4054
 
        'bzrlib.tests.test_merge_core',
4055
 
        'bzrlib.tests.test_merge_directive',
4056
 
        'bzrlib.tests.test_mergetools',
4057
 
        'bzrlib.tests.test_missing',
4058
 
        'bzrlib.tests.test_msgeditor',
4059
 
        'bzrlib.tests.test_multiparent',
4060
 
        'bzrlib.tests.test_mutabletree',
4061
 
        'bzrlib.tests.test_nonascii',
4062
 
        'bzrlib.tests.test_options',
4063
 
        'bzrlib.tests.test_osutils',
4064
 
        'bzrlib.tests.test_osutils_encodings',
4065
 
        'bzrlib.tests.test_pack',
4066
 
        'bzrlib.tests.test_patch',
4067
 
        'bzrlib.tests.test_patches',
4068
 
        'bzrlib.tests.test_permissions',
4069
 
        'bzrlib.tests.test_plugins',
4070
 
        'bzrlib.tests.test_progress',
4071
 
        'bzrlib.tests.test_pyutils',
4072
 
        'bzrlib.tests.test_read_bundle',
4073
 
        'bzrlib.tests.test_reconcile',
4074
 
        'bzrlib.tests.test_reconfigure',
4075
 
        'bzrlib.tests.test_registry',
4076
 
        'bzrlib.tests.test_remote',
4077
 
        'bzrlib.tests.test_rename_map',
4078
 
        'bzrlib.tests.test_repository',
4079
 
        'bzrlib.tests.test_revert',
4080
 
        'bzrlib.tests.test_revision',
4081
 
        'bzrlib.tests.test_revisionspec',
4082
 
        'bzrlib.tests.test_revisiontree',
4083
 
        'bzrlib.tests.test_rio',
4084
 
        'bzrlib.tests.test_rules',
4085
 
        'bzrlib.tests.test_url_policy_open',
4086
 
        'bzrlib.tests.test_sampler',
4087
 
        'bzrlib.tests.test_scenarios',
4088
 
        'bzrlib.tests.test_script',
4089
 
        'bzrlib.tests.test_selftest',
4090
 
        'bzrlib.tests.test_serializer',
4091
 
        'bzrlib.tests.test_setup',
4092
 
        'bzrlib.tests.test_sftp_transport',
4093
 
        'bzrlib.tests.test_shelf',
4094
 
        'bzrlib.tests.test_shelf_ui',
4095
 
        'bzrlib.tests.test_smart',
4096
 
        'bzrlib.tests.test_smart_add',
4097
 
        'bzrlib.tests.test_smart_request',
4098
 
        'bzrlib.tests.test_smart_signals',
4099
 
        'bzrlib.tests.test_smart_transport',
4100
 
        'bzrlib.tests.test_smtp_connection',
4101
 
        'bzrlib.tests.test_source',
4102
 
        'bzrlib.tests.test_ssh_transport',
4103
 
        'bzrlib.tests.test_status',
4104
 
        'bzrlib.tests.test_store',
4105
 
        'bzrlib.tests.test_strace',
4106
 
        'bzrlib.tests.test_subsume',
4107
 
        'bzrlib.tests.test_switch',
4108
 
        'bzrlib.tests.test_symbol_versioning',
4109
 
        'bzrlib.tests.test_tag',
4110
 
        'bzrlib.tests.test_test_server',
4111
 
        'bzrlib.tests.test_testament',
4112
 
        'bzrlib.tests.test_textfile',
4113
 
        'bzrlib.tests.test_textmerge',
4114
 
        'bzrlib.tests.test_cethread',
4115
 
        'bzrlib.tests.test_timestamp',
4116
 
        'bzrlib.tests.test_trace',
4117
 
        'bzrlib.tests.test_transactions',
4118
 
        'bzrlib.tests.test_transform',
4119
 
        'bzrlib.tests.test_transport',
4120
 
        'bzrlib.tests.test_transport_log',
4121
 
        'bzrlib.tests.test_tree',
4122
 
        'bzrlib.tests.test_treebuilder',
4123
 
        'bzrlib.tests.test_treeshape',
4124
 
        'bzrlib.tests.test_tsort',
4125
 
        'bzrlib.tests.test_tuned_gzip',
4126
 
        'bzrlib.tests.test_ui',
4127
 
        'bzrlib.tests.test_uncommit',
4128
 
        'bzrlib.tests.test_upgrade',
4129
 
        'bzrlib.tests.test_upgrade_stacked',
4130
 
        'bzrlib.tests.test_urlutils',
4131
 
        'bzrlib.tests.test_utextwrap',
4132
 
        'bzrlib.tests.test_version',
4133
 
        'bzrlib.tests.test_version_info',
4134
 
        'bzrlib.tests.test_versionedfile',
4135
 
        'bzrlib.tests.test_vf_search',
4136
 
        'bzrlib.tests.test_weave',
4137
 
        'bzrlib.tests.test_whitebox',
4138
 
        'bzrlib.tests.test_win32utils',
4139
 
        'bzrlib.tests.test_workingtree',
4140
 
        'bzrlib.tests.test_workingtree_4',
4141
 
        'bzrlib.tests.test_wsgi',
4142
 
        'bzrlib.tests.test_xml',
 
3883
        'breezy.doc',
 
3884
        'breezy.tests.blackbox',
 
3885
        'breezy.tests.commands',
 
3886
        'breezy.tests.per_branch',
 
3887
        'breezy.tests.per_bzrdir',
 
3888
        'breezy.tests.per_controldir',
 
3889
        'breezy.tests.per_controldir_colo',
 
3890
        'breezy.tests.per_foreign_vcs',
 
3891
        'breezy.tests.per_interrepository',
 
3892
        'breezy.tests.per_intertree',
 
3893
        'breezy.tests.per_inventory',
 
3894
        'breezy.tests.per_interbranch',
 
3895
        'breezy.tests.per_lock',
 
3896
        'breezy.tests.per_merger',
 
3897
        'breezy.tests.per_transport',
 
3898
        'breezy.tests.per_tree',
 
3899
        'breezy.tests.per_pack_repository',
 
3900
        'breezy.tests.per_repository',
 
3901
        'breezy.tests.per_repository_chk',
 
3902
        'breezy.tests.per_repository_reference',
 
3903
        'breezy.tests.per_repository_vf',
 
3904
        'breezy.tests.per_uifactory',
 
3905
        'breezy.tests.per_versionedfile',
 
3906
        'breezy.tests.per_workingtree',
 
3907
        'breezy.tests.test__annotator',
 
3908
        'breezy.tests.test__bencode',
 
3909
        'breezy.tests.test__btree_serializer',
 
3910
        'breezy.tests.test__chk_map',
 
3911
        'breezy.tests.test__dirstate_helpers',
 
3912
        'breezy.tests.test__groupcompress',
 
3913
        'breezy.tests.test__known_graph',
 
3914
        'breezy.tests.test__rio',
 
3915
        'breezy.tests.test__simple_set',
 
3916
        'breezy.tests.test__static_tuple',
 
3917
        'breezy.tests.test__walkdirs_win32',
 
3918
        'breezy.tests.test_ancestry',
 
3919
        'breezy.tests.test_annotate',
 
3920
        'breezy.tests.test_api',
 
3921
        'breezy.tests.test_atomicfile',
 
3922
        'breezy.tests.test_bad_files',
 
3923
        'breezy.tests.test_bisect_multi',
 
3924
        'breezy.tests.test_branch',
 
3925
        'breezy.tests.test_branchbuilder',
 
3926
        'breezy.tests.test_btree_index',
 
3927
        'breezy.tests.test_bugtracker',
 
3928
        'breezy.tests.test_bundle',
 
3929
        'breezy.tests.test_bzrdir',
 
3930
        'breezy.tests.test__chunks_to_lines',
 
3931
        'breezy.tests.test_cache_utf8',
 
3932
        'breezy.tests.test_chk_map',
 
3933
        'breezy.tests.test_chk_serializer',
 
3934
        'breezy.tests.test_chunk_writer',
 
3935
        'breezy.tests.test_clean_tree',
 
3936
        'breezy.tests.test_cleanup',
 
3937
        'breezy.tests.test_cmdline',
 
3938
        'breezy.tests.test_commands',
 
3939
        'breezy.tests.test_commit',
 
3940
        'breezy.tests.test_commit_merge',
 
3941
        'breezy.tests.test_config',
 
3942
        'breezy.tests.test_conflicts',
 
3943
        'breezy.tests.test_controldir',
 
3944
        'breezy.tests.test_counted_lock',
 
3945
        'breezy.tests.test_crash',
 
3946
        'breezy.tests.test_decorators',
 
3947
        'breezy.tests.test_delta',
 
3948
        'breezy.tests.test_debug',
 
3949
        'breezy.tests.test_diff',
 
3950
        'breezy.tests.test_directory_service',
 
3951
        'breezy.tests.test_dirstate',
 
3952
        'breezy.tests.test_email_message',
 
3953
        'breezy.tests.test_eol_filters',
 
3954
        'breezy.tests.test_errors',
 
3955
        'breezy.tests.test_estimate_compressed_size',
 
3956
        'breezy.tests.test_export',
 
3957
        'breezy.tests.test_export_pot',
 
3958
        'breezy.tests.test_extract',
 
3959
        'breezy.tests.test_features',
 
3960
        'breezy.tests.test_fetch',
 
3961
        'breezy.tests.test_fixtures',
 
3962
        'breezy.tests.test_fifo_cache',
 
3963
        'breezy.tests.test_filters',
 
3964
        'breezy.tests.test_filter_tree',
 
3965
        'breezy.tests.test_ftp_transport',
 
3966
        'breezy.tests.test_foreign',
 
3967
        'breezy.tests.test_generate_docs',
 
3968
        'breezy.tests.test_generate_ids',
 
3969
        'breezy.tests.test_globbing',
 
3970
        'breezy.tests.test_gpg',
 
3971
        'breezy.tests.test_graph',
 
3972
        'breezy.tests.test_groupcompress',
 
3973
        'breezy.tests.test_hashcache',
 
3974
        'breezy.tests.test_help',
 
3975
        'breezy.tests.test_hooks',
 
3976
        'breezy.tests.test_http',
 
3977
        'breezy.tests.test_http_response',
 
3978
        'breezy.tests.test_https_ca_bundle',
 
3979
        'breezy.tests.test_https_urllib',
 
3980
        'breezy.tests.test_i18n',
 
3981
        'breezy.tests.test_identitymap',
 
3982
        'breezy.tests.test_ignores',
 
3983
        'breezy.tests.test_index',
 
3984
        'breezy.tests.test_import_tariff',
 
3985
        'breezy.tests.test_info',
 
3986
        'breezy.tests.test_inv',
 
3987
        'breezy.tests.test_inventory_delta',
 
3988
        'breezy.tests.test_knit',
 
3989
        'breezy.tests.test_lazy_import',
 
3990
        'breezy.tests.test_lazy_regex',
 
3991
        'breezy.tests.test_library_state',
 
3992
        'breezy.tests.test_lock',
 
3993
        'breezy.tests.test_lockable_files',
 
3994
        'breezy.tests.test_lockdir',
 
3995
        'breezy.tests.test_log',
 
3996
        'breezy.tests.test_lru_cache',
 
3997
        'breezy.tests.test_lsprof',
 
3998
        'breezy.tests.test_mail_client',
 
3999
        'breezy.tests.test_matchers',
 
4000
        'breezy.tests.test_memorytree',
 
4001
        'breezy.tests.test_merge',
 
4002
        'breezy.tests.test_merge3',
 
4003
        'breezy.tests.test_merge_core',
 
4004
        'breezy.tests.test_merge_directive',
 
4005
        'breezy.tests.test_mergetools',
 
4006
        'breezy.tests.test_missing',
 
4007
        'breezy.tests.test_msgeditor',
 
4008
        'breezy.tests.test_multiparent',
 
4009
        'breezy.tests.test_mutabletree',
 
4010
        'breezy.tests.test_nonascii',
 
4011
        'breezy.tests.test_options',
 
4012
        'breezy.tests.test_osutils',
 
4013
        'breezy.tests.test_osutils_encodings',
 
4014
        'breezy.tests.test_pack',
 
4015
        'breezy.tests.test_patch',
 
4016
        'breezy.tests.test_patches',
 
4017
        'breezy.tests.test_permissions',
 
4018
        'breezy.tests.test_plugins',
 
4019
        'breezy.tests.test_progress',
 
4020
        'breezy.tests.test_pyutils',
 
4021
        'breezy.tests.test_read_bundle',
 
4022
        'breezy.tests.test_reconcile',
 
4023
        'breezy.tests.test_reconfigure',
 
4024
        'breezy.tests.test_registry',
 
4025
        'breezy.tests.test_remote',
 
4026
        'breezy.tests.test_rename_map',
 
4027
        'breezy.tests.test_repository',
 
4028
        'breezy.tests.test_revert',
 
4029
        'breezy.tests.test_revision',
 
4030
        'breezy.tests.test_revisionspec',
 
4031
        'breezy.tests.test_revisiontree',
 
4032
        'breezy.tests.test_rio',
 
4033
        'breezy.tests.test_rules',
 
4034
        'breezy.tests.test_url_policy_open',
 
4035
        'breezy.tests.test_sampler',
 
4036
        'breezy.tests.test_scenarios',
 
4037
        'breezy.tests.test_script',
 
4038
        'breezy.tests.test_selftest',
 
4039
        'breezy.tests.test_serializer',
 
4040
        'breezy.tests.test_setup',
 
4041
        'breezy.tests.test_sftp_transport',
 
4042
        'breezy.tests.test_shelf',
 
4043
        'breezy.tests.test_shelf_ui',
 
4044
        'breezy.tests.test_smart',
 
4045
        'breezy.tests.test_smart_add',
 
4046
        'breezy.tests.test_smart_request',
 
4047
        'breezy.tests.test_smart_signals',
 
4048
        'breezy.tests.test_smart_transport',
 
4049
        'breezy.tests.test_smtp_connection',
 
4050
        'breezy.tests.test_source',
 
4051
        'breezy.tests.test_ssh_transport',
 
4052
        'breezy.tests.test_status',
 
4053
        'breezy.tests.test_store',
 
4054
        'breezy.tests.test_strace',
 
4055
        'breezy.tests.test_subsume',
 
4056
        'breezy.tests.test_switch',
 
4057
        'breezy.tests.test_symbol_versioning',
 
4058
        'breezy.tests.test_tag',
 
4059
        'breezy.tests.test_test_server',
 
4060
        'breezy.tests.test_testament',
 
4061
        'breezy.tests.test_textfile',
 
4062
        'breezy.tests.test_textmerge',
 
4063
        'breezy.tests.test_cethread',
 
4064
        'breezy.tests.test_timestamp',
 
4065
        'breezy.tests.test_trace',
 
4066
        'breezy.tests.test_transactions',
 
4067
        'breezy.tests.test_transform',
 
4068
        'breezy.tests.test_transport',
 
4069
        'breezy.tests.test_transport_log',
 
4070
        'breezy.tests.test_tree',
 
4071
        'breezy.tests.test_treebuilder',
 
4072
        'breezy.tests.test_treeshape',
 
4073
        'breezy.tests.test_tsort',
 
4074
        'breezy.tests.test_tuned_gzip',
 
4075
        'breezy.tests.test_ui',
 
4076
        'breezy.tests.test_uncommit',
 
4077
        'breezy.tests.test_upgrade',
 
4078
        'breezy.tests.test_upgrade_stacked',
 
4079
        'breezy.tests.test_urlutils',
 
4080
        'breezy.tests.test_utextwrap',
 
4081
        'breezy.tests.test_version',
 
4082
        'breezy.tests.test_version_info',
 
4083
        'breezy.tests.test_versionedfile',
 
4084
        'breezy.tests.test_vf_search',
 
4085
        'breezy.tests.test_weave',
 
4086
        'breezy.tests.test_whitebox',
 
4087
        'breezy.tests.test_win32utils',
 
4088
        'breezy.tests.test_workingtree',
 
4089
        'breezy.tests.test_workingtree_4',
 
4090
        'breezy.tests.test_wsgi',
 
4091
        'breezy.tests.test_xml',
4143
4092
        ]
4144
4093
 
4145
4094
 
4149
4098
        # GZ 2009-03-31: No docstrings with -OO so there's nothing to doctest
4150
4099
        return []
4151
4100
    return [
4152
 
        'bzrlib',
4153
 
        'bzrlib.branchbuilder',
4154
 
        'bzrlib.decorators',
4155
 
        'bzrlib.inventory',
4156
 
        'bzrlib.iterablefile',
4157
 
        'bzrlib.lockdir',
4158
 
        'bzrlib.merge3',
4159
 
        'bzrlib.option',
4160
 
        'bzrlib.pyutils',
4161
 
        'bzrlib.symbol_versioning',
4162
 
        'bzrlib.tests',
4163
 
        'bzrlib.tests.fixtures',
4164
 
        'bzrlib.timestamp',
4165
 
        'bzrlib.transport.http',
4166
 
        'bzrlib.version_info_formats.format_custom',
 
4101
        'breezy',
 
4102
        'breezy.branchbuilder',
 
4103
        'breezy.decorators',
 
4104
        'breezy.inventory',
 
4105
        'breezy.iterablefile',
 
4106
        'breezy.lockdir',
 
4107
        'breezy.merge3',
 
4108
        'breezy.option',
 
4109
        'breezy.pyutils',
 
4110
        'breezy.symbol_versioning',
 
4111
        'breezy.tests',
 
4112
        'breezy.tests.fixtures',
 
4113
        'breezy.timestamp',
 
4114
        'breezy.transport.http',
 
4115
        'breezy.version_info_formats.format_custom',
4167
4116
        ]
4168
4117
 
4169
4118
 
4170
4119
def test_suite(keep_only=None, starting_with=None):
4171
 
    """Build and return TestSuite for the whole of bzrlib.
 
4120
    """Build and return TestSuite for the whole of breezy.
4172
4121
 
4173
4122
    :param keep_only: A list of test ids limiting the suite returned.
4174
4123
 
4223
4172
            # still runs the rest of the examples
4224
4173
            doc_suite = IsolatedDocTestSuite(
4225
4174
                mod, optionflags=doctest.REPORT_ONLY_FIRST_FAILURE)
4226
 
        except ValueError, e:
4227
 
            print '**failed to get doctest for: %s\n%s' % (mod, e)
 
4175
        except ValueError as e:
 
4176
            print('**failed to get doctest for: %s\n%s' % (mod, e))
4228
4177
            raise
4229
4178
        if len(doc_suite._tests) == 0:
4230
4179
            raise errors.BzrError("no doctests found in %s" % (mod,))
4315
4264
    the scenario name at the end of its id(), and updating the test object's
4316
4265
    __dict__ with the scenario_param_dict.
4317
4266
 
4318
 
    >>> import bzrlib.tests.test_sampler
 
4267
    >>> import breezy.tests.test_sampler
4319
4268
    >>> r = multiply_tests(
4320
 
    ...     bzrlib.tests.test_sampler.DemoTest('test_nothing'),
 
4269
    ...     breezy.tests.test_sampler.DemoTest('test_nothing'),
4321
4270
    ...     [('one', dict(param=1)),
4322
4271
    ...      ('two', dict(param=2))],
4323
4272
    ...     TestUtil.TestSuite())
4325
4274
    >>> len(tests)
4326
4275
    2
4327
4276
    >>> tests[0].id()
4328
 
    'bzrlib.tests.test_sampler.DemoTest.test_nothing(one)'
 
4277
    'breezy.tests.test_sampler.DemoTest.test_nothing(one)'
4329
4278
    >>> tests[0].param
4330
4279
    1
4331
4280
    >>> tests[1].param
4397
4346
    This is meant to be used inside a modules 'load_tests()' function. It will
4398
4347
    create 2 scenarios, and cause all tests in the 'standard_tests' to be run
4399
4348
    against both implementations. Setting 'test.module' to the appropriate
4400
 
    module. See bzrlib.tests.test__chk_map.load_tests as an example.
 
4349
    module. See breezy.tests.test__chk_map.load_tests as an example.
4401
4350
 
4402
4351
    :param standard_tests: A test suite to permute
4403
4352
    :param loader: A TestLoader
4404
4353
    :param py_module_name: The python path to a python module that can always
4405
4354
        be loaded, and will be considered the 'python' implementation. (eg
4406
 
        'bzrlib._chk_map_py')
 
4355
        'breezy._chk_map_py')
4407
4356
    :param ext_module_name: The python path to an extension module. If the
4408
4357
        module cannot be loaded, a single test will be added, which notes that
4409
4358
        the module is not available. If it can be loaded, all standard_tests
4413
4362
        the module is available.
4414
4363
    """
4415
4364
 
4416
 
    from bzrlib.tests.features import ModuleAvailableFeature
 
4365
    from .features import ModuleAvailableFeature
4417
4366
    py_module = pyutils.get_named_object(py_module_name)
4418
4367
    scenarios = [
4419
4368
        ('python', {'module': py_module}),
4441
4390
    # (they are either ascii or mbcs)
4442
4391
    if sys.platform == 'win32':
4443
4392
        # make sure we are using the unicode win32 api
4444
 
        dirname = unicode(dirname)
 
4393
        dirname = text_type(dirname)
4445
4394
    else:
4446
4395
        dirname = dirname.encode(sys.getfilesystemencoding())
4447
4396
    try:
4448
4397
        osutils.rmtree(dirname)
4449
 
    except OSError, e:
 
4398
    except OSError as e:
4450
4399
        # We don't want to fail here because some useful display will be lost
4451
4400
        # otherwise. Polluting the tmp dir is bad, but not giving all the
4452
4401
        # possible info to the test runner is even worse.
4535
4484
    ]:
4536
4485
    globals()[name] = _CompatabilityThunkFeature(
4537
4486
        symbol_versioning.deprecated_in((2, 5, 0)),
4538
 
        'bzrlib.tests', name,
4539
 
        name, 'bzrlib.tests.features')
 
4487
        'breezy.tests', name,
 
4488
        name, 'breezy.tests.features')
4540
4489
 
4541
4490
 
4542
4491
for (old_name, new_name) in [
4544
4493
    ]:
4545
4494
    globals()[name] = _CompatabilityThunkFeature(
4546
4495
        symbol_versioning.deprecated_in((2, 5, 0)),
4547
 
        'bzrlib.tests', old_name,
4548
 
        new_name, 'bzrlib.tests.features')
 
4496
        'breezy.tests', old_name,
 
4497
        new_name, 'breezy.tests.features')