Merge lp:~jelmer/brz/run-brz-bytes into lp:brz

[Jelmer Vernooij]

Add run_bzr_raw

=== modified file 'breezy/builtins.py'
--- breezy/builtins.py	2018-08-04 17:32:58 +0000
+++ breezy/builtins.py	2018-08-14 20:37:51 +0000
@@ -6074,6 +6074,8 @@
                     # which are not in this branch. Fail gracefully ...
                     revno = '?'
                 tags[index] = (tag, revno)
+        else:
+            tags = [(tag, revid.decode('utf-8')) for (tag, revid) in tags]
         self.cleanup_now()
         for tag, revspec in tags:
             self.outf.write('%-20s %s\n' % (tag, revspec))

=== modified file 'breezy/cache_utf8.py'
--- breezy/cache_utf8.py	2011-12-19 13:23:58 +0000
+++ breezy/cache_utf8.py	2018-08-14 20:37:51 +0000
@@ -109,7 +109,7 @@
     # same hash, so we can just use it as the key in _uni_to_utf8, but we need
     # the return value to be different in _utf8_to_uni
     ascii_str = _uni_to_utf8.setdefault(ascii_str, ascii_str)
-    _utf8_to_uni.setdefault(ascii_str, unicode(ascii_str))
+    _utf8_to_uni.setdefault(ascii_str, ascii_str.decode('ascii'))
     return ascii_str
 
 

=== modified file 'breezy/osutils.py'
--- breezy/osutils.py	2018-07-24 22:51:28 +0000
+++ breezy/osutils.py	2018-08-14 20:37:51 +0000
@@ -1992,7 +1992,7 @@
     """Compare path_a and path_b to generate the same order walkdirs uses."""
     key_a = path_prefix_key(path_a)
     key_b = path_prefix_key(path_b)
-    return cmp(key_a, key_b)
+    return (key_a > key_b) - (key_a < key_b)
 
 
 _cached_user_encoding = None

=== modified file 'breezy/plugins/grep/test_grep.py'
--- breezy/plugins/grep/test_grep.py	2018-07-22 17:06:14 +0000
+++ breezy/plugins/grep/test_grep.py	2018-08-14 20:37:51 +0000
@@ -1943,28 +1943,27 @@
 
         # GZ 2010-06-07: Note we can't actually grep for \u1234 as the pattern
         #                is mangled according to the user encoding.
-        streams = self.run_bzr(["grep", "--files-with-matches",
+        streams = self.run_bzr_raw(["grep", "--files-with-matches",
             u"contents"], encoding="UTF-8")
-        if not PY3:
-            as_utf8 = as_utf8.encode("UTF-8")
-        self.assertEqual(streams, (as_utf8 + "\n", ""))
+        as_utf8 = as_utf8.encode("UTF-8")
+        self.assertEqual(streams, (as_utf8 + b"\n", b""))
 
-        streams = self.run_bzr(["grep", "-r", "1", "--files-with-matches",
+        streams = self.run_bzr_raw(["grep", "-r", "1", "--files-with-matches",
             u"contents"], encoding="UTF-8")
-        self.assertEqual(streams, (as_utf8 + "~1\n", ""))
+        self.assertEqual(streams, (as_utf8 + b"~1\n", b""))
 
         fileencoding = osutils.get_user_encoding()
         as_mangled = as_utf8.decode(fileencoding, "replace").encode("UTF-8")
 
-        streams = self.run_bzr(["grep", "-n",
+        streams = self.run_bzr_raw(["grep", "-n",
             u"contents"], encoding="UTF-8")
-        self.assertEqual(streams, ("%s:1:contents of %s\n" %
-            (as_utf8, as_mangled), ""))
+        self.assertEqual(streams, (b"%s:1:contents of %s\n" %
+            (as_utf8, as_mangled), b""))
 
-        streams = self.run_bzr(["grep", "-n", "-r", "1",
+        streams = self.run_bzr_raw(["grep", "-n", "-r", "1",
             u"contents"], encoding="UTF-8")
-        self.assertEqual(streams, ("%s~1:1:contents of %s\n" %
-            (as_utf8, as_mangled), ""))
+        self.assertEqual(streams, (b"%s~1:1:contents of %s\n" %
+            (as_utf8, as_mangled), b""))
 
 
 class TestColorGrep(GrepTestBase):

=== modified file 'breezy/tests/__init__.py'
--- breezy/tests/__init__.py	2018-08-08 02:14:32 +0000
+++ breezy/tests/__init__.py	2018-08-14 20:37:51 +0000
@@ -33,6 +33,7 @@
 from io import (
     BytesIO,
     StringIO,
+    TextIOWrapper,
     )
 import itertools
 import logging
@@ -1916,42 +1917,20 @@
         if not feature.available():
             raise UnavailableFeature(feature)
 
-    def _run_bzr_autosplit(self, args, retcode, encoding, stdin,
-            working_dir):
-        """Run bazaar command line, splitting up a string command line."""
-        if isinstance(args, string_types):
-            args = shlex.split(args)
-        return self._run_bzr_core(args, retcode=retcode,
-                encoding=encoding, stdin=stdin, working_dir=working_dir,
-                )
-
-    def _run_bzr_core(self, args, retcode, encoding, stdin,
+    def _run_bzr_core(self, args, encoding, stdin, stdout, stderr,
             working_dir):
         # Clear chk_map page cache, because the contents are likely to mask
         # locking errors.
         chk_map.clear_cache()
-        if encoding is None:
-            encoding = osutils.get_user_encoding()
 
         self.log('run brz: %r', args)
 
-        if sys.version_info[0] == 2:
-            stdout = ui_testing.BytesIOWithEncoding()
-            stderr = ui_testing.BytesIOWithEncoding()
-            stdout.encoding = stderr.encoding = encoding
+        if PY3:
+            self._last_cmd_stdout = stdout
+            self._last_cmd_stderr = stderr
         else:
-            stdout = ui_testing.StringIOWithEncoding()
-            stderr = ui_testing.StringIOWithEncoding()
-            stdout.encoding = stderr.encoding = encoding
-
-        # FIXME: don't call into logging here
-        handler = trace.EncodedStreamHandler(
-            stderr, errors="replace", level=logging.INFO)
-        logger = logging.getLogger('')
-        logger.addHandler(handler)
-
-        self._last_cmd_stdout = codecs.getwriter(encoding)(stdout)
-        self._last_cmd_stderr = codecs.getwriter(encoding)(stderr)
+            self._last_cmd_stdout = codecs.getwriter(encoding)(stdout)
+            self._last_cmd_stderr = codecs.getwriter(encoding)(stderr)
 
         old_ui_factory = ui.ui_factory
         ui.ui_factory = ui_testing.TestUIFactory(
@@ -1972,11 +1951,81 @@
                     _mod_commands.run_bzr_catch_user_errors,
                     args)
         finally:
-            logger.removeHandler(handler)
             ui.ui_factory = old_ui_factory
             if cwd is not None:
                 os.chdir(cwd)
 
+        return result
+
+    def run_bzr_raw(self, args, retcode=0, stdin=None, encoding=None,
+                working_dir=None, error_regexes=[]):
+        """Invoke brz, as if it were run from the command line.
+
+        The argument list should not include the brz program name - the
+        first argument is normally the brz command.  Arguments may be
+        passed in three ways:
+
+        1- A list of strings, eg ["commit", "a"].  This is recommended
+        when the command contains whitespace or metacharacters, or
+        is built up at run time.
+
+        2- A single string, eg "add a".  This is the most convenient
+        for hardcoded commands.
+
+        This runs brz through the interface that catches and reports
+        errors, and with logging set to something approximating the
+        default, so that error reporting can be checked.
+
+        This should be the main method for tests that want to exercise the
+        overall behavior of the brz application (rather than a unit test
+        or a functional test of the library.)
+
+        This sends the stdout/stderr results into the test's log,
+        where it may be useful for debugging.  See also run_captured.
+
+        :keyword stdin: A string to be used as stdin for the command.
+        :keyword retcode: The status code the command should return;
+            default 0.
+        :keyword working_dir: The directory to run the command in
+        :keyword error_regexes: A list of expected error messages.  If
+            specified they must be seen in the error output of the command.
+        """
+        if isinstance(args, string_types):
+            args = shlex.split(args)
+
+        if encoding is None:
+            encoding = osutils.get_user_encoding()
+
+        if sys.version_info[0] == 2:
+            wrapped_stdout = stdout = ui_testing.BytesIOWithEncoding()
+            wrapped_stderr = stderr = ui_testing.BytesIOWithEncoding()
+            stdout.encoding = stderr.encoding = encoding
+
+            # FIXME: don't call into logging here
+            handler = trace.EncodedStreamHandler(
+                stderr, errors="replace")
+        else:
+            stdout = BytesIO()
+            stderr = BytesIO()
+            wrapped_stdout = TextIOWrapper(stdout, encoding)
+            wrapped_stderr = TextIOWrapper(stderr, encoding)
+            handler = logging.StreamHandler(wrapped_stderr)
+        handler.setLevel(logging.INFO)
+
+        logger = logging.getLogger('')
+        logger.addHandler(handler)
+        try:
+            result = self._run_bzr_core(
+                    args, encoding=encoding, stdin=stdin, stdout=wrapped_stdout,
+                    stderr=wrapped_stderr, working_dir=working_dir,
+                    )
+        finally:
+            logger.removeHandler(handler)
+
+        if PY3:
+            wrapped_stdout.flush()
+            wrapped_stderr.flush()
+
         out = stdout.getvalue()
         err = stderr.getvalue()
         if out:
@@ -1986,7 +2035,10 @@
         if retcode is not None:
             self.assertEqual(retcode, result,
                               message='Unexpected return code')
-        return result, out, err
+        self.assertIsInstance(error_regexes, (list, tuple))
+        for regex in error_regexes:
+            self.assertContainsRe(err, regex)
+        return out, err
 
     def run_bzr(self, args, retcode=0, stdin=None, encoding=None,
                 working_dir=None, error_regexes=[]):
@@ -2021,13 +2073,46 @@
         :keyword error_regexes: A list of expected error messages.  If
             specified they must be seen in the error output of the command.
         """
-        retcode, out, err = self._run_bzr_autosplit(
-            args=args,
-            retcode=retcode,
-            encoding=encoding,
-            stdin=stdin,
-            working_dir=working_dir,
-            )
+        if isinstance(args, string_types):
+            args = shlex.split(args)
+
+        if encoding is None:
+            encoding = osutils.get_user_encoding()
+
+        if sys.version_info[0] == 2:
+            stdout = ui_testing.BytesIOWithEncoding()
+            stderr = ui_testing.BytesIOWithEncoding()
+            stdout.encoding = stderr.encoding = encoding
+            # FIXME: don't call into logging here
+            handler = trace.EncodedStreamHandler(
+                stderr, errors="replace")
+        else:
+            stdout = ui_testing.StringIOWithEncoding()
+            stderr = ui_testing.StringIOWithEncoding()
+            stdout.encoding = stderr.encoding = encoding
+            handler = logging.StreamHandler(stream=stderr)
+        handler.setLevel(logging.INFO)
+
+        logger = logging.getLogger('')
+        logger.addHandler(handler)
+
+        try:
+            result = self._run_bzr_core(args,
+                    encoding=encoding, stdin=stdin, stdout=stdout,
+                    stderr=stderr, working_dir=working_dir,
+                    )
+        finally:
+            logger.removeHandler(handler)
+
+        out = stdout.getvalue()
+        err = stderr.getvalue()
+        if out:
+            self.log('output:\n%r', out)
+        if err:
+            self.log('errors:\n%r', err)
+        if retcode is not None:
+            self.assertEqual(retcode, result,
+                              message='Unexpected return code')
         self.assertIsInstance(error_regexes, (list, tuple))
         for regex in error_regexes:
             self.assertContainsRe(err, regex)

=== modified file 'breezy/tests/blackbox/test_command_encoding.py'
--- breezy/tests/blackbox/test_command_encoding.py	2018-07-15 19:09:26 +0000
+++ breezy/tests/blackbox/test_command_encoding.py	2018-08-14 20:37:51 +0000
@@ -51,11 +51,11 @@
     def test_exact(self):
         def bzr(*args, **kwargs):
             kwargs['encoding'] = 'ascii'
-            return self.run_bzr(*args, **kwargs)[0]
+            return self.run_bzr_raw(*args, **kwargs)[0]
 
         register_command(cmd_echo_exact)
         try:
-            self.assertEqual('foo', bzr('echo-exact foo'))
+            self.assertEqual(b'foo', bzr('echo-exact foo'))
             # Exact should fail to decode the string
             self.assertRaises(UnicodeEncodeError,
                 bzr,
@@ -68,14 +68,13 @@
     def test_strict_utf8(self):
         def bzr(*args, **kwargs):
             kwargs['encoding'] = 'utf-8'
-            return self.run_bzr(*args, **kwargs)[0]
+            return self.run_bzr_raw(*args, **kwargs)[0]
 
         register_command(cmd_echo_strict)
         try:
-            self.assertEqual('foo', bzr('echo-strict foo'))
+            self.assertEqual(b'foo', bzr('echo-strict foo'))
             expected = u'foo\xb5'
-            if not PY3:
-                expected = expected.encode('utf-8')
+            expected = expected.encode('utf-8')
             self.assertEqual(expected,
                              bzr(['echo-strict', u'foo\xb5']))
         finally:
@@ -84,11 +83,11 @@
     def test_strict_ascii(self):
         def bzr(*args, **kwargs):
             kwargs['encoding'] = 'ascii'
-            return self.run_bzr(*args, **kwargs)[0]
+            return self.run_bzr_raw(*args, **kwargs)[0]
 
         register_command(cmd_echo_strict)
         try:
-            self.assertEqual('foo', bzr('echo-strict foo'))
+            self.assertEqual(b'foo', bzr('echo-strict foo'))
             # ascii can't encode \xb5
             self.assertRaises(UnicodeEncodeError,
                 bzr,
@@ -99,11 +98,11 @@
     def test_replace_utf8(self):
         def bzr(*args, **kwargs):
             kwargs['encoding'] = 'utf-8'
-            return self.run_bzr(*args, **kwargs)[0]
+            return self.run_bzr_raw(*args, **kwargs)[0]
 
         register_command(cmd_echo_replace)
         try:
-            self.assertEqual('foo', bzr('echo-replace foo'))
+            self.assertEqual(b'foo', bzr('echo-replace foo'))
             self.assertEqual(u'foo\xb5'.encode('utf-8'),
                              bzr(['echo-replace', u'foo\xb5']))
         finally:
@@ -112,13 +111,13 @@
     def test_replace_ascii(self):
         def bzr(*args, **kwargs):
             kwargs['encoding'] = 'ascii'
-            return self.run_bzr(*args, **kwargs)[0]
+            return self.run_bzr_raw(*args, **kwargs)[0]
 
         register_command(cmd_echo_replace)
         try:
-            self.assertEqual('foo', bzr('echo-replace foo'))
+            self.assertEqual(b'foo', bzr('echo-replace foo'))
             # ascii can't encode \xb5
-            self.assertEqual('foo?', bzr(['echo-replace', u'foo\xb5']))
+            self.assertEqual(b'foo?', bzr(['echo-replace', u'foo\xb5']))
         finally:
             plugin_cmds.remove('echo-replace')
 

=== modified file 'breezy/tests/blackbox/test_commit.py'
--- breezy/tests/blackbox/test_commit.py	2018-07-27 01:17:23 +0000
+++ breezy/tests/blackbox/test_commit.py	2018-08-14 20:37:51 +0000
@@ -176,20 +176,23 @@
         tree = self.make_branch_and_tree(".")
         self.build_tree(["f"])
         tree.add(["f"])
-        out, err = self.run_bzr(["commit", "-m", "Wrong filename", u"\xa7"],
+        out, err = self.run_bzr_raw(["commit", "-m", "Wrong filename", u"\xa7"],
             encoding="utf-8", retcode=3)
-        self.assertContainsRe(err, "(?m)not versioned: \"\xc2\xa7\"$")
+        self.assertContainsRe(err, b"(?m)not versioned: \"\xc2\xa7\"$")
 
     def test_non_ascii_file_unversioned_iso_8859_5(self):
         self.requireFeature(features.UnicodeFilenameFeature)
         tree = self.make_branch_and_tree(".")
         self.build_tree(["f"])
         tree.add(["f"])
-        out, err = self.run_bzr(["commit", "-m", "Wrong filename", u"\xa7"],
+        out, err = self.run_bzr_raw(["commit", "-m", "Wrong filename", u"\xa7"],
             encoding="iso-8859-5", retcode=3)
-        self.expectFailure("Error messages are always written as UTF-8",
-            self.assertNotContainsString, err, "\xc2\xa7")
-        self.assertContainsRe(err, "(?m)not versioned: \"\xfd\"$")
+        if not PY3:
+            self.expectFailure("Error messages are always written as UTF-8",
+                self.assertNotContainsString, err, b"\xc2\xa7")
+        else:
+            self.assertNotContainsString(err, b"\xc2\xa7")
+        self.assertContainsRe(err, b"(?m)not versioned: \"\xfd\"$")
 
     def test_warn_about_forgotten_commit_message(self):
         """Test that the lack of -m parameter is caught"""
@@ -541,13 +544,13 @@
         tree = self.make_branch_and_tree('tree')
         self.build_tree(['tree/hello.txt'])
         tree.add('hello.txt')
-        output, err = self.run_bzr(
+        output, err = self.run_bzr_raw(
             ['commit', '-m', 'hello',
              u'--fixes=generic:\u20ac', 'tree/hello.txt'],
             encoding='utf-8', retcode=3)
-        self.assertEqual('', output)
+        self.assertEqual(b'', output)
         self.assertContainsRe(err,
-            'brz: ERROR: Unrecognized bug generic:\xe2\x82\xac\\. Commit refused.\n')
+            b'brz: ERROR: Unrecognized bug generic:\xe2\x82\xac\\. Commit refused.\n')
 
     def test_no_bugs_no_properties(self):
         """If no bugs are fixed, the bugs property is not set.

=== modified file 'breezy/tests/blackbox/test_export.py'
--- breezy/tests/blackbox/test_export.py	2018-07-24 19:02:16 +0000
+++ breezy/tests/blackbox/test_export.py	2018-08-14 20:37:51 +0000
@@ -154,7 +154,7 @@
 
     def test_zip_export_stdout(self):
         tree = self.make_basic_tree()
-        contents = self.run_bzr('export -d tree --format=zip -')[0]
+        contents = self.run_bzr_raw('export -d tree --format=zip -')[0]
         self.assertZipANameAndContent(zipfile.ZipFile(BytesIO(contents)))
 
     def test_zip_export_file(self):
@@ -184,7 +184,7 @@
         mode = 'r|%s' % (tarfile_flags,)
         ball = tarfile.open(fname, mode=mode)
         self.assertTarANameAndContent(ball, root='test/')
-        content = self.run_bzr('export -d tree --format=%s -' % (extension,))[0]
+        content = self.run_bzr_raw('export -d tree --format=%s -' % (extension,))[0]
         ball = tarfile.open(mode=mode, fileobj=BytesIO(content))
         self.assertTarANameAndContent(ball, root='')
 

=== modified file 'breezy/tests/blackbox/test_help.py'
--- breezy/tests/blackbox/test_help.py	2018-07-15 18:45:17 +0000
+++ breezy/tests/blackbox/test_help.py	2018-08-14 20:37:51 +0000
@@ -187,17 +187,17 @@
         self.overrideAttr(i18n, '_translations', ZzzTranslations())
 
     def test_help_command_utf8(self):
-        out, err = self.run_bzr(["help", "push"], encoding="utf-8")
+        out, err = self.run_bzr_raw(["help", "push"], encoding="utf-8")
         self.assertContainsRe(out, b"zz\xc3\xa5{{:See also:")
 
     def test_help_switch_utf8(self):
-        out, err = self.run_bzr(["push", "--help"], encoding="utf-8")
+        out, err = self.run_bzr_raw(["push", "--help"], encoding="utf-8")
         self.assertContainsRe(out, b"zz\xc3\xa5{{:See also:")
 
     def test_help_command_ascii(self):
-        out, err = self.run_bzr(["help", "push"], encoding="ascii")
+        out, err = self.run_bzr_raw(["help", "push"], encoding="ascii")
         self.assertContainsRe(out, b"zz\\?{{:See also:")
 
     def test_help_switch_ascii(self):
-        out, err = self.run_bzr(["push", "--help"], encoding="ascii")
+        out, err = self.run_bzr_raw(["push", "--help"], encoding="ascii")
         self.assertContainsRe(out, b"zz\\?{{:See also:")

=== modified file 'breezy/tests/blackbox/test_log.py'
--- breezy/tests/blackbox/test_log.py	2018-07-27 01:17:23 +0000
+++ breezy/tests/blackbox/test_log.py	2018-08-14 20:37:51 +0000
@@ -814,7 +814,7 @@
         self.build_tree(['a'])
         brz('add a')
         brz(['commit', '-m', u'\u0422\u0435\u0441\u0442'])
-        stdout, stderr = self.run_bzr('log', encoding='cp866')
+        stdout, stderr = self.run_bzr_raw('log', encoding='cp866')
 
         message = stdout.splitlines()[-1]
 
@@ -824,8 +824,8 @@
         # in cp1251 encoding this is string '\xd2\xe5\xf1\xf2'
         # This test should check that output of log command
         # encoded to sys.stdout.encoding
-        test_in_cp866 = '\x92\xa5\xe1\xe2'
-        test_in_cp1251 = '\xd2\xe5\xf1\xf2'
+        test_in_cp866 = b'\x92\xa5\xe1\xe2'
+        test_in_cp1251 = b'\xd2\xe5\xf1\xf2'
         # Make sure the log string is encoded in cp866
         self.assertEqual(test_in_cp866, message[2:])
         # Make sure the cp1251 string is not found anywhere

=== modified file 'breezy/tests/blackbox/test_non_ascii.py'
--- breezy/tests/blackbox/test_non_ascii.py	2018-07-17 21:20:55 +0000
+++ breezy/tests/blackbox/test_non_ascii.py	2018-08-14 20:37:51 +0000
@@ -61,12 +61,9 @@
         if encoding is None:
             encoding = osutils.get_user_encoding()
         try:
-            out = self.run_bzr(args, encoding=encoding,
+            out = self.run_bzr_raw(args, encoding=encoding,
                                retcode=retcode, working_dir=working_dir)[0]
-            if PY3:
-                return out.encode(encoding, 'replace').decode(encoding)
-            else:
-                return out.decode(encoding)
+            return out.decode(encoding)
         except UnicodeError as e:
             if not fail:
                 raise
@@ -157,12 +154,12 @@
     def test_cat(self):
         # brz cat shouldn't change the contents
         # using run_brz since that doesn't decode
-        txt = self.run_bzr('cat b')[0]
-        self.assertEqual('non-ascii \xFF\xFF\xFC\xFB\x00 in b\n', txt)
+        txt = self.run_bzr_raw('cat b')[0]
+        self.assertEqual(b'non-ascii \xFF\xFF\xFC\xFB\x00 in b\n', txt)
 
         self._check_OSX_can_roundtrip(self.info['filename'])
-        txt = self.run_bzr(['cat', self.info['filename']])[0]
-        self.assertEqual('unicode filename\n', txt)
+        txt = self.run_bzr_raw(['cat', self.info['filename']])[0]
+        self.assertEqual(b'unicode filename\n', txt)
 
     def test_cat_revision(self):
         committer = self.info['committer']
@@ -179,8 +176,8 @@
         self.assertEqual(u'added %s\n' % self.info['directory'], txt)
 
         # The text should be garbled, but the command should succeed
-        txt = self.run_bzr_decode(['mkdir', self.info['directory'] + '2'],
-                                  encoding='ascii')
+        txt = self.run_bzr_raw(['mkdir', self.info['directory'] + '2'],
+                               encoding='ascii')[0]
         expected = u'added %s2\n' % (self.info['directory'],)
         expected = expected.encode('ascii', 'replace')
         self.assertEqual(expected, txt)
@@ -245,9 +242,9 @@
 
         # The rename should still succeed
         newpath = u'%s/%s' % (dirname, fname2)
-        txt = self.run_bzr_decode(['mv', newpath, 'a'], encoding='ascii')
+        txt = self.run_bzr_raw(['mv', newpath, 'a'], encoding='ascii')[0]
         self.assertPathExists('a')
-        self.assertEqual(newpath.encode('ascii', 'replace') + ' => a\n', txt)
+        self.assertEqual(newpath.encode('ascii', 'replace') + b' => a\n', txt)
 
     def test_branch(self):
         # We should be able to branch into a directory that
@@ -445,8 +442,7 @@
         self.assertNotEqual(-1, txt.find(fname))
 
         # Make sure log doesn't fail even if we can't write out
-        txt = self.run_bzr_decode('log --verbose', encoding='ascii')
-        self.assertEqual(-1, txt.find(fname))
+        txt = self.run_bzr_raw('log --verbose', encoding='ascii')[0]
         self.assertNotEqual(-1, txt.find(fname.encode('ascii', 'replace')))
 
     def test_touching_revisions(self):
@@ -536,8 +532,8 @@
         self.assertNotEqual(-1, txt.find(msg))
 
         # Make sure missing doesn't fail even if we can't write out
-        txt = self.run_bzr_decode('missing empty-tree', encoding='ascii')
-        self.assertEqual(-1, txt.find(msg))
+        txt = self.run_bzr_raw('missing empty-tree', encoding='ascii',
+                               retcode=1)[0]
         self.assertNotEqual(-1, txt.find(msg.encode('ascii', 'replace')))
 
     def test_info(self):

=== modified file 'breezy/tests/blackbox/test_shelve.py'
--- breezy/tests/blackbox/test_shelve.py	2018-07-22 17:06:14 +0000
+++ breezy/tests/blackbox/test_shelve.py	2018-08-14 20:37:51 +0000
@@ -103,6 +103,7 @@
 contents of file
 ''')
 
+
 class TestUnshelvePreview(TestCaseWithTransport):
 
     def test_non_ascii(self):
@@ -111,7 +112,7 @@
         init_content = u'Initial: \u0418\u0437\u043d\u0430\u0447\n'.encode('utf-8')
         more_content = u'More: \u0415\u0449\u0451\n'.encode('utf-8')
         next_content = init_content + more_content
-        diff_part = '@@ -1,1 +1,2 @@\n %s+%s' % (init_content, more_content)
+        diff_part = b'@@ -1,1 +1,2 @@\n %s+%s' % (init_content, more_content)
 
         tree = self.make_branch_and_tree('.')
         self.build_tree_contents([('a_file', init_content)])
@@ -119,7 +120,7 @@
         tree.commit(message='committed')
         self.build_tree_contents([('a_file', next_content)])
         self.run_bzr(['shelve', '--all'])
-        out, err = self.run_bzr(['unshelve', '--preview'], encoding='latin-1')
+        out, err = self.run_bzr_raw(['unshelve', '--preview'], encoding='latin-1')
 
         self.assertContainsString(out, diff_part)
 

=== modified file 'breezy/tests/blackbox/test_tags.py'
--- breezy/tests/blackbox/test_tags.py	2018-07-13 00:16:39 +0000
+++ breezy/tests/blackbox/test_tags.py	2018-08-14 20:37:51 +0000
@@ -42,7 +42,7 @@
     def test_cannot_tag_range(self):
         out, err = self.run_bzr('tag -r1..10 name', retcode=3)
         self.assertContainsRe(err,
-            b"Tags can only be placed on a single revision")
+            "Tags can only be placed on a single revision")
 
     def test_no_tag_name(self):
         out, err = self.run_bzr('tag -d branch', retcode=3)
@@ -220,35 +220,34 @@
         b1.tags.set_tag(u'tag2\u30d0', b'revid-1')
 
         # natural order
-        out, err = self.run_bzr('tags -d branch1',
-                                encoding='utf-8')
-        self.assertEqual(err, '')
+        out, err = self.run_bzr_raw('tags -d branch1', encoding='utf-8')
+        self.assertEqual(err, b'')
         self.assertContainsRe(out, (u'^tag1\u30d0  *2\ntag2\u30d0  *1\n' +
             u'tag10\u30d0 *\\?\n').encode('utf-8'))
 
         # lexicographical order
-        out, err = self.run_bzr('tags --sort=alpha -d branch1',
-                                encoding='utf-8')
-        self.assertEqual(err, '')
+        out, err = self.run_bzr_raw('tags --sort=alpha -d branch1',
+                                    encoding='utf-8')
+        self.assertEqual(err, b'')
         self.assertContainsRe(out, (u'^tag10\u30d0  *\\?\ntag1\u30d0  *2\n' +
             u'tag2\u30d0 *1\n').encode('utf-8'))
 
-        out, err = self.run_bzr('tags --sort=alpha --show-ids -d branch1',
+        out, err = self.run_bzr_raw('tags --sort=alpha --show-ids -d branch1',
                                 encoding='utf-8')
-        self.assertEqual(err, '')
+        self.assertEqual(err, b'')
         self.assertContainsRe(out, (u'^tag10\u30d0  *missing\n' +
             u'tag1\u30d0  *revid-2\ntag2\u30d0 *revid-1\n').encode('utf-8'))
 
         # chronological order
-        out, err = self.run_bzr('tags --sort=time -d branch1',
+        out, err = self.run_bzr_raw('tags --sort=time -d branch1',
                 encoding='utf-8')
-        self.assertEqual(err, '')
+        self.assertEqual(err, b'')
         self.assertContainsRe(out, (u'^tag2\u30d0  *1\ntag1\u30d0  *2\n' +
             u'tag10\u30d0 *\\?\n').encode('utf-8'))
 
-        out, err = self.run_bzr('tags --sort=time --show-ids -d branch1',
+        out, err = self.run_bzr_raw('tags --sort=time --show-ids -d branch1',
                 encoding='utf-8')
-        self.assertEqual(err, '')
+        self.assertEqual(err, b'')
         self.assertContainsRe(out, (u'^tag2\u30d0  *revid-1\n' +
             u'tag1\u30d0  *revid-2\ntag10\u30d0 *missing\n').encode('utf-8'))
 

=== modified file 'breezy/tests/blackbox/test_version.py'
--- breezy/tests/blackbox/test_version.py	2018-07-27 01:17:23 +0000
+++ breezy/tests/blackbox/test_version.py	2018-08-14 20:37:51 +0000
@@ -101,9 +101,9 @@
         else:
             self.overrideEnv('BRZ_HOME', str_val)
         self.permit_source_tree_branch_repo()
-        out = self.run_bzr("version")[0]
+        out = self.run_bzr_raw("version")[0]
         self.assertTrue(len(out) > 0)
-        self.assertContainsRe(out, r"(?m)^  Breezy configuration: " + str_val)
+        self.assertContainsRe(out, br"(?m)^  Breezy configuration: " + str_val)
 
 
 class TestVersionBzrLogLocation(TestCaseInTempDir):
@@ -115,7 +115,7 @@
         self.assertPathDoesNotExist([default_log, brz_log])
         out = self.run_bzr_subprocess('version')[0]
         self.assertTrue(len(out) > 0)
-        self.assertContainsRe(out, br"(?m)^  Breezy log file: " + brz_log)
+        self.assertContainsRe(out, br"(?m)^  Breezy log file: " + brz_log.encode('ascii'))
         self.assertPathDoesNotExist(default_log)
         self.assertPathExists(brz_log)
 
@@ -131,7 +131,7 @@
         self.assertPathDoesNotExist(default_log)
         out = self.run_bzr_subprocess('version')[0]
         self.assertTrue(len(out) > 0)
-        self.assertContainsRe(out, br"(?m)^  Breezy log file: " + brz_log)
+        self.assertContainsRe(out, br"(?m)^  Breezy log file: " + brz_log.encode('ascii'))
         self.assertPathDoesNotExist(default_log)
 
     def test_unicode_brz_log(self):
@@ -144,8 +144,11 @@
                 "Test string %r unrepresentable in user encoding %s" % (
                 uni_val, enc))
         self.overrideEnv('BRZ_HOME', self.test_base_dir)
-        self.overrideEnv("BRZ_LOG",
-            os.path.join(self.test_base_dir, uni_val).encode(enc))
+        brz_log = os.path.join(self.test_base_dir, uni_val)
+        if PY3:
+            self.overrideEnv("BRZ_LOG", brz_log)
+        else:
+            self.overrideEnv("BRZ_LOG", brz_log.encode(enc))
         out, err = self.run_bzr_subprocess("version")
         uni_out = out.decode(enc)
         self.assertContainsRe(uni_out, u"(?m)^  Breezy log file: .*/\xa7$")

=== modified file 'breezy/tests/blackbox/test_version_info.py'
--- breezy/tests/blackbox/test_version_info.py	2018-07-25 01:23:15 +0000
+++ breezy/tests/blackbox/test_version_info.py	2018-08-14 20:37:51 +0000
@@ -171,11 +171,10 @@
         self.build_tree(['a_file'])
         tree.add('a_file')
         tree.commit(commit_message)
-        out, err = self.run_bzr(
+        out, err = self.run_bzr_raw(
             ['version-info', '--include-history'], encoding='latin-1')
 
-        if not PY3:
-            commit_message = commit_message.encode('latin-1', 'replace')
+        commit_message = commit_message.encode('latin-1', 'replace')
         self.assertContainsString(out, commit_message)
 
     def test_revision(self):

=== modified file 'breezy/tests/script.py'
--- breezy/tests/script.py	2018-07-15 18:45:17 +0000
+++ breezy/tests/script.py	2018-08-14 20:37:51 +0000
@@ -22,14 +22,18 @@
 import doctest
 import errno
 import glob
+import logging
 import os
 import shlex
+import sys
 import textwrap
 
 from .. import (
     osutils,
     tests,
+    trace,
     )
+from ..tests import ui_testing
 
 
 def split(s):
@@ -315,9 +319,32 @@
         return output
 
     def do_brz(self, test_case, input, args):
-        retcode, out, err = test_case._run_bzr_core(
-            args, retcode=None, encoding=None, stdin=input, working_dir=None)
-        return retcode, out, err
+        encoding = osutils.get_user_encoding()
+        if sys.version_info[0] == 2:
+            stdout = ui_testing.BytesIOWithEncoding()
+            stderr = ui_testing.BytesIOWithEncoding()
+            stdout.encoding = stderr.encoding = encoding
+
+            # FIXME: don't call into logging here
+            handler = trace.EncodedStreamHandler(
+                stderr, errors="replace")
+        else:
+            stdout = ui_testing.StringIOWithEncoding()
+            stderr = ui_testing.StringIOWithEncoding()
+            stdout.encoding = stderr.encoding = encoding
+            handler = logging.StreamHandler(stderr)
+        handler.setLevel(logging.INFO)
+
+        logger = logging.getLogger('')
+        logger.addHandler(handler)
+        try:
+            retcode = test_case._run_bzr_core(
+                args, encoding=encoding, stdin=input, stdout=stdout,
+                stderr=stderr, working_dir=None)
+        finally:
+            logger.removeHandler(handler)
+
+        return retcode, stdout.getvalue(), stderr.getvalue()
 
     def do_cat(self, test_case, input, args):
         (in_name, out_name, out_mode, args) = _scan_redirection_options(args)

=== modified file 'breezy/tests/test_errors.py'
--- breezy/tests/test_errors.py	2017-10-27 00:18:42 +0000
+++ breezy/tests/test_errors.py	2018-08-14 20:37:51 +0000
@@ -29,6 +29,7 @@
     urlutils,
     )
 from ..sixish import (
+    PY3,
     text_type,
     )
 
@@ -511,12 +512,15 @@
     def test_always_str(self):
         e = PassThroughError(u'\xb5', 'bar')
         self.assertIsInstance(e.__str__(), str)
-        # In Python str(foo) *must* return a real byte string
+        # In Python 2 str(foo) *must* return a real byte string
         # not a Unicode string. The following line would raise a
         # Unicode error, because it tries to call str() on the string
         # returned from e.__str__(), and it has non ascii characters
         s = str(e)
-        self.assertEqual('Pass through \xc2\xb5 and bar', s)
+        if PY3:
+            self.assertEqual('Pass through \xb5 and bar', s)
+        else:
+            self.assertEqual('Pass through \xc2\xb5 and bar', s)
 
     def test_missing_format_string(self):
         e = ErrorWithNoFormat(param='randomvalue')

=== modified file 'breezy/tests/test_nonascii.py'
--- breezy/tests/test_nonascii.py	2018-07-24 21:44:05 +0000
+++ breezy/tests/test_nonascii.py	2018-08-14 20:37:51 +0000
@@ -154,7 +154,7 @@
             with open(path, 'rb') as f:
                 # Check the contents
                 shouldbe = b'contents of %s%s' % (path.encode('utf8'),
-                                                  os.linesep)
+                                                  os.linesep.encode('utf-8'))
                 actual = f.read()
             self.assertEqual(shouldbe, actual,
                              'contents of %r is incorrect: %r != %r'

=== modified file 'breezy/tests/test_osutils.py'
--- breezy/tests/test_osutils.py	2018-07-24 22:51:28 +0000
+++ breezy/tests/test_osutils.py	2018-08-14 20:37:51 +0000
@@ -1202,8 +1202,8 @@
         self.build_tree(tree)
 
         # rename the 1file to a latin-1 filename
-        os.rename("./1file", "\xe8file")
-        if "\xe8file" not in os.listdir("."):
+        os.rename(b"./1file", b"\xe8file")
+        if b"\xe8file" not in os.listdir("."):
             self.skipTest("Lack filesystem that preserves arbitrary bytes")
 
         self._save_platform_info()
@@ -1211,7 +1211,7 @@
 
         # this should raise on error
         def attempt():
-            for dirdetail, dirblock in osutils.walkdirs('.'):
+            for dirdetail, dirblock in osutils.walkdirs(b'.'):
                 pass
 
         self.assertRaises(errors.BadFilenameEncoding, attempt)
@@ -1245,11 +1245,15 @@
             ]
         result = []
         found_bzrdir = False
-        for dirdetail, dirblock in osutils._walkdirs_utf8('.'):
-            if len(dirblock) and dirblock[0][1] == '.bzr':
+        for dirdetail, dirblock in osutils._walkdirs_utf8(b'.'):
+            if len(dirblock) and dirblock[0][1] == b'.bzr':
                 # this tests the filtering of selected paths
                 found_bzrdir = True
                 del dirblock[0]
+            dirdetail = (dirdetail[0].decode('utf-8'), dirdetail[1])
+            dirblock = [
+                    (entry[0].decode('utf-8'), entry[1].decode('utf-8'), entry[2])
+                    for entry in dirblock]
             result.append((dirdetail, dirblock))
 
         self.assertTrue(found_bzrdir)
@@ -1720,7 +1724,10 @@
                 % (osutils.get_user_encoding(),))
 
         old = osutils.set_or_unset_env('BRZ_TEST_ENV_VAR', uni_val)
-        self.assertEqual(env_val, os.environ.get('BRZ_TEST_ENV_VAR'))
+        if PY3:
+            self.assertEqual(uni_val, os.environ.get('BRZ_TEST_ENV_VAR'))
+        else:
+            self.assertEqual(env_val, os.environ.get('BRZ_TEST_ENV_VAR'))
 
     def test_unset(self):
         """Test that passing None will remove the env var"""
@@ -2150,11 +2157,16 @@
         self.assertEqual(u'/home/\xa7test',
             osutils._posix_path_from_environ('BRZ_TEST_PATH'))
         osutils._fs_enc = "iso8859-5"
-        self.assertEqual(u'/home/\u0407test',
-            osutils._posix_path_from_environ('BRZ_TEST_PATH'))
-        osutils._fs_enc = "utf-8"
-        self.assertRaises(errors.BadFilenameEncoding,
-            osutils._posix_path_from_environ, 'BRZ_TEST_PATH')
+        if PY3:
+            # In Python 3, os.environ returns unicode.
+            self.assertEqual(u'/home/\xa7test',
+                osutils._posix_path_from_environ('BRZ_TEST_PATH'))
+        else:
+            self.assertEqual(u'/home/\u0407test',
+                osutils._posix_path_from_environ('BRZ_TEST_PATH'))
+            osutils._fs_enc = "utf-8"
+            self.assertRaises(errors.BadFilenameEncoding,
+                osutils._posix_path_from_environ, 'BRZ_TEST_PATH')
 
 
 class TestGetHomeDir(tests.TestCase):
@@ -2180,10 +2192,14 @@
         self.overrideAttr(osutils, "_fs_enc", "iso8859-1")
         self.assertEqual(u'/home/\xa7test', osutils._posix_get_home_dir())
         osutils._fs_enc = "iso8859-5"
-        self.assertEqual(u'/home/\u0407test', osutils._posix_get_home_dir())
-        osutils._fs_enc = "utf-8"
-        self.assertRaises(errors.BadFilenameEncoding,
-            osutils._posix_get_home_dir)
+        if PY3:
+            # In python 3, os.environ returns unicode
+            self.assertEqual(u'/home/\xa7test', osutils._posix_get_home_dir())
+        else:
+            self.assertEqual(u'/home/\u0407test', osutils._posix_get_home_dir())
+            osutils._fs_enc = "utf-8"
+            self.assertRaises(errors.BadFilenameEncoding,
+                osutils._posix_get_home_dir)
 
 
 class TestGetuserUnicode(tests.TestCase):
@@ -2212,7 +2228,10 @@
                 % (osutils.get_user_encoding(),))
         uni_username = u'jrandom' + uni_val
         encoded_username = uni_username.encode(ue)
-        self.overrideEnv(self.envvar_to_override(), encoded_username)
+        if PY3:
+            self.overrideEnv(self.envvar_to_override(), uni_username)
+        else:
+            self.overrideEnv(self.envvar_to_override(), encoded_username)
         self.assertEqual(uni_username, osutils.getuser_unicode())
 
 

=== modified file 'breezy/tests/test_remote.py'
--- breezy/tests/test_remote.py	2018-08-02 01:10:26 +0000
+++ breezy/tests/test_remote.py	2018-08-14 20:37:51 +0000
@@ -71,6 +71,7 @@
     )
 from ..sixish import (
     BytesIO,
+    PY3,
     text_type,
     )
 from ..bzr.smart import medium, request
@@ -337,10 +338,13 @@
         client = FakeClient('/')
         client.add_success_response(b'yes',)
         transport = RemoteTransport('bzr://localhost/', _client=client)
-        filename = u'/hell\u00d8'.encode('utf-8')
-        result = transport.has(filename)
+        filename = u'/hell\u00d8'
+        if PY3:
+            result = transport.has(filename)
+        else:
+            result = transport.has(filename.encode('utf-8'))
         self.assertEqual(
-            [('call', b'has', (filename,))],
+            [('call', b'has', (filename.encode('utf-8'),))],
             client._calls)
         self.assertTrue(result)
 

=== modified file 'breezy/tests/test_selftest.py'
--- breezy/tests/test_selftest.py	2018-08-02 23:52:07 +0000
+++ breezy/tests/test_selftest.py	2018-08-14 20:37:51 +0000
@@ -1778,11 +1778,6 @@
     return ExampleTests(name)
 
 
-def _get_skip_reasons(result):
-    # GZ 2017-06-06: Newer testtools doesn't have this, uses detail instead
-    return result.skip_reasons
-
-
 class TestTestCaseLogDetails(tests.TestCase):
 
     def _run_test(self, test_name):
@@ -1809,7 +1804,7 @@
 
     def test_skip_has_no_log(self):
         result = self._run_test('test_skip')
-        reasons = _get_skip_reasons(result)
+        reasons = result.skip_reasons
         self.assertEqual({'reason'}, set(reasons))
         skips = reasons['reason']
         self.assertEqual(1, len(skips))
@@ -1820,7 +1815,7 @@
         # testtools doesn't know about addNotSupported, so it just gets
         # considered as a skip
         result = self._run_test('test_missing_feature')
-        reasons = _get_skip_reasons(result)
+        reasons = result.skip_reasons
         self.assertEqual({str(missing_feature)}, set(reasons))
         skips = reasons[str(missing_feature)]
         self.assertEqual(1, len(skips))
@@ -2231,7 +2226,7 @@
         content, result = self.run_subunit_stream('test_skip')
         self.assertNotContainsRe(content, '(?m)^log$')
         self.assertNotContainsRe(content, 'this test will be skipped')
-        reasons = _get_skip_reasons(result)
+        reasons = result.skip_reasons
         self.assertEqual({'reason'}, set(reasons))
         skips = reasons['reason']
         self.assertEqual(1, len(skips))
@@ -2243,7 +2238,7 @@
         content, result = self.run_subunit_stream('test_missing_feature')
         self.assertNotContainsRe(content, '(?m)^log$')
         self.assertNotContainsRe(content, 'missing the feature')
-        reasons = _get_skip_reasons(result)
+        reasons = result.skip_reasons
         self.assertEqual({'_MissingFeature\n'}, set(reasons))
         skips = reasons['_MissingFeature\n']
         self.assertEqual(1, len(skips))
@@ -2265,13 +2260,6 @@
         content, result = self.run_subunit_stream('test_unexpected_success')
         self.assertContainsRe(content, '(?m)^log$')
         self.assertContainsRe(content, 'test with unexpected success')
-        # GZ 2011-05-18: Old versions of subunit treat unexpected success as a
-        #                success, if a min version check is added remove this
-        from subunit import TestProtocolClient as _Client
-        if _Client.addUnexpectedSuccess.__func__ is _Client.addSuccess.__func__:
-            self.expectFailure('subunit treats "unexpectedSuccess"'
-                               ' as a plain success',
-                self.assertEqual, 1, len(result.unexpectedSuccesses))
         self.assertEqual(1, len(result.unexpectedSuccesses))
         test = result.unexpectedSuccesses[0]
         # RemotedTestCase doesn't preserve the "details"
@@ -2286,11 +2274,12 @@
 
 class TestRunBzr(tests.TestCase):
 
+    result = 0
     out = ''
     err = ''
 
-    def _run_bzr_core(self, argv, retcode=0, encoding=None, stdin=None,
-                         working_dir=None):
+    def _run_bzr_core(self, argv, encoding=None, stdin=None,
+                      stdout=None, stderr=None, working_dir=None):
         """Override _run_bzr_core to test how it is invoked by run_bzr.
 
         Attempts to run bzr from inside this class don't actually run it.
@@ -2299,58 +2288,41 @@
         only need to test that it passes the right parameters to run_bzr.
         """
         self.argv = list(argv)
-        self.retcode = retcode
         self.encoding = encoding
         self.stdin = stdin
         self.working_dir = working_dir
-        return self.retcode, self.out, self.err
+        stdout.write(self.out)
+        stderr.write(self.err)
+        return self.result
 
     def test_run_bzr_error(self):
         self.out = "It sure does!\n"
+        self.result = 34
         out, err = self.run_bzr_error(['^$'], ['rocks'], retcode=34)
         self.assertEqual(['rocks'], self.argv)
-        self.assertEqual(34, self.retcode)
         self.assertEqual('It sure does!\n', out)
         self.assertEqual(out, self.out)
         self.assertEqual('', err)
         self.assertEqual(err, self.err)
 
     def test_run_bzr_error_regexes(self):
-        self.out = b''
-        self.err = b"bzr: ERROR: foobarbaz is not versioned"
+        self.out = ''
+        self.err = "bzr: ERROR: foobarbaz is not versioned"
+        self.result = 3
         out, err = self.run_bzr_error(
-            [b"bzr: ERROR: foobarbaz is not versioned"],
+            ["bzr: ERROR: foobarbaz is not versioned"],
             ['file-id', 'foobarbaz'])
 
     def test_encoding(self):
         """Test that run_bzr passes encoding to _run_bzr_core"""
         self.run_bzr('foo bar')
-        self.assertEqual(None, self.encoding)
+        self.assertEqual(osutils.get_user_encoding(), self.encoding)
         self.assertEqual(['foo', 'bar'], self.argv)
 
         self.run_bzr('foo bar', encoding='baz')
         self.assertEqual('baz', self.encoding)
         self.assertEqual(['foo', 'bar'], self.argv)
 
-    def test_retcode(self):
-        """Test that run_bzr passes retcode to _run_bzr_core"""
-        # Default is retcode == 0
-        self.run_bzr('foo bar')
-        self.assertEqual(0, self.retcode)
-        self.assertEqual(['foo', 'bar'], self.argv)
-
-        self.run_bzr('foo bar', retcode=1)
-        self.assertEqual(1, self.retcode)
-        self.assertEqual(['foo', 'bar'], self.argv)
-
-        self.run_bzr('foo bar', retcode=None)
-        self.assertEqual(None, self.retcode)
-        self.assertEqual(['foo', 'bar'], self.argv)
-
-        self.run_bzr(['foo', 'bar'], retcode=3)
-        self.assertEqual(3, self.retcode)
-        self.assertEqual(['foo', 'bar'], self.argv)
-
     def test_stdin(self):
         # test that the stdin keyword to run_bzr is passed through to
         # _run_bzr_core as-is. We do this by overriding

=== modified file 'python3.passing'
--- python3.passing	2018-08-08 02:10:06 +0000
+++ python3.passing	2018-08-14 20:37:51 +0000
@@ -1,5 +1,320 @@
 # This is the list of tests that are known to pass with Python3.
 # "make check-nodocs3" verifies that these pass.
+breezy.git.tests.test_blackbox.ShallowTests.test_log_shallow
+breezy.git.tests.test_blackbox.ShallowTests.test_version_info_custom_without_revno
+breezy.git.tests.test_blackbox.ShallowTests.test_version_info_custom_with_revno
+breezy.git.tests.test_blackbox.ShallowTests.test_version_info_python
+breezy.git.tests.test_blackbox.ShallowTests.test_version_info_rio
+breezy.git.tests.test_blackbox.TestGitBlackBox.test_branch
+breezy.git.tests.test_blackbox.TestGitBlackBox.test_branches
+breezy.git.tests.test_blackbox.TestGitBlackBox.test_branch_ls
+breezy.git.tests.test_blackbox.TestGitBlackBox.test_check
+breezy.git.tests.test_blackbox.TestGitBlackBox.test_checkout
+breezy.git.tests.test_blackbox.TestGitBlackBox.test_diff_format
+breezy.git.tests.test_blackbox.TestGitBlackBox.test_git_import
+breezy.git.tests.test_blackbox.TestGitBlackBox.test_git_import_colo
+breezy.git.tests.test_blackbox.TestGitBlackBox.test_git_import_incremental
+breezy.git.tests.test_blackbox.TestGitBlackBox.test_git_import_tags
+breezy.git.tests.test_blackbox.TestGitBlackBox.test_git_import_uncolocated
+breezy.git.tests.test_blackbox.TestGitBlackBox.test_git_refs_from_bzr
+breezy.git.tests.test_blackbox.TestGitBlackBox.test_git_refs_from_git
+breezy.git.tests.test_blackbox.TestGitBlackBox.test_info
+breezy.git.tests.test_blackbox.TestGitBlackBox.test_info_verbose
+breezy.git.tests.test_blackbox.TestGitBlackBox.test_init
+breezy.git.tests.test_blackbox.TestGitBlackBox.test_init_repo
+breezy.git.tests.test_blackbox.TestGitBlackBox.test_log
+breezy.git.tests.test_blackbox.TestGitBlackBox.test_log_verbose
+breezy.git.tests.test_blackbox.TestGitBlackBox.test_nick
+breezy.git.tests.test_blackbox.TestGitBlackBox.test_tag
+breezy.git.tests.test_blackbox.TestGitBlackBox.test_tags
+breezy.git.tests.test_branch.BranchTests.test_interbranch_pull
+breezy.git.tests.test_branch.BranchTests.test_interbranch_pull_noop
+breezy.git.tests.test_branch.BranchTests.test_interbranch_pull_stop_revision
+breezy.git.tests.test_branch.BranchTests.test_interbranch_pull_with_tags
+breezy.git.tests.test_branch.BranchTests.test_single_rev
+breezy.git.tests.test_branch.BranchTests.test_sprouted_tags
+breezy.git.tests.test_branch.TestGitBranch.test_last_revision_info
+breezy.git.tests.test_branch.TestGitBranch.test_last_revision_is_null
+breezy.git.tests.test_branch.TestGitBranch.test_last_revision_is_valid
+breezy.git.tests.test_branch.TestGitBranch.test_open_by_ref
+breezy.git.tests.test_branch.TestGitBranch.test_open_existing
+breezy.git.tests.test_branch.TestGitBranch.test_repr
+breezy.git.tests.test_branch.TestGitBranch.test_tag
+breezy.git.tests.test_branch.TestGitBranch.test_tag_annotated
+breezy.git.tests.test_branch.TestLocalGitBranchFormat.test_get_format_description
+breezy.git.tests.test_branch.TestLocalGitBranchFormat.test_get_network_name
+breezy.git.tests.test_branch.TestLocalGitBranchFormat.test_supports_tags
+breezy.git.tests.test_branch.TestWithGitBranch.test_get_parent
+breezy.git.tests.test_branch.TestWithGitBranch.test_get_physical_lock_status
+breezy.git.tests.test_branch.TestWithGitBranch.test_get_stacked_on_url
+breezy.git.tests.test_builder.TestGitBranchBuilderReal.test_create_real_branch
+breezy.git.tests.test_builder.TestGitBranchBuilder.test_add_and_commit
+breezy.git.tests.test_builder.TestGitBranchBuilder.test_auto_timestamp
+breezy.git.tests.test_builder.TestGitBranchBuilder.test_commit_base
+breezy.git.tests.test_builder.TestGitBranchBuilder.test_commit_merge
+breezy.git.tests.test_builder.TestGitBranchBuilder.test__create_blob
+breezy.git.tests.test_builder.TestGitBranchBuilder.test_delete_entry
+breezy.git.tests.test_builder.TestGitBranchBuilder.test_delete_entry_newline
+breezy.git.tests.test_builder.TestGitBranchBuilder.test_encode_path
+breezy.git.tests.test_builder.TestGitBranchBuilder.test_reset
+breezy.git.tests.test_builder.TestGitBranchBuilder.test_reset_named_ref
+breezy.git.tests.test_builder.TestGitBranchBuilder.test_reset_revision
+breezy.git.tests.test_builder.TestGitBranchBuilder.test_set_file
+breezy.git.tests.test_builder.TestGitBranchBuilder.test_set_file_executable
+breezy.git.tests.test_builder.TestGitBranchBuilder.test_set_file_newline
+breezy.git.tests.test_builder.TestGitBranchBuilder.test_set_file_unicode
+breezy.git.tests.test_builder.TestGitBranchBuilder.test_set_symlink
+breezy.git.tests.test_builder.TestGitBranchBuilder.test_set_symlink_newline
+breezy.git.tests.test_cache.DictGitShaMapTests.test_blob
+breezy.git.tests.test_cache.DictGitShaMapTests.test_commit
+breezy.git.tests.test_cache.DictGitShaMapTests.test_lookup_notfound
+breezy.git.tests.test_cache.DictGitShaMapTests.test_missing_revisions
+breezy.git.tests.test_cache.DictGitShaMapTests.test_revids
+breezy.git.tests.test_cache.DictGitShaMapTests.test_tree
+breezy.git.tests.test_cache.IndexGitShaMapTests.test_blob
+breezy.git.tests.test_cache.IndexGitShaMapTests.test_commit
+breezy.git.tests.test_cache.IndexGitShaMapTests.test_lookup_notfound
+breezy.git.tests.test_cache.IndexGitShaMapTests.test_missing_revisions
+breezy.git.tests.test_cache.IndexGitShaMapTests.test_revids
+breezy.git.tests.test_cache.IndexGitShaMapTests.test_tree
+breezy.git.tests.test_cache.SqliteGitShaMapTests.test_blob
+breezy.git.tests.test_cache.SqliteGitShaMapTests.test_commit
+breezy.git.tests.test_cache.SqliteGitShaMapTests.test_lookup_notfound
+breezy.git.tests.test_cache.SqliteGitShaMapTests.test_missing_revisions
+breezy.git.tests.test_cache.SqliteGitShaMapTests.test_revids
+breezy.git.tests.test_cache.SqliteGitShaMapTests.test_tree
+breezy.git.tests.test_cache.TdbGitShaMapTests.test_blob
+breezy.git.tests.test_cache.TdbGitShaMapTests.test_commit
+breezy.git.tests.test_cache.TdbGitShaMapTests.test_lookup_notfound
+breezy.git.tests.test_cache.TdbGitShaMapTests.test_missing_revisions
+breezy.git.tests.test_cache.TdbGitShaMapTests.test_revids
+breezy.git.tests.test_cache.TdbGitShaMapTests.test_tree
+breezy.git.tests.test_dir.TestGitDirFormat.test_eq
+breezy.git.tests.test_dir.TestGitDirFormat.test_get_format_description
+breezy.git.tests.test_dir.TestGitDir.test_get_head_branch_reference
+breezy.git.tests.test_dir.TestGitDir.test_git_file
+breezy.git.tests.test_dir.TestGitDir.test_open_existing
+breezy.git.tests.test_dir.TestGitDir.test_open_workingtree
+breezy.git.tests.test_dir.TestGitDir.test_open_workingtree_bare
+breezy.git.tests.test_fetch.ImportObjects.test_directory_converted_to_submodule
+breezy.git.tests.test_fetch.ImportObjects.test_import_blob_simple
+breezy.git.tests.test_fetch.ImportObjects.test_import_tree_empty
+breezy.git.tests.test_fetch.ImportObjects.test_import_tree_empty_root
+breezy.git.tests.test_fetch.ImportObjects.test_import_tree_with_file
+breezy.git.tests.test_fetch.ImportObjects.test_import_tree_with_file_exe
+breezy.git.tests.test_fetch.ImportObjects.test_import_tree_with_unusual_mode_file
+breezy.git.tests.test_fetch.LocalRepositoryFetchTests.test_becomes_executable
+breezy.git.tests.test_fetch.LocalRepositoryFetchTests.test_changing_symlink
+breezy.git.tests.test_fetch.LocalRepositoryFetchTests.test_dir_becomes_symlink
+breezy.git.tests.test_fetch.LocalRepositoryFetchTests.test_empty
+breezy.git.tests.test_fetch.LocalRepositoryFetchTests.test_executable
+breezy.git.tests.test_fetch.LocalRepositoryFetchTests.test_incremental
+breezy.git.tests.test_fetch.LocalRepositoryFetchTests.test_into_stacked_on
+breezy.git.tests.test_fetch.LocalRepositoryFetchTests.test_non_ascii_characters
+breezy.git.tests.test_fetch.LocalRepositoryFetchTests.test_single_rev
+breezy.git.tests.test_fetch.LocalRepositoryFetchTests.test_single_rev_specific
+breezy.git.tests.test_fetch.LocalRepositoryFetchTests.test_symlink_becomes_dir
+breezy.git.tests.test_fetch.LocalRepositoryFetchTests.test_tagged_tree
+breezy.git.tests.test_git_remote_helper.FetchTests.test_no_wants
+breezy.git.tests.test_git_remote_helper.FetchTests.test_simple
+breezy.git.tests.test_git_remote_helper.OpenLocalDirTests.test_from_dir
+breezy.git.tests.test_git_remote_helper.OpenLocalDirTests.test_from_env_dir
+breezy.git.tests.test_git_remote_helper.RemoteHelperTests.test_capabilities
+breezy.git.tests.test_git_remote_helper.RemoteHelperTests.test_import
+breezy.git.tests.test_git_remote_helper.RemoteHelperTests.test_list_basic
+breezy.git.tests.test_git_remote_helper.RemoteHelperTests.test_option
+breezy.git.tests.test_mapping.FileidTests.test_escape_control_l
+breezy.git.tests.test_mapping.FileidTests.test_escape_space
+breezy.git.tests.test_mapping.FileidTests.test_escape_underscore
+breezy.git.tests.test_mapping.FileidTests.test_escape_underscore_space
+breezy.git.tests.test_mapping.FileidTests.test_unescape_control_l
+breezy.git.tests.test_mapping.FileidTests.test_unescape_underscore
+breezy.git.tests.test_mapping.FileidTests.test_unescape_underscore_space
+breezy.git.tests.test_mapping.FixPersonIdentifierTests.test_fix
+breezy.git.tests.test_mapping.FixPersonIdentifierTests.test_valid
+breezy.git.tests.test_mapping.RoundtripRevisionsFromBazaar.test_custom_property
+breezy.git.tests.test_mapping.RoundtripRevisionsFromBazaar.test_ghost_parent
+breezy.git.tests.test_mapping.RoundtripRevisionsFromBazaar.test_revision_id
+breezy.git.tests.test_mapping.RoundtripRevisionsFromBazaar.test_simple_commit
+breezy.git.tests.test_mapping.RoundtripRevisionsFromGit.test_commit
+breezy.git.tests.test_mapping.RoundtripRevisionsFromGit.test_commit_double_negative_timezone
+breezy.git.tests.test_mapping.RoundtripRevisionsFromGit.test_commit_encoding
+breezy.git.tests.test_mapping.RoundtripRevisionsFromGit.test_commit_extra
+breezy.git.tests.test_mapping.RoundtripRevisionsFromGit.test_commit_mergetag
+breezy.git.tests.test_mapping.RoundtripRevisionsFromGit.test_commit_zero_utc_timezone
+breezy.git.tests.test_mapping.TestImportCommit.test_commit
+breezy.git.tests.test_mapping.TestImportCommit.test_explicit_encoding
+breezy.git.tests.test_mapping.TestImportCommit.test_implicit_encoding_fallback
+breezy.git.tests.test_mapping.TestImportCommit.test_implicit_encoding_utf8
+breezy.git.tests.test_mapping.TestImportCommit.test_mergetag
+breezy.git.tests.test_mapping.TestImportCommit.test_unknown_extra
+breezy.git.tests.test_mapping.TestRevidConversionV1.test_generate_file_id
+breezy.git.tests.test_mapping.TestRevidConversionV1.test_is_control_file
+breezy.git.tests.test_mapping.TestRevidConversionV1.test_simple_bzr_to_git_revision_id
+breezy.git.tests.test_mapping.TestRevidConversionV1.test_simple_git_to_bzr_revision_id
+breezy.git.tests.test_memorytree.TestMemoryTree.test_add_in_subdir
+breezy.git.tests.test_memorytree.TestMemoryTree.test_add_with_kind
+breezy.git.tests.test_memorytree.TestMemoryTree.test_commit_trivial
+breezy.git.tests.test_memorytree.TestMemoryTree.test_create_on_branch
+breezy.git.tests.test_memorytree.TestMemoryTree.test_create_on_branch_with_content
+breezy.git.tests.test_memorytree.TestMemoryTree.test_last_revision
+breezy.git.tests.test_memorytree.TestMemoryTree.test_lock_tree_write
+breezy.git.tests.test_memorytree.TestMemoryTree.test_lock_tree_write_after_read_fails
+breezy.git.tests.test_memorytree.TestMemoryTree.test_lock_write
+breezy.git.tests.test_memorytree.TestMemoryTree.test_lock_write_after_read_fails
+breezy.git.tests.test_memorytree.TestMemoryTree.test_put_existing_file
+breezy.git.tests.test_memorytree.TestMemoryTree.test_put_new_file
+breezy.git.tests.test_memorytree.TestMemoryTree.test_rename_file
+breezy.git.tests.test_memorytree.TestMemoryTree.test_rename_file_to_subdir
+breezy.git.tests.test_memorytree.TestMemoryTree.test_unversion
+breezy.git.tests.test_object_store.BazaarObjectStoreTests.test_contains
+breezy.git.tests.test_object_store.BazaarObjectStoreTests.test_get_blob
+breezy.git.tests.test_object_store.BazaarObjectStoreTests.test_get_raw
+breezy.git.tests.test_object_store.DirectoryToTreeTests.test_empty
+breezy.git.tests.test_object_store.DirectoryToTreeTests.test_empty_dir
+breezy.git.tests.test_object_store.DirectoryToTreeTests.test_empty_dir_dummy_files
+breezy.git.tests.test_object_store.DirectoryToTreeTests.test_empty_root
+breezy.git.tests.test_object_store.DirectoryToTreeTests.test_with_file
+breezy.git.tests.test_object_store.DirectoryToTreeTests.test_with_gitdir
+breezy.git.tests.test_object_store.ExpectedShaTests.test_binary
+breezy.git.tests.test_object_store.ExpectedShaTests.test_hex
+breezy.git.tests.test_object_store.ExpectedShaTests.test_none
+breezy.git.tests.test_object_store.FindMissingBzrRevidsTests.test_one_missing
+breezy.git.tests.test_object_store.FindMissingBzrRevidsTests.test_simple
+breezy.git.tests.test_object_store.FindMissingBzrRevidsTests.test_two_missing
+breezy.git.tests.test_object_store.FindMissingBzrRevidsTests.test_two_missing_history
+breezy.git.tests.test_object_store.FindMissingBzrRevidsTests.test_up_to_date
+breezy.git.tests.test_object_store.LRUTreeCacheTests.test_get
+breezy.git.tests.test_object_store.LRUTreeCacheTests.test_get_not_present
+breezy.git.tests.test_object_store.LRUTreeCacheTests.test_iter_revision_trees
+breezy.git.tests.test_object_store.LRUTreeCacheTests.test_revision_trees
+breezy.git.tests.test_object_store.TreeToObjectsTests.test_no_changes
+breezy.git.tests.test_object_store.TreeToObjectsTests.test_with_gitdir
+breezy.git.tests.test_pristine_tar.ReadPristineTarData.test_read_pristine_tar_data
+breezy.git.tests.test_pristine_tar.ReadPristineTarData.test_read_pristine_tar_data_no_branch
+breezy.git.tests.test_pristine_tar.ReadPristineTarData.test_read_pristine_tar_data_no_file
+breezy.git.tests.test_pristine_tar.RevisionPristineTarDataTests.test_pristine_tar_delta_gz
+breezy.git.tests.test_pristine_tar.RevisionPristineTarDataTests.test_pristine_tar_delta_unknown
+breezy.git.tests.test_pristine_tar.StoreGitPristineTarData.test_store_new
+breezy.git.tests.test_push.InterToGitRepositoryTests.test_instance
+breezy.git.tests.test_push.InterToGitRepositoryTests.test_missing_revisions_unknown_stop_rev
+breezy.git.tests.test_push.InterToGitRepositoryTests.test_odd_rename
+breezy.git.tests.test_push.InterToGitRepositoryTests.test_pointless_fetch_refs
+breezy.git.tests.test_push.InterToGitRepositoryTests.test_pointless_fetch_refs_old_mapping
+breezy.git.tests.test_push.InterToGitRepositoryTests.test_pointless_lossy_fetch_refs
+breezy.git.tests.test_push.InterToGitRepositoryTests.test_pointless_missing_revisions
+breezy.git.tests.test_refs.BazaarRefsContainerTests.test_empty
+breezy.git.tests.test_refs.BazaarRefsContainerTests.test_some_branch
+breezy.git.tests.test_refs.BazaarRefsContainerTests.test_some_commit
+breezy.git.tests.test_refs.BazaarRefsContainerTests.test_some_tag
+breezy.git.tests.test_refs.BranchNameRefConversionTests.test_branch
+breezy.git.tests.test_refs.BranchNameRefConversionTests.test_head
+breezy.git.tests.test_refs.BranchNameRefConversionTests.test_tag
+breezy.git.tests.test_remote.FetchFromRemoteToBzrTests.test_sprout_simple
+breezy.git.tests.test_remote.FetchFromRemoteToBzrTests.test_sprout_with_annotated_tag
+breezy.git.tests.test_remote.FetchFromRemoteToBzrTests.test_sprout_with_tags
+breezy.git.tests.test_remote.FetchFromRemoteToGitTests.test_sprout_simple
+breezy.git.tests.test_remote.FetchFromRemoteToGitTests.test_sprout_with_annotated_tag
+breezy.git.tests.test_remote.FetchFromRemoteToGitTests.test_sprout_with_tags
+breezy.git.tests.test_remote.ParseGitErrorTests.test_notbrancherror
+breezy.git.tests.test_remote.ParseGitErrorTests.test_unknown
+breezy.git.tests.test_remote.PushToRemoteFromBzrTests.test_push
+breezy.git.tests.test_remote.PushToRemoteFromBzrTests.test_push_branch_new
+breezy.git.tests.test_remote.PushToRemoteFromBzrTests.test_push_diverged
+breezy.git.tests.test_remote.PushToRemoteFromGitTests.test_push
+breezy.git.tests.test_remote.PushToRemoteFromGitTests.test_push_branch_new
+breezy.git.tests.test_remote.PushToRemoteFromGitTests.test_push_diverged
+breezy.git.tests.test_remote.RemoteControlDirTests.test_annotated_tag
+breezy.git.tests.test_remote.RemoteControlDirTests.test_get_branches
+breezy.git.tests.test_remote.RemoteControlDirTests.test_list_branches
+breezy.git.tests.test_remote.RemoteControlDirTests.test_remove_branch
+breezy.git.tests.test_remote.RemoteControlDirTests.test_remove_tag
+breezy.git.tests.test_remote.RemoteControlDirTests.test_set_tag
+breezy.git.tests.test_remote.SplitUrlTests.test_homedir
+breezy.git.tests.test_remote.SplitUrlTests.test_nopath
+breezy.git.tests.test_remote.SplitUrlTests.test_port
+breezy.git.tests.test_remote.SplitUrlTests.test_simple
+breezy.git.tests.test_remote.SplitUrlTests.test_slashpath
+breezy.git.tests.test_remote.SplitUrlTests.test_username
+breezy.git.tests.test_remote.TestRemoteGitBranchFormat.test_get_format_description
+breezy.git.tests.test_remote.TestRemoteGitBranchFormat.test_get_network_name
+breezy.git.tests.test_remote.TestRemoteGitBranchFormat.test_supports_tags
+breezy.git.tests.test_repository.GitRepositoryFormat.test_get_format_description
+breezy.git.tests.test_repository.RevisionGistImportTests.test_pointless
+breezy.git.tests.test_repository.SigningGitRepository.test_signed_commit
+breezy.git.tests.test_repository.TestGitRepositoryFeatures.test_get_revision
+breezy.git.tests.test_repository.TestGitRepositoryFeatures.test_get_revision_unknown
+breezy.git.tests.test_repository.TestGitRepositoryFeatures.test_has_git_repo
+breezy.git.tests.test_repository.TestGitRepositoryFeatures.test_has_revision
+breezy.git.tests.test_repository.TestGitRepositoryFeatures.test_has_revisions
+breezy.git.tests.test_repository.TestGitRepositoryFeatures.test_open_existing
+breezy.git.tests.test_repository.TestGitRepositoryFeatures.test_pack
+breezy.git.tests.test_repository.TestGitRepositoryFeatures.test_revision_tree
+breezy.git.tests.test_repository.TestGitRepository.test_all_revision_ids
+breezy.git.tests.test_repository.TestGitRepository.test_all_revision_ids_none
+breezy.git.tests.test_repository.TestGitRepository.test_get_known_graph_ancestry
+breezy.git.tests.test_repository.TestGitRepository.test_get_parent_map_null
+breezy.git.tests.test_repository.TestGitRepository.test_get_signature_text
+breezy.git.tests.test_repository.TestGitRepository.test_has_signature_for_revision_id
+breezy.git.tests.test_repository.TestGitRepository.test_revision_tree_none
+breezy.git.tests.test_repository.TestGitRepository.test_supports_rich_root
+breezy.git.tests.test_revspec.Sha1ValidTests.test_invalid
+breezy.git.tests.test_revspec.Sha1ValidTests.test_valid
+breezy.git.tests.test_roundtrip.ExtractMetadataTests.test_roundtrip
+breezy.git.tests.test_roundtrip.FileIdRoundTripTests.test_deserialize
+breezy.git.tests.test_roundtrip.FileIdRoundTripTests.test_serialize
+breezy.git.tests.test_roundtrip.FormatTests.test_empty
+breezy.git.tests.test_roundtrip.FormatTests.test_parent_ids
+breezy.git.tests.test_roundtrip.FormatTests.test_properties
+breezy.git.tests.test_roundtrip.FormatTests.test_revid
+breezy.git.tests.test_roundtrip.GenerateMetadataTests.test_no_metadata
+breezy.git.tests.test_roundtrip.GenerateMetadataTests.test_roundtrip
+breezy.git.tests.test_roundtrip.RoundtripTests.test_parent_ids
+breezy.git.tests.test_roundtrip.RoundtripTests.test_properties
+breezy.git.tests.test_roundtrip.RoundtripTests.test_revid
+breezy.git.tests.test_server.TestPlainFetch.test_fetch_from_native_git
+breezy.git.tests.test_server.TestPlainFetch.test_fetch_from_non_git
+breezy.git.tests.test_server.TestPlainFetch.test_fetch_nothing
+breezy.git.tests.test_server.TestPresent.test_present
+breezy.git.tests.test_transportgit.TransportObjectStoreTests.test_add_commit
+breezy.git.tests.test_transportgit.TransportObjectStoreTests.test_add_object
+breezy.git.tests.test_transportgit.TransportObjectStoreTests.test_add_objects
+breezy.git.tests.test_transportgit.TransportObjectStoreTests.test_add_objects_empty
+breezy.git.tests.test_transportgit.TransportObjectStoreTests.test_close
+breezy.git.tests.test_transportgit.TransportObjectStoreTests.test_contains_nonexistant
+breezy.git.tests.test_transportgit.TransportObjectStoreTests.test_determine_wants_all
+breezy.git.tests.test_transportgit.TransportObjectStoreTests.test_determine_wants_all_zero
+breezy.git.tests.test_transportgit.TransportObjectStoreTests.test_empty_packs
+breezy.git.tests.test_transportgit.TransportObjectStoreTests.test_get_nonexistant
+breezy.git.tests.test_transportgit.TransportObjectStoreTests.test_get_raw
+breezy.git.tests.test_transportgit.TransportObjectStoreTests.test_iter
+breezy.git.tests.test_transportgit.TransportObjectStoreTests.test_iter_tree_contents
+breezy.git.tests.test_transportgit.TransportObjectStoreTests.test_iter_tree_contents_include_trees
+breezy.git.tests.test_transportgit.TransportObjectStoreTests.test_pack_loose_objects
+breezy.git.tests.test_transportgit.TransportObjectStoreTests.test_peel_sha
+breezy.git.tests.test_transportgit.TransportObjectStoreTests.test_remembers_packs
+breezy.git.tests.test_transportgit.TransportObjectStoreTests.test_repack
+breezy.git.tests.test_transportgit.TransportObjectStoreTests.test_repack_existing
+breezy.git.tests.test_transportgit.TransportObjectStoreTests.test_store_resilience
+breezy.git.tests.test_transportgit.TransportObjectStoreTests.test_tree_changes
+breezy.git.tests.test_unpeel_map.TestUnpeelMap.test_load
+breezy.git.tests.test_unpeel_map.TestUnpeelMap.test_new
+breezy.git.tests.test_unpeel_map.TestUnpeelMap.test_update
+breezy.git.tests.test_urls.TestConvertURL.test_path
+breezy.git.tests.test_urls.TestConvertURL.test_regular
+breezy.git.tests.test_urls.TestConvertURL.test_simple
+breezy.git.tests.test_workingtree.ChangesBetweenGitTreeAndWorkingCopyTests.test_added_file
+breezy.git.tests.test_workingtree.ChangesBetweenGitTreeAndWorkingCopyTests.test_added_unknown_file
+breezy.git.tests.test_workingtree.ChangesBetweenGitTreeAndWorkingCopyTests.test_empty
+breezy.git.tests.test_workingtree.ChangesBetweenGitTreeAndWorkingCopyTests.test_extra
+breezy.git.tests.test_workingtree.ChangesBetweenGitTreeAndWorkingCopyTests.test_missing_added_file
+breezy.git.tests.test_workingtree.ChangesBetweenGitTreeAndWorkingCopyTests.test_missing_versioned_file
+breezy.git.tests.test_workingtree.ChangesBetweenGitTreeAndWorkingCopyTests.test_versioned_replace_by_dir
+breezy.git.tests.test_workingtree.GitWorkingTreeTests.test_add_conflict
+breezy.git.tests.test_workingtree.GitWorkingTreeTests.test_conflict_list
+breezy.git.tests.test_workingtree.GitWorkingTreeTests.test_revert_empty
+breezy.git.tests.test_workingtree.TreeDeltaFromGitChangesTests.test_empty
+breezy.git.tests.test_workingtree.TreeDeltaFromGitChangesTests.test_missing
 breezy.plugins.bash_completion.tests.test_bashcomp.BlackboxTests.test_bash_completion
 breezy.plugins.bash_completion.tests.test_bashcomp.TestBashCodeGen.test_brz_version
 breezy.plugins.bash_completion.tests.test_bashcomp.TestBashCodeGen.test_command_case
@@ -762,6 +1077,7 @@
 breezy.plugins.grep.test_grep.TestGrep.test_wtree_include_from_outside_dir
 breezy.plugins.grep.test_grep.TestGrep.test_wtree_null_option
 breezy.plugins.grep.test_grep.TestGrep.test_wtree_with_line_number
+breezy.plugins.grep.test_grep.TestNonAscii.test_unicode_only_file
 breezy.plugins.launchpad.test_account.CheckAccountTests.test_check_lp_login_no_ssh_keys
 breezy.plugins.launchpad.test_account.CheckAccountTests.test_check_lp_login_no_user
 breezy.plugins.launchpad.test_account.CheckAccountTests.test_check_lp_login_valid_user
@@ -1525,6 +1841,7 @@
 breezy.tests.blackbox.test_clean_tree.TestBzrTools.test_clean_tree_nested_bzrdir
 breezy.tests.blackbox.test_command_encoding.TestCommandEncoding.test_exact
 breezy.tests.blackbox.test_command_encoding.TestCommandEncoding.test_replace_ascii
+breezy.tests.blackbox.test_command_encoding.TestCommandEncoding.test_replace_utf8
 breezy.tests.blackbox.test_command_encoding.TestCommandEncoding.test_strict_ascii
 breezy.tests.blackbox.test_command_encoding.TestCommandEncoding.test_strict_utf8
 breezy.tests.blackbox.test_commit.TestCommit.test_05_empty_commit
@@ -1553,6 +1870,7 @@
 breezy.tests.blackbox.test_commit.TestCommit.test_empty_commit_message
 breezy.tests.blackbox.test_commit.TestCommit.test_fixes_bug_output
 breezy.tests.blackbox.test_commit.TestCommit.test_fixes_bug_sets_property
+breezy.tests.blackbox.test_commit.TestCommit.test_fixes_bug_unicode
 breezy.tests.blackbox.test_commit.TestCommit.test_fixes_bug_with_alternate_trackers
 breezy.tests.blackbox.test_commit.TestCommit.test_fixes_bug_with_default_tracker
 breezy.tests.blackbox.test_commit.TestCommit.test_fixes_invalid_argument
@@ -1565,6 +1883,7 @@
 breezy.tests.blackbox.test_commit.TestCommit.test_no_author
 breezy.tests.blackbox.test_commit.TestCommit.test_no_bugs_no_properties
 breezy.tests.blackbox.test_commit.TestCommit.test_non_ascii_file_unversioned_iso_8859_5
+breezy.tests.blackbox.test_commit.TestCommit.test_non_ascii_file_unversioned_utf8
 breezy.tests.blackbox.test_commit.TestCommit.test_other_branch_commit
 breezy.tests.blackbox.test_commit.TestCommit.test_out_of_date_tree_commit
 breezy.tests.blackbox.test_commit.TestCommit.test_partial_commit_with_renames_in_tree
@@ -1708,13 +2027,17 @@
 breezy.tests.blackbox.test_export.TestExport.test_export_partial_tree
 breezy.tests.blackbox.test_export.TestExport.test_export_uncommitted
 breezy.tests.blackbox.test_export.TestExport.test_export_uncommitted_no_tree
+breezy.tests.blackbox.test_export.TestExport.test_tar_export
 breezy.tests.blackbox.test_export.TestExport.test_tar_export_ignores_bzr
 breezy.tests.blackbox.test_export.TestExport.test_tar_export_unicode_basedir
 breezy.tests.blackbox.test_export.TestExport.test_tar_export_unicode_filename
+breezy.tests.blackbox.test_export.TestExport.test_tbz2_export
+breezy.tests.blackbox.test_export.TestExport.test_tgz_export
 breezy.tests.blackbox.test_export.TestExport.test_zip_export_directories
 breezy.tests.blackbox.test_export.TestExport.test_zip_export_file
 breezy.tests.blackbox.test_export.TestExport.test_zip_export_ignores_bzr
 breezy.tests.blackbox.test_export.TestExport.test_zip_export_per_file_timestamps
+breezy.tests.blackbox.test_export.TestExport.test_zip_export_stdout
 breezy.tests.blackbox.test_export.TestExport.test_zip_export_unicode
 breezy.tests.blackbox.test_export.TestSmartServerExport.test_simple_export
 breezy.tests.blackbox.test_fetch_ghosts.TestFetchGhosts.test_fetch_ghosts
@@ -1770,6 +2093,10 @@
 breezy.tests.blackbox.test_help.TestHelp.test_help_with_aliases
 breezy.tests.blackbox.test_help.TestHelp.test_help_working_trees
 breezy.tests.blackbox.test_help.TestHelp.test_hidden
+breezy.tests.blackbox.test_help.TestTranslatedHelp.test_help_command_ascii
+breezy.tests.blackbox.test_help.TestTranslatedHelp.test_help_command_utf8
+breezy.tests.blackbox.test_help.TestTranslatedHelp.test_help_switch_ascii
+breezy.tests.blackbox.test_help.TestTranslatedHelp.test_help_switch_utf8
 breezy.tests.blackbox.test_hooks.TestHooks.test_hooks_lazy_with_named_hook
 breezy.tests.blackbox.test_hooks.TestHooks.test_hooks_lazy_with_unnamed_hook
 breezy.tests.blackbox.test_hooks.TestHooks.test_hooks_no_branch
@@ -1855,6 +2182,7 @@
 breezy.tests.blackbox.test_log.Test_GenerateAllRevisions.test_wrong_order
 breezy.tests.blackbox.test_log.TestLogEncodings.test_log_handles_bad_encoding
 breezy.tests.blackbox.test_log.TestLogEncodings.test_log_handles_encoding
+breezy.tests.blackbox.test_log.TestLogEncodings.test_stdout_encoding
 breezy.tests.blackbox.test_log.TestLogErrors.test_log_bad_message_re
 breezy.tests.blackbox.test_log.TestLogErrors.test_log_change_incompatible_with_revision
 breezy.tests.blackbox.test_log.TestLogErrors.test_log_change_nonexistent_dotted_revno
@@ -1985,6 +2313,7 @@
 breezy.tests.blackbox.test_merge.TestMerge.test_merge_criss_cross
 breezy.tests.blackbox.test_merge.TestMerge.test_merge_defaults_to_reprocess
 breezy.tests.blackbox.test_merge.TestMerge.test_merge_explicit_reprocess_show_base
+breezy.tests.blackbox.test_merge.TestMerge.test_merge_fetches_tags
 breezy.tests.blackbox.test_merge.TestMerge.test_merge_from_submit
 breezy.tests.blackbox.test_merge.TestMerge.test_merge_interactive_unlocks_branch
 breezy.tests.blackbox.test_merge.TestMerge.test_merge_kind_change
@@ -2074,12 +2403,16 @@
 breezy.tests.blackbox.test_non_ascii.TestNonAscii.test_branch(iso-8859-2)
 breezy.tests.blackbox.test_non_ascii.TestNonAscii.test_branch(utf-8,1)
 breezy.tests.blackbox.test_non_ascii.TestNonAscii.test_branch(utf-8,2)
+breezy.tests.blackbox.test_non_ascii.TestNonAscii.test_cat(cp1251)
 breezy.tests.blackbox.test_non_ascii.TestNonAscii.test_cat(iso-8859-1)
+breezy.tests.blackbox.test_non_ascii.TestNonAscii.test_cat(iso-8859-2)
 breezy.tests.blackbox.test_non_ascii.TestNonAscii.test_cat_revision(cp1251)
 breezy.tests.blackbox.test_non_ascii.TestNonAscii.test_cat_revision(iso-8859-1)
 breezy.tests.blackbox.test_non_ascii.TestNonAscii.test_cat_revision(iso-8859-2)
 breezy.tests.blackbox.test_non_ascii.TestNonAscii.test_cat_revision(utf-8,1)
 breezy.tests.blackbox.test_non_ascii.TestNonAscii.test_cat_revision(utf-8,2)
+breezy.tests.blackbox.test_non_ascii.TestNonAscii.test_cat(utf-8,1)
+breezy.tests.blackbox.test_non_ascii.TestNonAscii.test_cat(utf-8,2)
 breezy.tests.blackbox.test_non_ascii.TestNonAscii.test_deleted(cp1251)
 breezy.tests.blackbox.test_non_ascii.TestNonAscii.test_deleted(iso-8859-1)
 breezy.tests.blackbox.test_non_ascii.TestNonAscii.test_deleted(iso-8859-2)
@@ -2120,16 +2453,36 @@
 breezy.tests.blackbox.test_non_ascii.TestNonAscii.test_inventory(iso-8859-2)
 breezy.tests.blackbox.test_non_ascii.TestNonAscii.test_inventory(utf-8,1)
 breezy.tests.blackbox.test_non_ascii.TestNonAscii.test_inventory(utf-8,2)
+breezy.tests.blackbox.test_non_ascii.TestNonAscii.test_log(cp1251)
+breezy.tests.blackbox.test_non_ascii.TestNonAscii.test_log(iso-8859-1)
+breezy.tests.blackbox.test_non_ascii.TestNonAscii.test_log(iso-8859-2)
+breezy.tests.blackbox.test_non_ascii.TestNonAscii.test_log(utf-8,1)
+breezy.tests.blackbox.test_non_ascii.TestNonAscii.test_log(utf-8,2)
 breezy.tests.blackbox.test_non_ascii.TestNonAscii.test_ls(cp1251)
 breezy.tests.blackbox.test_non_ascii.TestNonAscii.test_ls(iso-8859-1)
 breezy.tests.blackbox.test_non_ascii.TestNonAscii.test_ls(iso-8859-2)
 breezy.tests.blackbox.test_non_ascii.TestNonAscii.test_ls(utf-8,1)
 breezy.tests.blackbox.test_non_ascii.TestNonAscii.test_ls(utf-8,2)
+breezy.tests.blackbox.test_non_ascii.TestNonAscii.test_missing(cp1251)
+breezy.tests.blackbox.test_non_ascii.TestNonAscii.test_missing(iso-8859-1)
+breezy.tests.blackbox.test_non_ascii.TestNonAscii.test_missing(iso-8859-2)
+breezy.tests.blackbox.test_non_ascii.TestNonAscii.test_missing(utf-8,1)
+breezy.tests.blackbox.test_non_ascii.TestNonAscii.test_missing(utf-8,2)
+breezy.tests.blackbox.test_non_ascii.TestNonAscii.test_mkdir(cp1251)
+breezy.tests.blackbox.test_non_ascii.TestNonAscii.test_mkdir(iso-8859-1)
+breezy.tests.blackbox.test_non_ascii.TestNonAscii.test_mkdir(iso-8859-2)
+breezy.tests.blackbox.test_non_ascii.TestNonAscii.test_mkdir(utf-8,1)
+breezy.tests.blackbox.test_non_ascii.TestNonAscii.test_mkdir(utf-8,2)
 breezy.tests.blackbox.test_non_ascii.TestNonAscii.test_modified(cp1251)
 breezy.tests.blackbox.test_non_ascii.TestNonAscii.test_modified(iso-8859-1)
 breezy.tests.blackbox.test_non_ascii.TestNonAscii.test_modified(iso-8859-2)
 breezy.tests.blackbox.test_non_ascii.TestNonAscii.test_modified(utf-8,1)
 breezy.tests.blackbox.test_non_ascii.TestNonAscii.test_modified(utf-8,2)
+breezy.tests.blackbox.test_non_ascii.TestNonAscii.test_mv(cp1251)
+breezy.tests.blackbox.test_non_ascii.TestNonAscii.test_mv(iso-8859-1)
+breezy.tests.blackbox.test_non_ascii.TestNonAscii.test_mv(iso-8859-2)
+breezy.tests.blackbox.test_non_ascii.TestNonAscii.test_mv(utf-8,1)
+breezy.tests.blackbox.test_non_ascii.TestNonAscii.test_mv(utf-8,2)
 breezy.tests.blackbox.test_non_ascii.TestNonAscii.test_pull(cp1251)
 breezy.tests.blackbox.test_non_ascii.TestNonAscii.test_pull(iso-8859-1)
 breezy.tests.blackbox.test_non_ascii.TestNonAscii.test_pull(iso-8859-2)
@@ -2523,6 +2876,7 @@
 breezy.tests.blackbox.test_send.TestSend.test_uses_submit
 breezy.tests.blackbox.test_send.TestSmartServerSend.test_send
 breezy.tests.blackbox.test_serve.TestBzrServe.test_bzr_serve_dhpss
+breezy.tests.blackbox.test_serve.TestBzrServe.test_bzr_serve_graceful_shutdown
 breezy.tests.blackbox.test_serve.TestBzrServe.test_bzr_serve_inet_readonly
 breezy.tests.blackbox.test_serve.TestBzrServe.test_bzr_serve_inet_readwrite
 breezy.tests.blackbox.test_serve.TestBzrServe.test_bzr_serve_port_readonly
@@ -2561,6 +2915,7 @@
 breezy.tests.blackbox.test_shelve.TestShelveRelpath.test_shelve_in_subdir
 breezy.tests.blackbox.test_shelve.TestShelveRelpath.test_shelve_via_directory
 breezy.tests.blackbox.test_shelve.TestShelveUnshelve.test_directory
+breezy.tests.blackbox.test_shelve.TestUnshelvePreview.test_non_ascii
 breezy.tests.blackbox.test_sign_my_commits.SignMyCommits.test_sign_diff_committer
 breezy.tests.blackbox.test_sign_my_commits.SignMyCommits.test_sign_dry_run
 breezy.tests.blackbox.test_sign_my_commits.SignMyCommits.test_sign_my_commits
@@ -2648,9 +3003,11 @@
 breezy.tests.blackbox.test_tags.TestSmartServerCat.test_show_tags
 breezy.tests.blackbox.test_tags.TestTagging.test_automatic_tag_name
 breezy.tests.blackbox.test_tags.TestTagging.test_branch_push_pull_merge_copies_tags
+breezy.tests.blackbox.test_tags.TestTagging.test_cannot_tag_range
 breezy.tests.blackbox.test_tags.TestTagging.test_commit_in_heavyweight_checkout_copies_tags_to_master
 breezy.tests.blackbox.test_tags.TestTagging.test_commit_in_heavyweight_checkout_reports_tag_conflict
 breezy.tests.blackbox.test_tags.TestTagging.test_conflicting_tags
+breezy.tests.blackbox.test_tags.TestTagging.test_list_tags
 breezy.tests.blackbox.test_tags.TestTagging.test_list_tags_dotted_revnos_unsupported
 breezy.tests.blackbox.test_tags.TestTagging.test_list_tags_revision_filtering
 breezy.tests.blackbox.test_tags.TestTagging.test_merge_without_commit_does_not_propagate_tags_to_master
@@ -2762,6 +3119,7 @@
 breezy.tests.blackbox.test_version_info.TestVersionInfo.test_custom_without_template
 breezy.tests.blackbox.test_version_info.TestVersionInfo.test_invalid_format
 breezy.tests.blackbox.test_version_info.TestVersionInfo.test_no_branch
+breezy.tests.blackbox.test_version_info.TestVersionInfo.test_non_ascii
 breezy.tests.blackbox.test_version_info.TestVersionInfo.test_no_working_tree
 breezy.tests.blackbox.test_version_info.TestVersionInfo.test_python
 breezy.tests.blackbox.test_version_info.TestVersionInfo.test_revision
@@ -2772,11 +3130,15 @@
 breezy.tests.blackbox.test_versioning.TestMkdir.test_mkdir_in_subdir
 breezy.tests.blackbox.test_versioning.TestMkdir.test_mkdir_quiet
 breezy.tests.blackbox.test_versioning.TestMkdir.test_mkdir_w_nested_trees
+breezy.tests.blackbox.test_version.TestVersionBzrLogLocation.test_dev_null
+breezy.tests.blackbox.test_version.TestVersionBzrLogLocation.test_simple
+breezy.tests.blackbox.test_version.TestVersionBzrLogLocation.test_unicode_brz_log
 breezy.tests.blackbox.test_version.TestVersion.test_main_version
 breezy.tests.blackbox.test_version.TestVersion.test_version
 breezy.tests.blackbox.test_version.TestVersion.test_version_short
 breezy.tests.blackbox.test_version.TestVersionUnicodeOutput.test_command
 breezy.tests.blackbox.test_version.TestVersionUnicodeOutput.test_flag
+breezy.tests.blackbox.test_version.TestVersionUnicodeOutput.test_unicode_bzr_home
 breezy.tests.blackbox.test_view.TestViewUI.test_define_view
 breezy.tests.blackbox.test_view.TestViewUI.test_delete_view
 breezy.tests.blackbox.test_view.TestViewUI.test_list_view
@@ -9130,16 +9492,16 @@
 breezy.tests.per_repository_reference.test_get_record_stream.TestGetRecordStream.test_ordered_no_closure(RemoteRepositoryFormat-v2)
 breezy.tests.per_repository_reference.test_get_record_stream.TestGetRecordStream.test_ordered_no_closure(RepositoryFormat2a)
 breezy.tests.per_repository_reference.test_get_record_stream.TestGetRecordStream.test_ordered_no_closure(RepositoryFormat2aSubtree)
-breezy.tests.per_repository_reference.test_get_record_stream.TestGetRecordStream.test_unordered_fetch_complex_split(RemoteRepositoryFormat-default)
-breezy.tests.per_repository_reference.test_get_record_stream.TestGetRecordStream.test_unordered_fetch_complex_split(RemoteRepositoryFormat-v2)
-breezy.tests.per_repository_reference.test_get_record_stream.TestGetRecordStream.test_unordered_fetch_complex_split(RepositoryFormat2a)
-breezy.tests.per_repository_reference.test_get_record_stream.TestGetRecordStream.test_unordered_fetch_complex_split(RepositoryFormat2aSubtree)
 breezy.tests.per_repository_reference.test_get_record_stream.TestGetRecordStream.test_ordered_no_closure(RepositoryFormatKnitPack5)
 breezy.tests.per_repository_reference.test_get_record_stream.TestGetRecordStream.test_ordered_no_closure(RepositoryFormatKnitPack5RichRoot)
 breezy.tests.per_repository_reference.test_get_record_stream.TestGetRecordStream.test_ordered_no_closure(RepositoryFormatKnitPack5RichRootBroken)
 breezy.tests.per_repository_reference.test_get_record_stream.TestGetRecordStream.test_ordered_no_closure(RepositoryFormatKnitPack6)
 breezy.tests.per_repository_reference.test_get_record_stream.TestGetRecordStream.test_ordered_no_closure(RepositoryFormatKnitPack6RichRoot)
 breezy.tests.per_repository_reference.test_get_record_stream.TestGetRecordStream.test_ordered_no_closure(RepositoryFormatPackDevelopment2Subtree)
+breezy.tests.per_repository_reference.test_get_record_stream.TestGetRecordStream.test_unordered_fetch_complex_split(RemoteRepositoryFormat-default)
+breezy.tests.per_repository_reference.test_get_record_stream.TestGetRecordStream.test_unordered_fetch_complex_split(RemoteRepositoryFormat-v2)
+breezy.tests.per_repository_reference.test_get_record_stream.TestGetRecordStream.test_unordered_fetch_complex_split(RepositoryFormat2a)
+breezy.tests.per_repository_reference.test_get_record_stream.TestGetRecordStream.test_unordered_fetch_complex_split(RepositoryFormat2aSubtree)
 breezy.tests.per_repository_reference.test_get_record_stream.TestGetRecordStream.test_unordered_fetch_complex_split(RepositoryFormatKnitPack5)
 breezy.tests.per_repository_reference.test_get_record_stream.TestGetRecordStream.test_unordered_fetch_complex_split(RepositoryFormatKnitPack5RichRoot)
 breezy.tests.per_repository_reference.test_get_record_stream.TestGetRecordStream.test_unordered_fetch_complex_split(RepositoryFormatKnitPack5RichRootBroken)
@@ -19344,10 +19706,16 @@
 breezy.tests.per_workingtree.test_content_filters.TestWorkingTreeWithContentFilters.test_content_filtering_applied_on_merge(WorkingTreeFormat2)
 breezy.tests.per_workingtree.test_content_filters.TestWorkingTreeWithContentFilters.test_content_filtering_applied_on_merge(WorkingTreeFormat3)
 breezy.tests.per_workingtree.test_content_filters.TestWorkingTreeWithContentFilters.test_content_filtering_applied_on_merge(WorkingTreeFormat4)
+breezy.tests.per_workingtree.test_content_filters.TestWorkingTreeWithContentFilters.test_content_filtering_applied_on_merge(WorkingTreeFormat5)
+breezy.tests.per_workingtree.test_content_filters.TestWorkingTreeWithContentFilters.test_content_filtering_applied_on_merge(WorkingTreeFormat6)
+breezy.tests.per_workingtree.test_content_filters.TestWorkingTreeWithContentFilters.test_content_filtering_applied_on_merge(WorkingTreeFormat6,remote)
 breezy.tests.per_workingtree.test_content_filters.TestWorkingTreeWithContentFilters.test_content_filtering_applied_on_pull(GitWorkingTreeFormat)
 breezy.tests.per_workingtree.test_content_filters.TestWorkingTreeWithContentFilters.test_content_filtering_applied_on_pull(WorkingTreeFormat2)
 breezy.tests.per_workingtree.test_content_filters.TestWorkingTreeWithContentFilters.test_content_filtering_applied_on_pull(WorkingTreeFormat3)
 breezy.tests.per_workingtree.test_content_filters.TestWorkingTreeWithContentFilters.test_content_filtering_applied_on_pull(WorkingTreeFormat4)
+breezy.tests.per_workingtree.test_content_filters.TestWorkingTreeWithContentFilters.test_content_filtering_applied_on_pull(WorkingTreeFormat5)
+breezy.tests.per_workingtree.test_content_filters.TestWorkingTreeWithContentFilters.test_content_filtering_applied_on_pull(WorkingTreeFormat6)
+breezy.tests.per_workingtree.test_content_filters.TestWorkingTreeWithContentFilters.test_content_filtering_applied_on_pull(WorkingTreeFormat6,remote)
 breezy.tests.per_workingtree.test_content_filters.TestWorkingTreeWithContentFilters.test_content_filtering_applied_on_revert_delete(GitWorkingTreeFormat)
 breezy.tests.per_workingtree.test_content_filters.TestWorkingTreeWithContentFilters.test_content_filtering_applied_on_revert_delete(WorkingTreeFormat2)
 breezy.tests.per_workingtree.test_content_filters.TestWorkingTreeWithContentFilters.test_content_filtering_applied_on_revert_delete(WorkingTreeFormat3)
@@ -23729,6 +24097,10 @@
 breezy.tests.test_conflicts.TestResolveMissingParent.test_kill_them_all
 breezy.tests.test_conflicts.TestResolveMissingParent.test_resolve_taking_other
 breezy.tests.test_conflicts.TestResolveMissingParent.test_resolve_taking_this
+breezy.tests.test_conflicts.TestResolveNonDirectoryParent.test_resolve_taking_other
+breezy.tests.test_conflicts.TestResolveNonDirectoryParent.test_resolve_taking_this
+breezy.tests.test_conflicts.TestResolveNonDirectoryParent.test_take_other
+breezy.tests.test_conflicts.TestResolveNonDirectoryParent.test_take_this
 breezy.tests.test_conflicts.TestResolveParentLoop.test_resolve_taking_other(dir1_into_dir2,dir2_into_dir1)
 breezy.tests.test_conflicts.TestResolveParentLoop.test_resolve_taking_other(dir2_into_dir1,dir1_into_dir2)
 breezy.tests.test_conflicts.TestResolveParentLoop.test_resolve_taking_this(dir1_into_dir2,dir2_into_dir1)
@@ -24151,6 +24523,8 @@
 breezy.tests.test_email_message.TestEmailMessage.test_multiple_destinations
 breezy.tests.test_email_message.TestEmailMessage.test_retrieving_headers
 breezy.tests.test_email_message.TestEmailMessage.test_setting_headers
+breezy.tests.test_email_message.TestEmailMessage.test_simple_message
+breezy.tests.test_email_message.TestEmailMessage.test_string_with_encoding
 breezy.tests.test_email_message.TestSend.test_send_patch
 breezy.tests.test_email_message.TestSend.test_send_plain
 breezy.tests.test_email_message.TestSend.test_send_simple
@@ -24160,6 +24534,7 @@
 breezy.tests.test_eol_filters.TestEolRulesSpecifications.test_exact_value
 breezy.tests.test_eol_filters.TestEolRulesSpecifications.test_other_known_values
 breezy.tests.test_eol_filters.TestEolRulesSpecifications.test_unknown_value
+breezy.tests.test_errors.TestErrorFormatting.test_always_str
 breezy.tests.test_errors.TestErrorFormatting.test_cannot_bind_address
 breezy.tests.test_errors.TestErrorFormatting.test_mismatched_format_args
 breezy.tests.test_errors.TestErrorFormatting.test_missing_format_string
@@ -25107,6 +25482,7 @@
 breezy.tests.test_import_tariff.TestImportTariffs.test_help_commands
 breezy.tests.test_import_tariff.TestImportTariffs.test_import_tariffs_working
 breezy.tests.test_import_tariff.TestImportTariffs.test_simple_local
+breezy.tests.test_import_tariff.TestImportTariffs.test_simple_serve
 breezy.tests.test_index.ErrorTests.test_bad_index_data
 breezy.tests.test_index.ErrorTests.test_bad_index_duplicate_key
 breezy.tests.test_index.ErrorTests.test_bad_index_format_signature
@@ -27009,6 +27385,7 @@
 breezy.tests.test_nonascii.NonAsciiTest.test_add_in_nonascii_branch
 breezy.tests.test_nonascii.NormalizedFilename.test__accessible_normalized_filename
 breezy.tests.test_nonascii.NormalizedFilename.test_access_non_normalized
+breezy.tests.test_nonascii.NormalizedFilename.test_access_normalized
 breezy.tests.test_nonascii.NormalizedFilename.test_functions
 breezy.tests.test_nonascii.NormalizedFilename.test__inaccessible_normalized_filename
 breezy.tests.test_nonascii.NormalizedFilename.test_platform
@@ -27106,8 +27483,10 @@
 breezy.tests.test_osutils.TestGetHomeDir.test_is_unicode
 breezy.tests.test_osutils.TestGetHomeDir.test_posix_home_ascii
 breezy.tests.test_osutils.TestGetHomeDir.test_posix_homeless
+breezy.tests.test_osutils.TestGetHomeDir.test_posix_home_unicode
 breezy.tests.test_osutils.TestGetuserUnicode.test_ascii_user
 breezy.tests.test_osutils.TestGetuserUnicode.test_is_unicode
+breezy.tests.test_osutils.TestGetuserUnicode.test_unicode_user
 breezy.tests.test_osutils.TestIsInside.test_is_inside
 breezy.tests.test_osutils.TestIsInside.test_is_inside_any
 breezy.tests.test_osutils.TestIsInside.test_is_inside_or_parent_of_any
@@ -27122,6 +27501,7 @@
 breezy.tests.test_osutils.TestParentDirectories.test_parent_directories
 breezy.tests.test_osutils.TestPathFromEnviron.test_is_unicode
 breezy.tests.test_osutils.TestPathFromEnviron.test_posix_path_env_ascii
+breezy.tests.test_osutils.TestPathFromEnviron.test_posix_path_env_unicode
 breezy.tests.test_osutils.TestPosixFuncs.test_normpath
 breezy.tests.test_osutils.TestPumpFile.test_bracket_block_size
 breezy.tests.test_osutils.TestPumpFile.test_defaults
@@ -27171,6 +27551,7 @@
 breezy.tests.test_osutils.TestSendAll.test_send_with_no_progress
 breezy.tests.test_osutils.TestSetUnsetEnv.test_double_set
 breezy.tests.test_osutils.TestSetUnsetEnv.test_set
+breezy.tests.test_osutils.TestSetUnsetEnv.test_unicode
 breezy.tests.test_osutils.TestSetUnsetEnv.test_unset
 breezy.tests.test_osutils.TestShaFileByName.test_sha_empty
 breezy.tests.test_osutils.TestShaFileByName.test_sha_mixed_endings
@@ -27186,6 +27567,7 @@
 breezy.tests.test_osutils.TestTerminalWidth.test_no_TIOCGWINSZ
 breezy.tests.test_osutils.TestTerminalWidth.test_tty_default_without_columns
 breezy.tests.test_osutils.TestUmask.test_get_umask
+breezy.tests.test_osutils.TestWalkDirs.test_compare_paths_prefix_order
 breezy.tests.test_osutils.TestWalkDirs.test_force_walkdirs_utf8_fs_ascii
 breezy.tests.test_osutils.TestWalkDirs.test_force_walkdirs_utf8_fs_latin1
 breezy.tests.test_osutils.TestWalkDirs.test_force_walkdirs_utf8_fs_utf8
@@ -27194,7 +27576,9 @@
 breezy.tests.test_osutils.TestWalkDirs.test_unicode_walkdirs
 breezy.tests.test_osutils.TestWalkDirs.test_unicode__walkdirs_utf8
 breezy.tests.test_osutils.TestWalkDirs.test_walkdirs
+breezy.tests.test_osutils.TestWalkDirs.test_walkdirs_encoding_error
 breezy.tests.test_osutils.TestWalkDirs.test_walkdirs_os_error
+breezy.tests.test_osutils.TestWalkDirs.test__walkdirs_utf8
 breezy.tests.test_osutils.TestWalkDirs.test__walkdirs_utf8_win32readdir
 breezy.tests.test_osutils.TestWalkDirs.test__walkdirs_utf8_with_unicode_fs
 breezy.tests.test_osutils.TestWalkDirs.test__walkdirs_utf_win32_find_file_stat_directory
@@ -27758,6 +28142,7 @@
 breezy.tests.test_remote.TestUpdateBoundBranchWithModifiedBoundLocation.test_plus_sign
 breezy.tests.test_remote.TestUpdateBoundBranchWithModifiedBoundLocation.test_tilda
 breezy.tests.test_remote.TestUpdateBoundBranchWithModifiedBoundLocation.test_without_final_slash
+breezy.tests.test_remote.TestVfsHas.test_unicode_path
 breezy.tests.test_remote.TestWithCustomErrorHandler.test_no_context
 breezy.tests.test_remote.TestWithCustomErrorHandler.test_with_context
 breezy.tests.test_rename_map.TestRenameMap.test_add_edge_hashes