Merge lp:~jelmer/brz/python3-blackbox into lp:brz

[Jelmer Vernooij]

Change run_bzr to use StringIOWithEncoding for stderr and stdout on python 3.

Change run_bzr to use StringIOWithEncoding for stderr and stdout on python 3.

This is more correct: it matches the actual sys.stderr and sys.stdout on Python 3.

It fixes a large number of blackbox tests and removes the need to add bees in many places.

There are some corner cases, where we currently compare with utf-8 encoded bytestrings on Python2. We'll need to either special case those for Python 3 or add some sort of generic way of dealing with it.

[Martin Packman (gz)]

I think the run_bzr level should be text by default, so overall changes here seem good regardless of a few messy bits. Some of the output content checks really should be using regexp matching over more primitive things, but that can all get fiddled with later.

review: Approve

[The Breezy Bot (the-breezy-bot)]

Merging failed
https://ci.breezy-vcs.org/job/land-brz/287/

[The Breezy Bot (the-breezy-bot)]

Merging failed
https://ci.breezy-vcs.org/job/land-brz/291/

[The Breezy Bot (the-breezy-bot)]

Merging failed
https://ci.breezy-vcs.org/job/land-brz/298/

[The Breezy Bot (the-breezy-bot)]

Running landing tests failed
https://ci.breezy-vcs.org/job/land-brz/300/

[The Breezy Bot (the-breezy-bot)]

Merging failed
https://ci.breezy-vcs.org/job/land-brz/307/

[The Breezy Bot (the-breezy-bot)]

Merging failed
https://ci.breezy-vcs.org/job/land-brz/309/

[The Breezy Bot (the-breezy-bot)]

Running landing tests failed
https://ci.breezy-vcs.org/job/land-brz/310/

[The Breezy Bot (the-breezy-bot)]

Running landing tests failed
https://ci.breezy-vcs.org/job/land-brz/311/

[The Breezy Bot (the-breezy-bot)]

Running landing tests failed
https://ci.breezy-vcs.org/job/land-brz/312/

[The Breezy Bot (the-breezy-bot)]

Running landing tests failed
https://ci.breezy-vcs.org/job/land-brz/313/

[The Breezy Bot (the-breezy-bot)]

Running landing tests failed
https://ci.breezy-vcs.org/job/land-brz/314/

[The Breezy Bot (the-breezy-bot)]

Running landing tests failed
https://ci.breezy-vcs.org/job/land-brz/315/

=== modified file 'breezy/builtins.py'
--- breezy/builtins.py	2018-07-13 00:21:51 +0000
+++ breezy/builtins.py	2018-07-14 19:37:12 +0000
@@ -84,6 +84,7 @@
     )
 from .sixish import (
     BytesIO,
+    PY3,
     text_type,
     viewitems,
     viewvalues,
@@ -1581,7 +1582,7 @@
                 else:
                     prefix = " "
                 self.outf.write("%s %s\n" % (
-                    prefix, name.encode(self.outf.encoding)))
+                    prefix, (name if PY3 else name.encode(self.outf.encoding))))
 
 
 class cmd_checkout(Command):
@@ -5461,7 +5462,7 @@
         uncommit(b, tree=tree, dry_run=dry_run, verbose=verbose,
                  revno=revno, local=local, keep_tags=keep_tags)
         self.outf.write(gettext('You can restore the old tip by running:\n'
-             '  brz pull . -r revid:%s\n') % last_rev_id)
+             '  brz pull . -r revid:%s\n') % last_rev_id.decode('utf-8'))
 
 
 class cmd_break_lock(Command):

=== modified file 'breezy/bzr/smart/vfs.py'
--- breezy/bzr/smart/vfs.py	2018-05-13 02:18:13 +0000
+++ breezy/bzr/smart/vfs.py	2018-07-14 19:37:12 +0000
@@ -126,7 +126,7 @@
             relpath += b'/'
         relpath = self.translate_client_path(relpath)
         filenames = self._backing_transport.list_dir(relpath)
-        return request.SuccessfulSmartServerResponse((b'names',) + tuple(filenames))
+        return request.SuccessfulSmartServerResponse((b'names',) + tuple([filename.encode('utf-8') for filename in filenames]))
 
 
 class MkdirRequest(VfsRequest):

=== modified file 'breezy/diff.py'
--- breezy/diff.py	2018-07-11 21:06:20 +0000
+++ breezy/diff.py	2018-07-14 19:37:12 +0000
@@ -757,6 +757,7 @@
             else:
                 raise
         self.to_file.write(proc.stdout.read())
+        proc.stdout.close()
         return proc.wait()
 
     def _try_symlink_root(self, tree, prefix):

=== modified file 'breezy/log.py'
--- breezy/log.py	2018-07-12 08:47:57 +0000
+++ breezy/log.py	2018-07-14 19:37:12 +0000
@@ -759,6 +759,8 @@
                 # Oops, a ghost.
                 yield e.revision_id, None, None
                 break
+            except StopIteration:
+                break
             else:
                 yield revision_id, str(cur_revno) if cur_revno is not None else None, 0
                 if cur_revno is not None:

=== modified file 'breezy/plugins/fastimport/tests/test_commands.py'
--- breezy/plugins/fastimport/tests/test_commands.py	2018-07-03 23:54:50 +0000
+++ breezy/plugins/fastimport/tests/test_commands.py	2018-07-14 19:37:12 +0000
@@ -59,7 +59,7 @@
         self.assertIsNot(b"bla", stream.read())
 
 
-fast_export_baseline_data = b"""commit refs/heads/master
+fast_export_baseline_data = """commit refs/heads/master
 mark :1
 committer
 data 15
@@ -99,19 +99,19 @@
 
     def test_empty(self):
         self.make_branch_and_tree("br")
-        self.assertEquals(b"", self.run_bzr("fast-export br")[0])
+        self.assertEquals("", self.run_bzr("fast-export br")[0])
 
     def test_pointless(self):
         tree = self.make_branch_and_tree("br")
         tree.commit("pointless")
         data = self.run_bzr("fast-export br")[0]
-        self.assertTrue(data.startswith(b'commit refs/heads/master\nmark :1\ncommitter'))
+        self.assertTrue(data.startswith('commit refs/heads/master\nmark :1\ncommitter'))
 
     def test_file(self):
         tree = self.make_branch_and_tree("br")
         tree.commit("pointless")
         data = self.run_bzr("fast-export br br.fi")[0]
-        self.assertEquals(b"", data)
+        self.assertEquals("", data)
         try:
             self.assertPathExists("br.fi")
         except AttributeError: # bzr < 2.4
@@ -124,17 +124,17 @@
         rev_id = tree.branch.dotted_revno_to_revision_id((1,))
         tree.branch.tags.set_tag("goodTag", rev_id)
         tree.branch.tags.set_tag("bad Tag", rev_id)
-        
+
         # first check --no-rewrite-tag-names
         data = self.run_bzr("fast-export --plain --no-rewrite-tag-names br")[0]
-        self.assertNotEqual(-1, data.find(b"reset refs/tags/goodTag"))
-        self.assertEqual(data.find(b"reset refs/tags/"), data.rfind(b"reset refs/tags/"))
-        
+        self.assertNotEqual(-1, data.find("reset refs/tags/goodTag"))
+        self.assertEqual(data.find("reset refs/tags/"), data.rfind("reset refs/tags/"))
+
         # and now with --rewrite-tag-names
         data = self.run_bzr("fast-export --plain --rewrite-tag-names br")[0]
-        self.assertNotEqual(-1, data.find(b"reset refs/tags/goodTag"))
+        self.assertNotEqual(-1, data.find("reset refs/tags/goodTag"))
         # "bad Tag" should be exported as bad_Tag
-        self.assertNotEqual(-1, data.find(b"reset refs/tags/bad_Tag"))
+        self.assertNotEqual(-1, data.find("reset refs/tags/bad_Tag"))
 
     def test_no_tags(self):
         tree = self.make_branch_and_tree("br")
@@ -144,7 +144,7 @@
         tree.branch.tags.set_tag("someTag", rev_id)
 
         data = self.run_bzr("fast-export --plain --no-tags br")[0]
-        self.assertEqual(-1, data.find(b"reset refs/tags/someTag"))
+        self.assertEqual(-1, data.find("reset refs/tags/someTag"))
 
     def test_baseline_option(self):
         tree = self.make_branch_and_tree("bl")
@@ -184,7 +184,7 @@
         # This exports the baseline state at Revision 3,
         # followed by the deltas for 4 and 5
         data = self.run_bzr("fast-export --baseline -r 3.. bl")[0]
-        data = re.sub(b'committer.*', b'committer', data)
+        data = re.sub('committer.*', 'committer', data)
         self.assertEquals(fast_export_baseline_data, data)
 
         # Also confirm that --baseline with no args is identical to full export
@@ -208,7 +208,7 @@
     def test_empty(self):
         self.build_tree_contents([('empty.fi', b"")])
         self.make_branch_and_tree("br")
-        self.assertEquals(b"", self.run_bzr("fast-import empty.fi br")[0])
+        self.assertEquals("", self.run_bzr("fast-import empty.fi br")[0])
 
     def test_file(self):
         tree = self.make_branch_and_tree("br")
@@ -224,5 +224,5 @@
 data 15
 """)])
         self.make_branch_and_tree("br")
-        self.run_bzr_error([b'brz: ERROR: 4: Parse error: line 4: Command commit is missing section .*committer.*\n'], "fast-import empty.fi br")
+        self.run_bzr_error(['brz: ERROR: 4: Parse error: line 4: Command commit is missing section .*committer.*\n'], "fast-import empty.fi br")
 

=== modified file 'breezy/plugins/git/fetch.py'
--- breezy/plugins/git/fetch.py	2018-07-03 00:15:59 +0000
+++ breezy/plugins/git/fetch.py	2018-07-14 19:37:12 +0000
@@ -101,6 +101,9 @@
     :param blob: A git blob
     :return: Inventory delta for this file
     """
+    if not isinstance(path, bytes):
+        raise TypeError(path)
+    decoded_path = path.decode('utf-8')
     (base_mode, mode) = modes
     (base_hexsha, hexsha) = hexshas
     if mapping.is_special_file(path):
@@ -108,7 +111,7 @@
     if base_hexsha == hexsha and base_mode == mode:
         # If nothing has changed since the base revision, we're done
         return []
-    file_id = lookup_file_id(osutils.safe_unicode(path))
+    file_id = lookup_file_id(decoded_path)
     if stat.S_ISLNK(mode):
         cls = InventoryLink
     else:
@@ -117,14 +120,14 @@
     if ie.kind == "file":
         ie.executable = mode_is_executable(mode)
     if base_hexsha == hexsha and mode_kind(base_mode) == mode_kind(mode):
-        base_exec = base_bzr_tree.is_executable(path)
+        base_exec = base_bzr_tree.is_executable(decoded_path)
         if ie.kind == "symlink":
-            ie.symlink_target = base_bzr_tree.get_symlink_target(path)
+            ie.symlink_target = base_bzr_tree.get_symlink_target(decoded_path)
         else:
-            ie.text_size = base_bzr_tree.get_file_size(path)
-            ie.text_sha1 = base_bzr_tree.get_file_sha1(path)
+            ie.text_size = base_bzr_tree.get_file_size(decoded_path)
+            ie.text_sha1 = base_bzr_tree.get_file_sha1(decoded_path)
         if ie.kind == "symlink" or ie.executable == base_exec:
-            ie.revision = base_bzr_tree.get_file_revision(path)
+            ie.revision = base_bzr_tree.get_file_revision(decoded_path)
         else:
             blob = lookup_object(hexsha)
     else:
@@ -139,9 +142,10 @@
     parent_keys = []
     for ptree in parent_bzr_trees:
         try:
-            ppath = ptree.id2path(file_id)
-        except errors.NoSuchId:
+            ppaths = base_bzr_tree.find_related_paths_across_trees([decoded_path], trees=[ptree])
+        except errors.PathsNotVersionedError:
             continue
+        ppath = ppaths.pop()
         pkind = ptree.kind(ppath, file_id)
         if (pkind == ie.kind and
             ((pkind == "symlink" and ptree.get_symlink_target(ppath, file_id) == ie.symlink_target) or
@@ -167,14 +171,13 @@
                 tuple(parent_keys), ie.text_sha1, chunks)])
     invdelta = []
     if base_hexsha is not None:
-        old_path = path.decode("utf-8") # Renames are not supported yet
+        old_path = decoded_path # Renames are not supported yet
         if stat.S_ISDIR(base_mode):
             invdelta.extend(remove_disappeared_children(base_bzr_tree, old_path,
                 lookup_object(base_hexsha), [], lookup_object))
     else:
         old_path = None
-    new_path = path.decode("utf-8")
-    invdelta.append((old_path, new_path, file_id, ie))
+    invdelta.append((old_path, decoded_path, file_id, ie))
     if base_hexsha != hexsha:
         store_updater.add_object(blob, (ie.file_id, ie.revision), path)
     return invdelta

=== modified file 'breezy/plugins/git/send.py'
--- breezy/plugins/git/send.py	2018-05-13 22:54:28 +0000
+++ breezy/plugins/git/send.py	2018-07-14 19:37:12 +0000
@@ -75,7 +75,8 @@
             return object_mode(kind, executable)
         def get_blob(present, tree, path):
             if present:
-                return Blob.from_string(tree.get_file(path).read())
+                with tree.get_file(path) as f:
+                    return Blob.from_string(f.read())
             else:
                 return None
         trees = (self.old_tree, self.new_tree)

=== modified file 'breezy/plugins/git/tests/test_blackbox.py'
--- breezy/plugins/git/tests/test_blackbox.py	2018-07-03 01:42:53 +0000
+++ breezy/plugins/git/tests/test_blackbox.py	2018-07-14 19:37:12 +0000
@@ -54,18 +54,18 @@
         dir = ControlDir.open(self.test_dir)
         dir.create_branch()
         output, error = self.run_bzr(['nick'])
-        self.assertEqual(b"master\n", output)
+        self.assertEqual("master\n", output)
 
     def test_branches(self):
         self.simple_commit()
         output, error = self.run_bzr(['branches'])
-        self.assertEqual(b"* master\n", output)
+        self.assertEqual("* master\n", output)
 
     def test_info(self):
         self.simple_commit()
         output, error = self.run_bzr(['info'])
-        self.assertEqual(error, b'')
-        self.assertTrue(b"Standalone tree (format: git)" in output)
+        self.assertEqual(error, '')
+        self.assertTrue("Standalone tree (format: git)" in output)
 
     def test_branch(self):
         os.mkdir("gitbranch")
@@ -79,8 +79,8 @@
 
         output, error = self.run_bzr(['branch', 'gitbranch', 'bzrbranch'])
         self.assertTrue(
-            (error == b'Branched 1 revision(s).\n') or
-            (error == b'Branched 1 revision.\n'),
+            (error == 'Branched 1 revision(s).\n') or
+            (error == 'Branched 1 revision.\n'),
             error)
 
     def test_checkout(self):
@@ -95,15 +95,15 @@
 
         output, error = self.run_bzr(['checkout', 'gitbranch', 'bzrbranch'])
         self.assertEqual(error,
-                b'Fetching from Git to Bazaar repository. '
-                b'For better performance, fetch into a Git repository.\n')
-        self.assertEqual(output, b'')
+                'Fetching from Git to Bazaar repository. '
+                'For better performance, fetch into a Git repository.\n')
+        self.assertEqual(output, '')
 
     def test_branch_ls(self):
         self.simple_commit()
         output, error = self.run_bzr(['ls', '-r-1'])
-        self.assertEqual(error, b'')
-        self.assertEqual(output, b"a\n")
+        self.assertEqual(error, '')
+        self.assertEqual(output, "a\n")
 
     def test_init(self):
         self.run_bzr("init --format=git repo")
@@ -112,11 +112,11 @@
         self.simple_commit()
 
         output, error = self.run_bzr(['info', '-v'])
-        self.assertEqual(error, b'')
-        self.assertTrue(b"Standalone tree (format: git)" in output)
-        self.assertTrue(b"control: Local Git Repository" in output)
-        self.assertTrue(b"branch: Local Git Branch" in output)
-        self.assertTrue(b"repository: Git Repository" in output)
+        self.assertEqual(error, '')
+        self.assertTrue("Standalone tree (format: git)" in output)
+        self.assertTrue("control: Local Git Repository" in output)
+        self.assertTrue("branch: Local Git Branch" in output)
+        self.assertTrue("repository: Git Repository" in output)
 
     def test_push_roundtripping(self):
         self.knownFailure("roundtripping is not yet supported")
@@ -136,10 +136,10 @@
 
         # Check that bzr log does not fail and includes the revision.
         output, error = self.run_bzr(['log'])
-        self.assertEqual(error, b'')
+        self.assertEqual(error, '')
         self.assertTrue(
-            b'<The commit message>' in output,
-            b"Commit message was not found in output:\n%s" % (output,))
+            '<The commit message>' in output,
+            "Commit message was not found in output:\n%s" % (output,))
 
     def test_log_verbose(self):
         # Smoke test for "bzr log -v" in a git repository.
@@ -153,8 +153,8 @@
         git_repo.refs[b"refs/tags/foo"] = commit_sha1
 
         output, error = self.run_bzr(['tags'])
-        self.assertEqual(error, b'')
-        self.assertEqual(output, b"foo                  1\n")
+        self.assertEqual(error, '')
+        self.assertEqual(output, "foo                  1\n")
 
     def test_tag(self):
         self.simple_commit()
@@ -163,28 +163,28 @@
 
         # bzr <= 2.2 emits this message in the output stream
         # bzr => 2.3 emits this message in the error stream
-        self.assertEqual(error + output, b'Created tag bar.\n')
+        self.assertEqual(error + output, 'Created tag bar.\n')
 
     def test_init_repo(self):
         output, error = self.run_bzr(["init", "--format=git", "bla.git"])
-        self.assertEqual(error, b'')
-        self.assertEqual(output, b'Created a standalone tree (format: git)\n')
+        self.assertEqual(error, '')
+        self.assertEqual(output, 'Created a standalone tree (format: git)\n')
 
     def test_diff_format(self):
         tree = self.make_branch_and_tree('.')
         self.build_tree(['a'])
         tree.add(['a'])
         output, error = self.run_bzr(['diff', '--format=git'], retcode=1)
-        self.assertEqual(error, b'')
+        self.assertEqual(error, '')
         self.assertEqual(output,
-            b'diff --git /dev/null b/a\n'
-            b'old mode 0\n'
-            b'new mode 100644\n'
-            b'index 0000000..c197bd8 100644\n'
-            b'--- /dev/null\n'
-            b'+++ b/a\n'
-            b'@@ -0,0 +1 @@\n'
-            b'+contents of a\n')
+            'diff --git /dev/null b/a\n'
+            'old mode 0\n'
+            'new mode 100644\n'
+            'index 0000000..c197bd8 100644\n'
+            '--- /dev/null\n'
+            '+++ b/a\n'
+            '@@ -0,0 +1 @@\n'
+            '+contents of a\n')
 
     def test_git_import_uncolocated(self):
         r = GitRepo.init("a", mkdir=True)
@@ -249,10 +249,10 @@
         cid = r.do_commit(ref=b"refs/heads/abranch", committer=b"Joe <[e-mail]>", message=b"Dummy")
         r[b"refs/tags/atag"] = cid
         (stdout, stderr) = self.run_bzr(["git-refs", "a"])
-        self.assertEqual(stderr, b"")
+        self.assertEqual(stderr, "")
         self.assertEqual(stdout,
-            b'refs/heads/abranch -> ' + cid + b'\n'
-            b'refs/tags/atag -> ' + cid + b'\n')
+            'refs/heads/abranch -> ' + cid.decode('ascii') + '\n'
+            'refs/tags/atag -> ' + cid.decode('ascii') + '\n')
 
     def test_git_refs_from_bzr(self):
         tree = self.make_branch_and_tree('a')
@@ -261,9 +261,9 @@
         revid = tree.commit(committer=b"Joe <[e-mail]>", message=b"Dummy")
         tree.branch.tags.set_tag("atag", revid)
         (stdout, stderr) = self.run_bzr(["git-refs", "a"])
-        self.assertEqual(stderr, b"")
-        self.assertTrue(b"refs/tags/atag -> " in stdout)
-        self.assertTrue(b"HEAD -> " in stdout)
+        self.assertEqual(stderr, "")
+        self.assertTrue("refs/tags/atag -> " in stdout)
+        self.assertTrue("HEAD -> " in stdout)
 
     def test_check(self):
         r = GitRepo.init("gitr", mkdir=True)
@@ -272,8 +272,8 @@
         r.do_commit(b"message", committer=b"Somebody <[e-mail]>")
         out, err = self.run_bzr(["check", "gitr"])
         self.maxDiff = None
-        self.assertEqual(out, b'')
-        self.assertTrue(err.endswith, b'3 objects\n')
+        self.assertEqual(out, '')
+        self.assertTrue(err.endswith, '3 objects\n')
 
 
 class ShallowTests(ExternalBase):
@@ -293,36 +293,36 @@
     def test_log_shallow(self):
         # Check that bzr log does not fail and includes the revision.
         output, error = self.run_bzr(['log', 'gitr'], retcode=3)
-        self.assertEqual(error, b'brz: ERROR: Further revision history missing.\n')
+        self.assertEqual(error, 'brz: ERROR: Further revision history missing.\n')
         self.assertEqual(output,
-                b'------------------------------------------------------------\n'
-                b'revision-id: git-v1:' + self.repo.head() + b'\n'
-                b'git commit: ' + self.repo.head() + b'\n'
-                b'committer: Somebody <[e-mail]>\n'
-                b'timestamp: Mon 2018-05-14 20:36:05 +0000\n'
-                b'message:\n'
-                b'  message\n')
+                '------------------------------------------------------------\n'
+                'revision-id: git-v1:' + self.repo.head().decode('ascii') + '\n'
+                'git commit: ' + self.repo.head().decode('ascii') + '\n'
+                'committer: Somebody <[e-mail]>\n'
+                'timestamp: Mon 2018-05-14 20:36:05 +0000\n'
+                'message:\n'
+                '  message\n')
 
     def test_version_info_rio(self):
         output, error = self.run_bzr(['version-info', '--rio', 'gitr'])
-        self.assertEqual(error, b'')
-        self.assertNotIn(b'revno:', output)
+        self.assertEqual(error, '')
+        self.assertNotIn('revno:', output)
 
     def test_version_info_python(self):
         output, error = self.run_bzr(['version-info', '--python', 'gitr'])
-        self.assertEqual(error, b'')
-        self.assertNotIn(b'revno:', output)
+        self.assertEqual(error, '')
+        self.assertNotIn('revno:', output)
 
     def test_version_info_custom_with_revno(self):
         output, error = self.run_bzr(
                 ['version-info', '--custom',
                  '--template=VERSION_INFO r{revno})\n', 'gitr'], retcode=3)
-        self.assertEqual(error, b'brz: ERROR: Variable {revno} is not available.\n')
-        self.assertEqual(output, b'VERSION_INFO r')
+        self.assertEqual(error, 'brz: ERROR: Variable {revno} is not available.\n')
+        self.assertEqual(output, 'VERSION_INFO r')
 
     def test_version_info_custom_without_revno(self):
         output, error = self.run_bzr(
                 ['version-info', '--custom', '--template=VERSION_INFO \n',
                  'gitr'])
-        self.assertEqual(error, b'')
-        self.assertEqual(output, b'VERSION_INFO \n')
+        self.assertEqual(error, '')
+        self.assertEqual(output, 'VERSION_INFO \n')

=== modified file 'breezy/plugins/git/transportgit.py'
--- breezy/plugins/git/transportgit.py	2018-07-03 01:42:53 +0000
+++ breezy/plugins/git/transportgit.py	2018-07-14 19:37:12 +0000
@@ -220,7 +220,7 @@
             f = transport.get(name)
         except NoSuchFile:
             return None
-        try:
+        with f:
             header = f.read(len(SYMREF))
             if header == SYMREF:
                 # Read only the first line
@@ -228,8 +228,6 @@
             else:
                 # Read only the first 40 bytes
                 return header + f.read(40-len(SYMREF))
-        finally:
-            f.close()
 
     def _remove_packed_ref(self, name):
         if self._packed_refs is None:
@@ -485,7 +483,8 @@
     def get_config(self):
         from dulwich.config import ConfigFile
         try:
-            return ConfigFile.from_file(self._controltransport.get('config'))
+            with self._controltransport.get('config') as f:
+                return ConfigFile.from_file(f)
         except NoSuchFile:
             return ConfigFile()
 
@@ -568,16 +567,14 @@
         except NoSuchFile:
             return []
         ret = []
-        try:
+        with f:
             for l in f.read().splitlines():
-                if l[0] == "#":
+                if l[0] == b"#":
                     continue
                 if os.path.isabs(l):
                     continue
                 ret.append(l)
             return ret
-        finally:
-            f.close()
 
     @property
     def packs(self):
@@ -596,15 +593,16 @@
         except NoSuchFile:
             return self.pack_transport.list_dir(".")
         else:
-            ret = []
-            for line in f.read().splitlines():
-                if not line:
-                    continue
-                (kind, name) = line.split(" ", 1)
-                if kind != "P":
-                    continue
-                ret.append(name)
-            return ret
+            with f:
+                ret = []
+                for line in f.read().splitlines():
+                    if not line:
+                        continue
+                    (kind, name) = line.split(b" ", 1)
+                    if kind != b"P":
+                        continue
+                    ret.append(name)
+                return ret
 
     def _remove_pack(self, pack):
         self.pack_transport.delete(os.path.basename(pack.index.path))
@@ -646,7 +644,8 @@
     def _get_loose_object(self, sha):
         path = osutils.joinpath(self._split_loose_object(sha))
         try:
-            return ShaFile.from_file(self.transport.get(path))
+            with self.transport.get(path) as f:
+                return ShaFile.from_file(f)
         except NoSuchFile:
             return None
 
@@ -676,7 +675,7 @@
         f.seek(0)
         p = PackData("", f, len(f.getvalue()))
         entries = p.sorted_entries()
-        basename = "pack-%s" % iter_sha1(entry[0] for entry in entries)
+        basename = "pack-%s" % iter_sha1(entry[0] for entry in entries).decode('ascii')
         p._filename = basename + ".pack"
         f.seek(0)
         self.pack_transport.put_file(basename + ".pack", f)
@@ -709,14 +708,14 @@
         pack_sha = p.index.objects_sha1()
 
         datafile = self.pack_transport.open_write_stream(
-                "pack-%s.pack" % pack_sha)
+                "pack-%s.pack" % pack_sha.decode('ascii'))
         try:
             entries, data_sum = write_pack_objects(datafile, p.pack_tuples())
         finally:
             datafile.close()
         entries = sorted([(k, v[0], v[1]) for (k, v) in entries.items()])
         idxfile = self.pack_transport.open_write_stream(
-            "pack-%s.idx" % pack_sha)
+            "pack-%s.idx" % pack_sha.decode('ascii'))
         try:
             write_pack_index_v2(idxfile, entries, data_sum)
         finally:

=== modified file 'breezy/plugins/git/tree.py'
--- breezy/plugins/git/tree.py	2018-07-11 21:04:18 +0000
+++ breezy/plugins/git/tree.py	2018-07-14 19:37:12 +0000
@@ -946,7 +946,8 @@
                 file = BytesIO()
                 stat_val = os.stat_result(
                     (stat.S_IFREG | 0o644, 0, 0, 0, 0, 0, 0, 0, 0, 0))
-            blob.set_raw_string(file.read())
+            with file:
+                blob.set_raw_string(file.read())
             # Add object to the repository if it didn't exist yet
             if not blob.id in self.store:
                 self.store.add_object(blob)

=== modified file 'breezy/plugins/grep/test_grep.py'
--- breezy/plugins/grep/test_grep.py	2018-07-01 15:42:26 +0000
+++ breezy/plugins/grep/test_grep.py	2018-07-14 19:37:12 +0000
@@ -89,21 +89,21 @@
         self._mk_unknown_file('file0.txt')
 
         out, err = self.run_bzr(['grep', 'line1', 'file0.txt'])
-        self.assertContainsRe(out, b"file0.txt:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 2) # finds line1 and line10
 
         out, err = self.run_bzr(['grep', 'line\\d+', 'file0.txt'])
-        self.assertContainsRe(out, b"file0.txt:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 10)
 
         # unknown file is not grepped unless explicitely specified
         out, err = self.run_bzr(['grep', 'line1'])
-        self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 0)
 
         # unknown file is not grepped unless explicitely specified
         out, err = self.run_bzr(['grep', 'line1$'])
-        self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 0)
 
     def test_ver_basic_file(self):
@@ -115,16 +115,16 @@
         self._mk_versioned_file('file0.txt')
 
         out, err = self.run_bzr(['grep', '-r', '1', 'line1', 'file0.txt'])
-        self.assertContainsRe(out, b"file0.txt~1:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~1:line1", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 2) # finds line1 and line10
 
         out, err = self.run_bzr(['grep', '-r', '1', 'line[0-9]$', 'file0.txt'])
-        self.assertContainsRe(out, b"file0.txt~1:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~1:line1", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 9)
 
         # finds all the lines
         out, err = self.run_bzr(['grep', '-r', '1', 'line[0-9]', 'file0.txt'])
-        self.assertContainsRe(out, b"file0.txt~1:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~1:line1", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 10)
 
     def test_wtree_basic_file(self):
@@ -137,19 +137,19 @@
         self._update_file('file0.txt', 'ABC\n', checkin=False)
 
         out, err = self.run_bzr(['grep', 'ABC', 'file0.txt'])
-        self.assertContainsRe(out, b"file0.txt:ABC", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt:ABC", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 1)
 
         out, err = self.run_bzr(['grep', '[A-Z]{3}', 'file0.txt'])
-        self.assertContainsRe(out, b"file0.txt:ABC", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt:ABC", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 1)
 
         out, err = self.run_bzr(['grep', '-r', 'last:1', 'ABC', 'file0.txt'])
-        self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 0)
 
         out, err = self.run_bzr(['grep', '-r', 'last:1', '[A-Z]{3}', 'file0.txt'])
-        self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 0)
 
     def test_ver_basic_include(self):
@@ -164,33 +164,33 @@
 
         out, err = self.run_bzr(['grep', '-r', 'last:1',
             '--include', '*.aa', '--include', '*.bb', 'line1'])
-        self.assertContainsRe(out, b"file0.aa~.:line1", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"file0.bb~.:line1", flags=TestGrep._reflags)
-        self.assertNotContainsRe(out, b"file0.cc", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.aa~.:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.bb~.:line1", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
         # two lines each (line1, line10) from file0.aa and file0.bb
         self.assertEqual(len(out.splitlines()), 4)
 
         out, err = self.run_bzr(['grep', '-r', 'last:1',
             '--include', '*.aa', '--include', '*.bb', 'line1$'])
-        self.assertContainsRe(out, b"file0.aa~.:line1", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"file0.bb~.:line1", flags=TestGrep._reflags)
-        self.assertNotContainsRe(out, b"file0.cc", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.aa~.:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.bb~.:line1", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
         # one lines each (line1) from file0.aa and file0.bb
         self.assertEqual(len(out.splitlines()), 2)
 
         out, err = self.run_bzr(['grep', '-r', 'last:1',
             '-I', '*.aa', '-I', '*.bb', 'line1'])
-        self.assertContainsRe(out, b"file0.aa~.:line1", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"file0.bb~.:line1", flags=TestGrep._reflags)
-        self.assertNotContainsRe(out, b"file0.cc", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.aa~.:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.bb~.:line1", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
         # two lines each (line1, line10) from file0.aa and file0.bb
         self.assertEqual(len(out.splitlines()), 4)
 
         out, err = self.run_bzr(['grep', '-r', 'last:1',
             '-I', '*.aa', '-I', '*.bb', 'line1$'])
-        self.assertContainsRe(out, b"file0.aa~.:line1", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"file0.bb~.:line1", flags=TestGrep._reflags)
-        self.assertNotContainsRe(out, b"file0.cc", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.aa~.:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.bb~.:line1", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
         # one lines each (line1) from file0.aa and file0.bb
         self.assertEqual(len(out.splitlines()), 2)
 
@@ -206,17 +206,17 @@
 
         out, err = self.run_bzr(['grep', '--include', '*.aa',
             '--include', '*.bb', 'line1'])
-        self.assertContainsRe(out, b"file0.aa:line1", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"file0.bb:line1", flags=TestGrep._reflags)
-        self.assertNotContainsRe(out, b"file0.cc", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.aa:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.bb:line1", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
         # two lines each (line1, line10) from file0.aa and file0.bb
         self.assertEqual(len(out.splitlines()), 4)
 
         out, err = self.run_bzr(['grep', '--include', '*.aa',
             '--include', '*.bb', 'line1$'])
-        self.assertContainsRe(out, b"file0.aa:line1", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"file0.bb:line1", flags=TestGrep._reflags)
-        self.assertNotContainsRe(out, b"file0.cc", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.aa:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.bb:line1", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
         # one line each (line1) from file0.aa and file0.bb
         self.assertEqual(len(out.splitlines()), 2)
 
@@ -232,27 +232,27 @@
 
         out, err = self.run_bzr(['grep', '-r', 'last:1',
             '--exclude', '*.cc', 'line1'])
-        self.assertContainsRe(out, b"file0.aa~.:line1$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"file0.bb~.:line1$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"file0.aa~.:line10", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"file0.bb~.:line10", flags=TestGrep._reflags)
-        self.assertNotContainsRe(out, b"file0.cc", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.aa~.:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.bb~.:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.aa~.:line10", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.bb~.:line10", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
         # two lines each (line1, line10) from file0.aa and file0.bb
         self.assertEqual(len(out.splitlines()), 4)
 
         out, err = self.run_bzr(['grep', '-r', 'last:1',
             '--exclude', '*.cc', 'line1$'])
-        self.assertContainsRe(out, b"file0.aa~.:line1", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"file0.bb~.:line1", flags=TestGrep._reflags)
-        self.assertNotContainsRe(out, b"file0.cc", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.aa~.:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.bb~.:line1", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
         # one line each (line1) from file0.aa and file0.bb
         self.assertEqual(len(out.splitlines()), 2)
 
         out, err = self.run_bzr(['grep', '-r', 'last:1',
             '-X', '*.cc', 'line1'])
-        self.assertContainsRe(out, b"file0.aa~.:line1", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"file0.bb~.:line1", flags=TestGrep._reflags)
-        self.assertNotContainsRe(out, b"file0.cc", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.aa~.:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.bb~.:line1", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
         # two lines each (line1, line10) from file0.aa and file0.bb
         self.assertEqual(len(out.splitlines()), 4)
 
@@ -267,16 +267,16 @@
         self._mk_versioned_file('file0.cc')
 
         out, err = self.run_bzr(['grep', '--exclude', '*.cc', 'line1'])
-        self.assertContainsRe(out, b"file0.aa:line1", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"file0.bb:line1", flags=TestGrep._reflags)
-        self.assertNotContainsRe(out, b"file0.cc", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.aa:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.bb:line1", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
         # two lines each (line1, line10) from file0.aa and file0.bb
         self.assertEqual(len(out.splitlines()), 4)
 
         out, err = self.run_bzr(['grep', '--exclude', '*.cc', 'lin.1$'])
-        self.assertContainsRe(out, b"file0.aa:line1", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"file0.bb:line1", flags=TestGrep._reflags)
-        self.assertNotContainsRe(out, b"file0.cc", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.aa:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.bb:line1", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.cc", flags=TestGrep._reflags)
         # one line each (line1) from file0.aa and file0.bb
         self.assertEqual(len(out.splitlines()), 2)
 
@@ -291,21 +291,21 @@
         self._mk_versioned_file('file2.txt', total_lines=2)
 
         out, err = self.run_bzr(['grep', '-r', 'last:1', 'line[1-2]$'])
-        self.assertContainsRe(out, b"file0.txt~.:line1", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"file0.txt~.:line2", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"file1.txt~.:line1", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"file1.txt~.:line2", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"file2.txt~.:line1", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"file2.txt~.:line2", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~.:line2", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file1.txt~.:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file1.txt~.:line2", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file2.txt~.:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file2.txt~.:line2", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 6)
 
         out, err = self.run_bzr(['grep', '-r', 'last:1', 'line'])
-        self.assertContainsRe(out, b"file0.txt~.:line1", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"file0.txt~.:line2", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"file1.txt~.:line1", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"file1.txt~.:line2", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"file2.txt~.:line1", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"file2.txt~.:line2", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~.:line2", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file1.txt~.:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file1.txt~.:line2", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file2.txt~.:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file2.txt~.:line2", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 6)
 
     def test_multiple_wtree_files(self):
@@ -324,33 +324,33 @@
         out, err = self.run_bzr(['grep', 'HELLO',
             'file0.txt', 'file1.txt', 'file2.txt'])
 
-        self.assertContainsRe(out, b"file0.txt:HELLO", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"file1.txt:HELLO", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"file2.txt:HELLO", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt:HELLO", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file1.txt:HELLO", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file2.txt:HELLO", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 3)
 
         out, err = self.run_bzr(['grep', 'HELLO', '-r', 'last:1',
             'file0.txt', 'file1.txt', 'file2.txt'])
 
-        self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"file1.txt~.:HELLO", flags=TestGrep._reflags)
-        self.assertNotContainsRe(out, b"file2.txt", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file1.txt~.:HELLO", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file2.txt", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 1)
 
         out, err = self.run_bzr(['grep', 'HE..O',
             'file0.txt', 'file1.txt', 'file2.txt'])
 
-        self.assertContainsRe(out, b"file0.txt:HELLO", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"file1.txt:HELLO", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"file2.txt:HELLO", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt:HELLO", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file1.txt:HELLO", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file2.txt:HELLO", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 3)
 
         out, err = self.run_bzr(['grep', 'HE..O', '-r', 'last:1',
             'file0.txt', 'file1.txt', 'file2.txt'])
 
-        self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"file1.txt~.:HELLO", flags=TestGrep._reflags)
-        self.assertNotContainsRe(out, b"file2.txt", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file1.txt~.:HELLO", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file2.txt", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 1)
 
     def test_ver_null_option(self):
@@ -408,11 +408,11 @@
         self._mk_versioned_file('dir0/file0.txt')
 
         out, err = self.run_bzr(['grep', '-r', 'last:1', '--no-recursive', 'line1'])
-        self.assertNotContainsRe(out, b"file0.txt~.:line1", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 0)
 
         out, err = self.run_bzr(['grep', '-r', 'last:1', '--no-recursive', 'line1$'])
-        self.assertNotContainsRe(out, b"file0.txt~.:line1", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 0)
 
     def test_wtree_file_in_dir_no_recursive(self):
@@ -425,11 +425,11 @@
         self._mk_versioned_file('dir0/file0.txt')
 
         out, err = self.run_bzr(['grep', '--no-recursive', 'line1'])
-        self.assertNotContainsRe(out, b"file0.txt:line1", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 0)
 
         out, err = self.run_bzr(['grep', '--no-recursive', 'lin.1'])
-        self.assertNotContainsRe(out, b"file0.txt:line1", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 0)
 
     def test_versioned_file_in_dir_recurse(self):
@@ -442,12 +442,12 @@
         self._mk_versioned_file('dir0/file0.txt')
 
         out, err = self.run_bzr(['grep', '-r', '-1', '.i.e1'])
-        self.assertContainsRe(out, b"^dir0/file0.txt~.:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file0.txt~.:line1", flags=TestGrep._reflags)
         # find line1 and line10
         self.assertEqual(len(out.splitlines()), 2)
 
         out, err = self.run_bzr(['grep', '-r', '-1', 'line1'])
-        self.assertContainsRe(out, b"^dir0/file0.txt~.:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file0.txt~.:line1", flags=TestGrep._reflags)
         # find line1 and line10
         self.assertEqual(len(out.splitlines()), 2)
 
@@ -461,12 +461,12 @@
         self._mk_versioned_file('dir0/file0.txt')
 
         out, err = self.run_bzr(['grep', 'line1'])
-        self.assertContainsRe(out, b"^dir0/file0.txt:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file0.txt:line1", flags=TestGrep._reflags)
         # find line1 and line10
         self.assertEqual(len(out.splitlines()), 2)
 
         out, err = self.run_bzr(['grep', 'lin.1'])
-        self.assertContainsRe(out, b"^dir0/file0.txt:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file0.txt:line1", flags=TestGrep._reflags)
         # find line1 and line10
         self.assertEqual(len(out.splitlines()), 2)
 
@@ -481,12 +481,12 @@
         os.chdir('dir0')
 
         out, err = self.run_bzr(['grep', '-r', 'last:1', 'line1'])
-        self.assertContainsRe(out, b"^file0.txt~.:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file0.txt~.:line1", flags=TestGrep._reflags)
         # finds line1 and line10
         self.assertEqual(len(out.splitlines()), 2)
 
         out, err = self.run_bzr(['grep', '-r', 'last:1', '.i.e1'])
-        self.assertContainsRe(out, b"^file0.txt~.:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file0.txt~.:line1", flags=TestGrep._reflags)
         # finds line1 and line10
         self.assertEqual(len(out.splitlines()), 2)
 
@@ -505,39 +505,39 @@
 
         out, err = self.run_bzr(['grep', '-r', 'last:1',
             '--include', '*.aa', 'line1'])
-        self.assertContainsRe(out, b"^file1.aa~5:line1$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^file1.aa~5:line10$", flags=TestGrep._reflags)
-        self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.aa~5:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.aa~5:line10$", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
         # finds line1 and line10
         self.assertEqual(len(out.splitlines()), 2)
 
         out, err = self.run_bzr(['grep', '-r', 'last:2..last:1',
             '--include', '*.aa', 'line1'])
-        self.assertContainsRe(out, b"^file1.aa~4:line1$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^file1.aa~4:line10$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^file1.aa~5:line1$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^file1.aa~5:line10$", flags=TestGrep._reflags)
-        self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.aa~4:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.aa~4:line10$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.aa~5:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.aa~5:line10$", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
         # finds line1 and line10 over two revisions
         self.assertEqual(len(out.splitlines()), 4)
 
         out, err = self.run_bzr(['grep', '-r', 'last:1',
             '--include', '*.aa', 'lin.1'])
-        self.assertContainsRe(out, b"^file1.aa~5:line1$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^file1.aa~5:line10$", flags=TestGrep._reflags)
-        self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.aa~5:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.aa~5:line10$", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
         # finds line1 and line10
         self.assertEqual(len(out.splitlines()), 2)
 
         out, err = self.run_bzr(['grep', '-r', 'last:3..last:1',
             '--include', '*.aa', 'lin.1'])
-        self.assertContainsRe(out, b"^file1.aa~3:line1$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^file1.aa~4:line1$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^file1.aa~5:line1$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^file1.aa~3:line10$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^file1.aa~4:line10$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^file1.aa~5:line10$", flags=TestGrep._reflags)
-        self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.aa~3:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.aa~4:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.aa~5:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.aa~3:line10$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.aa~4:line10$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.aa~5:line10$", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
         # finds line1 and line10 over 3 revisions
         self.assertEqual(len(out.splitlines()), 6)
 
@@ -554,15 +554,15 @@
 
         out, err = self.run_bzr(['grep', '-r', 'last:1',
             '--exclude', '*.txt', 'line1'])
-        self.assertContainsRe(out, b"^file1.aa~.:line1", flags=TestGrep._reflags)
-        self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.aa~.:line1", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
         # finds line1 and line10
         self.assertEqual(len(out.splitlines()), 2)
 
         out, err = self.run_bzr(['grep', '-r', 'last:1',
             '--exclude', '*.txt', 'l[a-z]ne1'])
-        self.assertContainsRe(out, b"^file1.aa~.:line1", flags=TestGrep._reflags)
-        self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.aa~.:line1", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
         # finds line1 and line10
         self.assertEqual(len(out.splitlines()), 2)
 
@@ -577,12 +577,12 @@
         os.chdir('dir0')
 
         out, err = self.run_bzr(['grep', 'line1'])
-        self.assertContainsRe(out, b"^file0.txt:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file0.txt:line1", flags=TestGrep._reflags)
         # finds line1 and line10
         self.assertEqual(len(out.splitlines()), 2)
 
         out, err = self.run_bzr(['grep', 'l[aeiou]ne1'])
-        self.assertContainsRe(out, b"^file0.txt:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file0.txt:line1", flags=TestGrep._reflags)
         # finds line1 and line10
         self.assertEqual(len(out.splitlines()), 2)
 
@@ -598,13 +598,13 @@
         os.chdir('dir0')
 
         out, err = self.run_bzr(['grep', '--include', '*.aa', 'line1'])
-        self.assertContainsRe(out, b"^file1.aa:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.aa:line1", flags=TestGrep._reflags)
         # finds line1 and line10
         self.assertEqual(len(out.splitlines()), 2)
 
         out, err = self.run_bzr(['grep', '--include', '*.aa', 'l[ixn]ne1'])
-        self.assertContainsRe(out, b"^file1.aa:line1", flags=TestGrep._reflags)
-        self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.aa:line1", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
         # finds line1 and line10
         self.assertEqual(len(out.splitlines()), 2)
 
@@ -620,16 +620,16 @@
         os.chdir('dir0')
 
         out, err = self.run_bzr(['grep', '--exclude', '*.txt', 'li.e1'])
-        self.assertContainsRe(out, b"^file1.aa:line1$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^file1.aa:line10$", flags=TestGrep._reflags)
-        self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.aa:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.aa:line10$", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
         # finds line1 and line10
         self.assertEqual(len(out.splitlines()), 2)
 
         out, err = self.run_bzr(['grep', '--exclude', '*.txt', 'line1'])
-        self.assertContainsRe(out, b"^file1.aa:line1$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^file1.aa:line10$", flags=TestGrep._reflags)
-        self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.aa:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.aa:line10$", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
         # finds line1 and line10
         self.assertEqual(len(out.splitlines()), 2)
 
@@ -651,21 +651,21 @@
 
         out, err = self.run_bzr(['grep', '-r', 'last:1',
             '--include', '*.aa', '--include', '*.bb', 'l..e1'])
-        self.assertContainsRe(out, b"^dir0/file0.aa~.:line1$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^dir1/file1.bb~.:line1$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^dir0/file0.aa~.:line10$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^dir1/file1.bb~.:line10$", flags=TestGrep._reflags)
-        self.assertNotContainsRe(out, b"file1.cc", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file0.aa~.:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir1/file1.bb~.:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file0.aa~.:line10$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir1/file1.bb~.:line10$", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
         # finds line1 and line10
         self.assertEqual(len(out.splitlines()), 4)
 
         out, err = self.run_bzr(['grep', '-r', 'last:1',
             '--include', '*.aa', '--include', '*.bb', 'line1'])
-        self.assertContainsRe(out, b"^dir0/file0.aa~.:line1$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^dir1/file1.bb~.:line1$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^dir0/file0.aa~.:line10$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^dir1/file1.bb~.:line10$", flags=TestGrep._reflags)
-        self.assertNotContainsRe(out, b"file1.cc", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file0.aa~.:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir1/file1.bb~.:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file0.aa~.:line10$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir1/file1.bb~.:line10$", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
         # finds line1 and line10
         self.assertEqual(len(out.splitlines()), 4)
 
@@ -687,21 +687,21 @@
 
         out, err = self.run_bzr(['grep', '--include', '*.aa',
             '--include', '*.bb', 'l.n.1'])
-        self.assertContainsRe(out, b"^dir0/file0.aa:line1$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^dir1/file1.bb:line1$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^dir0/file0.aa:line10$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^dir1/file1.bb:line10$", flags=TestGrep._reflags)
-        self.assertNotContainsRe(out, b"file1.cc", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file0.aa:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir1/file1.bb:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file0.aa:line10$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir1/file1.bb:line10$", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
         # finds line1 and line10
         self.assertEqual(len(out.splitlines()), 4)
 
         out, err = self.run_bzr(['grep', '--include', '*.aa',
             '--include', '*.bb', 'line1'])
-        self.assertContainsRe(out, b"^dir0/file0.aa:line1$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^dir1/file1.bb:line1$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^dir0/file0.aa:line10$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^dir1/file1.bb:line10$", flags=TestGrep._reflags)
-        self.assertNotContainsRe(out, b"file1.cc", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file0.aa:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir1/file1.bb:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file0.aa:line10$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir1/file1.bb:line10$", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
         # finds line1 and line10
         self.assertEqual(len(out.splitlines()), 4)
 
@@ -723,15 +723,15 @@
 
         out, err = self.run_bzr(['grep', '-r', 'last:1',
             '--exclude', '*.cc', 'l..e1'])
-        self.assertContainsRe(out, b"^dir0/file0.aa~.:line1", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^dir1/file1.bb~.:line1", flags=TestGrep._reflags)
-        self.assertNotContainsRe(out, b"file1.cc", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file0.aa~.:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir1/file1.bb~.:line1", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
 
         out, err = self.run_bzr(['grep', '-r', 'last:1',
             '--exclude', '*.cc', 'line1'])
-        self.assertContainsRe(out, b"^dir0/file0.aa~.:line1", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^dir1/file1.bb~.:line1", flags=TestGrep._reflags)
-        self.assertNotContainsRe(out, b"file1.cc", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file0.aa~.:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir1/file1.bb~.:line1", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
 
     def test_wtree_exclude_from_outside_dir(self):
         """(wtree) Ensure --exclude is respected during recursive search.
@@ -750,14 +750,14 @@
         self._mk_versioned_file('dir2/file2.cc')
 
         out, err = self.run_bzr(['grep', '--exclude', '*.cc', 'l[hijk]ne1'])
-        self.assertContainsRe(out, b"^dir0/file0.aa:line1", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^dir1/file1.bb:line1", flags=TestGrep._reflags)
-        self.assertNotContainsRe(out, b"file1.cc", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file0.aa:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir1/file1.bb:line1", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
 
         out, err = self.run_bzr(['grep', '--exclude', '*.cc', 'line1'])
-        self.assertContainsRe(out, b"^dir0/file0.aa:line1", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^dir1/file1.bb:line1", flags=TestGrep._reflags)
-        self.assertNotContainsRe(out, b"file1.cc", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file0.aa:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir1/file1.bb:line1", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file1.cc", flags=TestGrep._reflags)
 
     def test_workingtree_files_from_outside_dir(self):
         """(wtree) Grep for pattern with dirs passed as argument.
@@ -773,12 +773,12 @@
         self._mk_versioned_file('dir1/file1.txt')
 
         out, err = self.run_bzr(['grep', 'l[aeiou]ne1', 'dir0', 'dir1'])
-        self.assertContainsRe(out, b"^dir0/file0.txt:line1", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^dir1/file1.txt:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file0.txt:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir1/file1.txt:line1", flags=TestGrep._reflags)
 
         out, err = self.run_bzr(['grep', 'line1', 'dir0', 'dir1'])
-        self.assertContainsRe(out, b"^dir0/file0.txt:line1", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^dir1/file1.txt:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file0.txt:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir1/file1.txt:line1", flags=TestGrep._reflags)
 
     def test_versioned_files_from_outside_dir(self):
         """(versioned) Grep for pattern with dirs passed as argument.
@@ -794,12 +794,12 @@
         self._mk_versioned_file('dir1/file1.txt')
 
         out, err = self.run_bzr(['grep', '-r', 'last:1', '.ine1', 'dir0', 'dir1'])
-        self.assertContainsRe(out, b"^dir0/file0.txt~.:line1", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^dir1/file1.txt~.:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file0.txt~.:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir1/file1.txt~.:line1", flags=TestGrep._reflags)
 
         out, err = self.run_bzr(['grep', '-r', 'last:1', 'line1', 'dir0', 'dir1'])
-        self.assertContainsRe(out, b"^dir0/file0.txt~.:line1", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^dir1/file1.txt~.:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file0.txt~.:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir1/file1.txt~.:line1", flags=TestGrep._reflags)
 
     def test_wtree_files_from_outside_dir(self):
         """(wtree) Grep for pattern with dirs passed as argument.
@@ -815,12 +815,12 @@
         self._mk_versioned_file('dir1/file1.txt')
 
         out, err = self.run_bzr(['grep', 'li.e1', 'dir0', 'dir1'])
-        self.assertContainsRe(out, b"^dir0/file0.txt:line1", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^dir1/file1.txt:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file0.txt:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir1/file1.txt:line1", flags=TestGrep._reflags)
 
         out, err = self.run_bzr(['grep', 'line1', 'dir0', 'dir1'])
-        self.assertContainsRe(out, b"^dir0/file0.txt:line1", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^dir1/file1.txt:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file0.txt:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir1/file1.txt:line1", flags=TestGrep._reflags)
 
     def test_versioned_files_from_outside_two_dirs(self):
         """(versioned) Grep for pattern with two levels of nested dir.
@@ -839,16 +839,16 @@
         self._mk_versioned_file('dir0/dir00/file0.txt')
 
         out, err = self.run_bzr(['grep', '-r', 'last:1', 'l.ne1', 'dir0/dir00'])
-        self.assertContainsRe(out, b"^dir0/dir00/file0.txt~.:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/dir00/file0.txt~.:line1", flags=TestGrep._reflags)
 
         out, err = self.run_bzr(['grep', '-r', 'last:1', 'l.ne1'])
-        self.assertContainsRe(out, b"^dir0/dir00/file0.txt~.:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/dir00/file0.txt~.:line1", flags=TestGrep._reflags)
 
         out, err = self.run_bzr(['grep', '-r', 'last:1', 'line1', 'dir0/dir00'])
-        self.assertContainsRe(out, b"^dir0/dir00/file0.txt~.:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/dir00/file0.txt~.:line1", flags=TestGrep._reflags)
 
         out, err = self.run_bzr(['grep', '-r', 'last:1', 'line1'])
-        self.assertContainsRe(out, b"^dir0/dir00/file0.txt~.:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/dir00/file0.txt~.:line1", flags=TestGrep._reflags)
 
     def test_wtree_files_from_outside_two_dirs(self):
         """(wtree) Grep for pattern with two levels of nested dir.
@@ -867,16 +867,16 @@
         self._mk_versioned_file('dir0/dir00/file0.txt')
 
         out, err = self.run_bzr(['grep', 'lin.1', 'dir0/dir00'])
-        self.assertContainsRe(out, b"^dir0/dir00/file0.txt:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/dir00/file0.txt:line1", flags=TestGrep._reflags)
 
         out, err = self.run_bzr(['grep', 'li.e1'])
-        self.assertContainsRe(out, b"^dir0/dir00/file0.txt:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/dir00/file0.txt:line1", flags=TestGrep._reflags)
 
         out, err = self.run_bzr(['grep', 'line1', 'dir0/dir00'])
-        self.assertContainsRe(out, b"^dir0/dir00/file0.txt:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/dir00/file0.txt:line1", flags=TestGrep._reflags)
 
         out, err = self.run_bzr(['grep', 'line1'])
-        self.assertContainsRe(out, b"^dir0/dir00/file0.txt:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/dir00/file0.txt:line1", flags=TestGrep._reflags)
 
     def test_versioned_file_within_dir_two_levels(self):
         """(versioned) Search for pattern while in nested dir (two levels).
@@ -890,22 +890,22 @@
         os.chdir('dir0')
 
         out, err = self.run_bzr(['grep', '-r', 'last:1', '.ine1'])
-        self.assertContainsRe(out, b"^dir1/file0.txt~.:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir1/file0.txt~.:line1", flags=TestGrep._reflags)
 
         out, err = self.run_bzr(['grep', '-r', 'last:1', '--from-root', 'l.ne1'])
-        self.assertContainsRe(out, b"^dir0/dir1/file0.txt~.:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/dir1/file0.txt~.:line1", flags=TestGrep._reflags)
 
         out, err = self.run_bzr(['grep', '-r', 'last:1', '--no-recursive', 'line1'])
-        self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
 
         out, err = self.run_bzr(['grep', '-r', 'last:1', 'lin.1'])
-        self.assertContainsRe(out, b"^dir1/file0.txt~.:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir1/file0.txt~.:line1", flags=TestGrep._reflags)
 
         out, err = self.run_bzr(['grep', '-r', 'last:1', '--from-root', 'line1'])
-        self.assertContainsRe(out, b"^dir0/dir1/file0.txt~.:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/dir1/file0.txt~.:line1", flags=TestGrep._reflags)
 
         out, err = self.run_bzr(['grep', '-r', 'last:1', '--no-recursive', 'line1'])
-        self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 0)
 
     def test_wtree_file_within_dir_two_levels(self):
@@ -920,22 +920,22 @@
         os.chdir('dir0')
 
         out, err = self.run_bzr(['grep', 'l[hij]ne1'])
-        self.assertContainsRe(out, b"^dir1/file0.txt:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir1/file0.txt:line1", flags=TestGrep._reflags)
 
         out, err = self.run_bzr(['grep', '--from-root', 'l.ne1'])
-        self.assertContainsRe(out, b"^dir0/dir1/file0.txt:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/dir1/file0.txt:line1", flags=TestGrep._reflags)
 
         out, err = self.run_bzr(['grep', '--no-recursive', 'lin.1'])
-        self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
 
         out, err = self.run_bzr(['grep', 'line1'])
-        self.assertContainsRe(out, b"^dir1/file0.txt:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir1/file0.txt:line1", flags=TestGrep._reflags)
 
         out, err = self.run_bzr(['grep', '--from-root', 'line1'])
-        self.assertContainsRe(out, b"^dir0/dir1/file0.txt:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/dir1/file0.txt:line1", flags=TestGrep._reflags)
 
         out, err = self.run_bzr(['grep', '--no-recursive', 'line1'])
-        self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
 
     def test_versioned_ignore_case_no_match(self):
         """(versioned) Match fails without --ignore-case.
@@ -946,10 +946,10 @@
         self._mk_versioned_file('file0.txt')
 
         out, err = self.run_bzr(['grep', '-r', 'last:1', 'LinE1', 'file0.txt'])
-        self.assertNotContainsRe(out, b"file0.txt~.:line1", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
 
         out, err = self.run_bzr(['grep', '-r', 'last:1', 'Li.E1', 'file0.txt'])
-        self.assertNotContainsRe(out, b"file0.txt~.:line1", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
 
     def test_wtree_ignore_case_no_match(self):
         """(wtree) Match fails without --ignore-case.
@@ -960,10 +960,10 @@
         self._mk_versioned_file('file0.txt')
 
         out, err = self.run_bzr(['grep', 'LinE1', 'file0.txt'])
-        self.assertNotContainsRe(out, b"file0.txt:line1", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
 
         out, err = self.run_bzr(['grep', '.inE1', 'file0.txt'])
-        self.assertNotContainsRe(out, b"file0.txt:line1", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
 
     def test_versioned_ignore_case_match(self):
         """(versioned) Match fails without --ignore-case.
@@ -975,15 +975,15 @@
 
         out, err = self.run_bzr(['grep', '-r', 'last:1',
             '-i', 'Li.E1', 'file0.txt'])
-        self.assertContainsRe(out, b"file0.txt~.:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
 
         out, err = self.run_bzr(['grep', '-r', 'last:1',
             '-i', 'LinE1', 'file0.txt'])
-        self.assertContainsRe(out, b"file0.txt~.:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
 
         out, err = self.run_bzr(['grep', '-r', 'last:1',
             '--ignore-case', 'LinE1', 'file0.txt'])
-        self.assertContainsRe(out, b"^file0.txt~.:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file0.txt~.:line1", flags=TestGrep._reflags)
 
     def test_wtree_ignore_case_match(self):
         """(wtree) Match fails without --ignore-case.
@@ -994,13 +994,13 @@
         self._mk_versioned_file('file0.txt')
 
         out, err = self.run_bzr(['grep', '-i', 'LinE1', 'file0.txt'])
-        self.assertContainsRe(out, b"file0.txt:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
 
         out, err = self.run_bzr(['grep', '--ignore-case', 'LinE1', 'file0.txt'])
-        self.assertContainsRe(out, b"^file0.txt:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file0.txt:line1", flags=TestGrep._reflags)
 
         out, err = self.run_bzr(['grep', '--ignore-case', 'Li.E1', 'file0.txt'])
-        self.assertContainsRe(out, b"^file0.txt:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file0.txt:line1", flags=TestGrep._reflags)
 
     def test_versioned_from_root_fail(self):
         """(versioned) Match should fail without --from-root.
@@ -1013,10 +1013,10 @@
         os.chdir('dir0')
 
         out, err = self.run_bzr(['grep', '-r', 'last:1', 'li.e1'])
-        self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
 
         out, err = self.run_bzr(['grep', '-r', 'last:1', 'line1'])
-        self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
 
     def test_wtree_from_root_fail(self):
         """(wtree) Match should fail without --from-root.
@@ -1029,10 +1029,10 @@
         os.chdir('dir0')
 
         out, err = self.run_bzr(['grep', 'line1'])
-        self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
 
         out, err = self.run_bzr(['grep', 'li.e1'])
-        self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
 
     def test_versioned_from_root_pass(self):
         """(versioned) Match pass with --from-root.
@@ -1046,11 +1046,11 @@
 
         out, err = self.run_bzr(['grep', '-r', 'last:1',
             '--from-root', 'l.ne1'])
-        self.assertContainsRe(out, b"file0.txt~.:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
 
         out, err = self.run_bzr(['grep', '-r', 'last:1',
             '--from-root', 'line1'])
-        self.assertContainsRe(out, b"file0.txt~.:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~.:line1", flags=TestGrep._reflags)
 
     def test_wtree_from_root_pass(self):
         """(wtree) Match pass with --from-root.
@@ -1063,10 +1063,10 @@
         os.chdir('dir0')
 
         out, err = self.run_bzr(['grep', '--from-root', 'lin.1'])
-        self.assertContainsRe(out, b"file0.txt:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
 
         out, err = self.run_bzr(['grep', '--from-root', 'line1'])
-        self.assertContainsRe(out, b"file0.txt:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
 
     def test_versioned_with_line_number(self):
         """(versioned) Search for pattern with --line-number.
@@ -1078,18 +1078,18 @@
 
         out, err = self.run_bzr(['grep', '-r', 'last:1',
             '--line-number', 'li.e3', 'file0.txt'])
-        self.assertContainsRe(out, b"file0.txt~.:3:line3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~.:3:line3", flags=TestGrep._reflags)
 
         out, err = self.run_bzr(['grep', '-r', 'last:1',
             '--line-number', 'line3', 'file0.txt'])
-        self.assertContainsRe(out, b"file0.txt~.:3:line3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~.:3:line3", flags=TestGrep._reflags)
 
         out, err = self.run_bzr(['grep', '-r', 'last:1',
             '-n', 'line1', 'file0.txt'])
-        self.assertContainsRe(out, b"file0.txt~.:1:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~.:1:line1", flags=TestGrep._reflags)
 
         out, err = self.run_bzr(['grep', '-n', 'line[0-9]', 'file0.txt'])
-        self.assertContainsRe(out, b"file0.txt:3:line3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt:3:line3", flags=TestGrep._reflags)
 
     def test_wtree_with_line_number(self):
         """(wtree) Search for pattern with --line-number.
@@ -1100,16 +1100,16 @@
         self._mk_versioned_file('file0.txt')
 
         out, err = self.run_bzr(['grep', '--line-number', 'line3', 'file0.txt'])
-        self.assertContainsRe(out, b"file0.txt:3:line3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt:3:line3", flags=TestGrep._reflags)
 
         out, err = self.run_bzr(['grep', '-n', 'line1', 'file0.txt'])
-        self.assertContainsRe(out, b"file0.txt:1:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt:1:line1", flags=TestGrep._reflags)
 
         out, err = self.run_bzr(['grep', '-n', '[hjkl]ine1', 'file0.txt'])
-        self.assertContainsRe(out, b"file0.txt:1:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt:1:line1", flags=TestGrep._reflags)
 
         out, err = self.run_bzr(['grep', '-n', 'line[0-9]', 'file0.txt'])
-        self.assertContainsRe(out, b"file0.txt:3:line3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt:3:line3", flags=TestGrep._reflags)
 
     def test_revno_basic_history_grep_file(self):
         """Search for pattern in specific revision number in a file.
@@ -1125,27 +1125,27 @@
 
         # rev 2 should not have text 'v3'
         out, err = self.run_bzr(['grep', '-r', '2', 'v3', fname])
-        self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
 
         # rev 3 should not have text 'v3'
         out, err = self.run_bzr(['grep', '-r', '3', 'v3', fname])
-        self.assertContainsRe(out, b"file0.txt~3:v3.*", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~3:v3.*", flags=TestGrep._reflags)
 
         # rev 3 should not have text 'v3' with line number
         out, err = self.run_bzr(['grep', '-r', '3', '-n', 'v3', fname])
-        self.assertContainsRe(out, b"file0.txt~3:2:v3.*", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~3:2:v3.*", flags=TestGrep._reflags)
 
         # rev 2 should not have text 'v3'
         out, err = self.run_bzr(['grep', '-r', '2', '[tuv]3', fname])
-        self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
 
         # rev 3 should not have text 'v3'
         out, err = self.run_bzr(['grep', '-r', '3', '[tuv]3', fname])
-        self.assertContainsRe(out, b"file0.txt~3:v3.*", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~3:v3.*", flags=TestGrep._reflags)
 
         # rev 3 should not have text 'v3' with line number
         out, err = self.run_bzr(['grep', '-r', '3', '-n', '[tuv]3', fname])
-        self.assertContainsRe(out, b"file0.txt~3:2:v3.*", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~3:2:v3.*", flags=TestGrep._reflags)
 
     def test_revno_basic_history_grep_full(self):
         """Search for pattern in specific revision number in a file.
@@ -1162,27 +1162,27 @@
 
         # rev 2 should not have text 'v3'
         out, err = self.run_bzr(['grep', '-r', '2', 'v3'])
-        self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
 
         # rev 3 should not have text 'v3'
         out, err = self.run_bzr(['grep', '-r', '3', 'v3'])
-        self.assertContainsRe(out, b"file0.txt~3:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
 
         # rev 3 should not have text 'v3' with line number
         out, err = self.run_bzr(['grep', '-r', '3', '-n', 'v3'])
-        self.assertContainsRe(out, b"file0.txt~3:1:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~3:1:v3", flags=TestGrep._reflags)
 
         # rev 2 should not have text 'v3'
         out, err = self.run_bzr(['grep', '-r', '2', '[tuv]3'])
-        self.assertNotContainsRe(out, b"file0.txt", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.txt", flags=TestGrep._reflags)
 
         # rev 3 should not have text 'v3'
         out, err = self.run_bzr(['grep', '-r', '3', '[tuv]3'])
-        self.assertContainsRe(out, b"file0.txt~3:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
 
         # rev 3 should not have text 'v3' with line number
         out, err = self.run_bzr(['grep', '-r', '3', '-n', '[tuv]3'])
-        self.assertContainsRe(out, b"file0.txt~3:1:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~3:1:v3", flags=TestGrep._reflags)
 
     def test_revno_versioned_file_in_dir(self):
         """Grep specific version of file withing dir.
@@ -1198,19 +1198,19 @@
 
         # v4 should not be present in revno 3
         out, err = self.run_bzr(['grep', '-r', 'last:3', 'v4'])
-        self.assertNotContainsRe(out, b"^dir0/file0.txt", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "^dir0/file0.txt", flags=TestGrep._reflags)
 
         # v4 should be present in revno 4
         out, err = self.run_bzr(['grep', '-r', 'last:2', 'v4'])
-        self.assertContainsRe(out, b"^dir0/file0.txt~4:v4", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file0.txt~4:v4", flags=TestGrep._reflags)
 
         # v4 should not be present in revno 3
         out, err = self.run_bzr(['grep', '-r', 'last:3', '[tuv]4'])
-        self.assertNotContainsRe(out, b"^dir0/file0.txt", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "^dir0/file0.txt", flags=TestGrep._reflags)
 
         # v4 should be present in revno 4
         out, err = self.run_bzr(['grep', '-r', 'last:2', '[tuv]4'])
-        self.assertContainsRe(out, b"^dir0/file0.txt~4:v4", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file0.txt~4:v4", flags=TestGrep._reflags)
 
     def test_revno_range_basic_history_grep(self):
         """Search for pattern in revision range for file.
@@ -1227,10 +1227,10 @@
         self._update_file(fname, text="v6 text\n")    # rev6
 
         out, err = self.run_bzr(['grep', '-r', '1..', 'v3'])
-        self.assertContainsRe(out, b"file0.txt~3:v3", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"file0.txt~4:v3", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"file0.txt~5:v3", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"file0.txt~6:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~6:v3", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 4)
 
         out, err = self.run_bzr(['grep', '-r', '..1', 'v3'])
@@ -1238,51 +1238,51 @@
         self.assertEqual(len(out.splitlines()), 0)
 
         out, err = self.run_bzr(['grep', '-r', '..6', 'v3'])
-        self.assertContainsRe(out, b"file0.txt~3:v3", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"file0.txt~4:v3", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"file0.txt~5:v3", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"file0.txt~6:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~6:v3", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 4)
 
         out, err = self.run_bzr(['grep', '-r', '..', 'v3'])
-        self.assertContainsRe(out, b"file0.txt~3:v3", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"file0.txt~4:v3", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"file0.txt~5:v3", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"file0.txt~6:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~6:v3", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 4)
 
         out, err = self.run_bzr(['grep', '-r', '1..5', 'v3'])
-        self.assertContainsRe(out, b"file0.txt~3:v3", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"file0.txt~4:v3", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"file0.txt~5:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
         self.assertNotContainsRe(out, "file0.txt~6:v3", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 3)
 
         out, err = self.run_bzr(['grep', '-r', '5..1', 'v3'])
-        self.assertContainsRe(out, b"file0.txt~3:v3", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"file0.txt~4:v3", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"file0.txt~5:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
         self.assertNotContainsRe(out, "file0.txt~6:v3", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 3)
 
         out, err = self.run_bzr(['grep', '-r', '1..', '[tuv]3'])
-        self.assertContainsRe(out, b"file0.txt~3:v3", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"file0.txt~4:v3", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"file0.txt~5:v3", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"file0.txt~6:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~6:v3", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 4)
 
         out, err = self.run_bzr(['grep', '-r', '1..5', '[tuv]3'])
-        self.assertContainsRe(out, b"file0.txt~3:v3", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"file0.txt~4:v3", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"file0.txt~5:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
         self.assertNotContainsRe(out, "file0.txt~6:v3", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 3)
 
         out, err = self.run_bzr(['grep', '-r', '5..1', '[tuv]3'])
-        self.assertContainsRe(out, b"file0.txt~3:v3", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"file0.txt~4:v3", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"file0.txt~5:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~3:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~4:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~5:v3", flags=TestGrep._reflags)
         self.assertNotContainsRe(out, "file0.txt~6:v3", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 3)
 
@@ -1300,16 +1300,16 @@
         self._update_file('dir0/file0.txt', "v6 text\n")    # rev6
 
         out, err = self.run_bzr(['grep', '-r', '2..5', 'v3'])
-        self.assertContainsRe(out, b"^dir0/file0.txt~3:v3", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^dir0/file0.txt~4:v3", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^dir0/file0.txt~5:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file0.txt~3:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file0.txt~4:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file0.txt~5:v3", flags=TestGrep._reflags)
         self.assertNotContainsRe(out, "^dir0/file0.txt~6:v3", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 3)
 
         out, err = self.run_bzr(['grep', '-r', '2..5', '[tuv]3'])
-        self.assertContainsRe(out, b"^dir0/file0.txt~3:v3", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^dir0/file0.txt~4:v3", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^dir0/file0.txt~5:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file0.txt~3:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file0.txt~4:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file0.txt~5:v3", flags=TestGrep._reflags)
         self.assertNotContainsRe(out, "^dir0/file0.txt~6:v3", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 3)
 
@@ -1327,15 +1327,15 @@
         self._update_file('dir0/file0.txt', "v6 text\n")    # rev6
 
         out, err = self.run_bzr(['grep', '-r', '2..5', 'v3', 'dir0'])
-        self.assertContainsRe(out, b"^dir0/file0.txt~3:v3", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^dir0/file0.txt~4:v3", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^dir0/file0.txt~5:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file0.txt~3:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file0.txt~4:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file0.txt~5:v3", flags=TestGrep._reflags)
         self.assertNotContainsRe(out, "^dir0/file0.txt~6:v3", flags=TestGrep._reflags)
 
         out, err = self.run_bzr(['grep', '-r', '2..5', '[tuv]3', 'dir0'])
-        self.assertContainsRe(out, b"^dir0/file0.txt~3:v3", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^dir0/file0.txt~4:v3", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^dir0/file0.txt~5:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file0.txt~3:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file0.txt~4:v3", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file0.txt~5:v3", flags=TestGrep._reflags)
         self.assertNotContainsRe(out, "^dir0/file0.txt~6:v3", flags=TestGrep._reflags)
 
     def test_levels(self):
@@ -1358,63 +1358,63 @@
         out, err = self.run_bzr(['ci', '-m', 'merged'])
 
         out, err = self.run_bzr(['grep', 'line1'])
-        self.assertContainsRe(out, b"file0.txt:line1", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"file1.txt:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file1.txt:line1", flags=TestGrep._reflags)
 
         # levels should be ignored by wtree grep
         out, err = self.run_bzr(['grep', '--levels=0', 'line1'])
-        self.assertContainsRe(out, b"^file0.txt:line1$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^file1.txt:line1$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^file0.txt:line10$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^file1.txt:line10$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file0.txt:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.txt:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file0.txt:line10$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.txt:line10$", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 4)
 
         out, err = self.run_bzr(['grep', '-r', 'last:1..', '--levels=0', 'line1'])
-        self.assertContainsRe(out, b"^file0.txt~2:line1$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^file1.txt~2:line1$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^file0.txt~1.1.1:line1$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^file1.txt~1.1.1:line1$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^file0.txt~2:line10$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^file1.txt~2:line10$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^file0.txt~1.1.1:line10$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^file1.txt~1.1.1:line10$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file0.txt~2:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.txt~2:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file0.txt~1.1.1:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.txt~1.1.1:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file0.txt~2:line10$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.txt~2:line10$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file0.txt~1.1.1:line10$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.txt~1.1.1:line10$", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 8)
 
         out, err = self.run_bzr(['grep', '-r',  '-1..', '-n', '--levels=0', 'line1'])
-        self.assertContainsRe(out, b"^file0.txt~2:1:line1$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^file1.txt~2:1:line1$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^file0.txt~1.1.1:1:line1$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^file1.txt~1.1.1:1:line1$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^file0.txt~2:10:line10$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^file1.txt~2:10:line10$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^file0.txt~1.1.1:10:line10$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^file1.txt~1.1.1:10:line10$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file0.txt~2:1:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.txt~2:1:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file0.txt~1.1.1:1:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.txt~1.1.1:1:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file0.txt~2:10:line10$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.txt~2:10:line10$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file0.txt~1.1.1:10:line10$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.txt~1.1.1:10:line10$", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 8)
 
         # levels should be ignored by wtree grep
         out, err = self.run_bzr(['grep', '--levels=0', 'l.ne1'])
-        self.assertContainsRe(out, b"^file0.txt:line1$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^file1.txt:line1$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^file0.txt:line10$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^file1.txt:line10$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file0.txt:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.txt:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file0.txt:line10$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.txt:line10$", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 4)
 
         out, err = self.run_bzr(['grep', '-r', 'last:1..', '--levels=0', 'lin.1'])
-        self.assertContainsRe(out, b"^file0.txt~2:line1$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^file1.txt~2:line1$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^file0.txt~1.1.1:line1$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^file1.txt~1.1.1:line1$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^file0.txt~2:line10$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^file1.txt~2:line10$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^file0.txt~1.1.1:line10$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^file1.txt~1.1.1:line10$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file0.txt~2:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.txt~2:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file0.txt~1.1.1:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.txt~1.1.1:line1$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file0.txt~2:line10$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.txt~2:line10$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file0.txt~1.1.1:line10$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.txt~1.1.1:line10$", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 8)
 
         out, err = self.run_bzr(['grep', '-r',  '-1..', '-n', '--levels=0', '.ine1'])
-        self.assertContainsRe(out, b"file0.txt~2:1:line1", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"file1.txt~2:1:line1", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"file0.txt~1.1.1:1:line1", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"file1.txt~1.1.1:1:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~2:1:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file1.txt~2:1:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~1.1.1:1:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file1.txt~1.1.1:1:line1", flags=TestGrep._reflags)
 
     def test_dotted_rev_grep(self):
         """Grep in dotted revs
@@ -1439,12 +1439,12 @@
         out, err = self.run_bzr(['ci', '-m', 'merged'])
 
         out, err = self.run_bzr(['grep', '-r', '1.1.1..1.1.4', 'text'])
-        self.assertContainsRe(out, b"file1.txt~1.1.2:text 0", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"file1.txt~1.1.3:text 1", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"file1.txt~1.1.3:text 1", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"file1.txt~1.1.4:text 0", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"file1.txt~1.1.4:text 1", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"file1.txt~1.1.4:text 2", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file1.txt~1.1.2:text 0", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file1.txt~1.1.3:text 1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file1.txt~1.1.3:text 1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file1.txt~1.1.4:text 0", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file1.txt~1.1.4:text 1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file1.txt~1.1.4:text 2", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 6)
 
     def test_versioned_binary_file_grep(self):
@@ -1460,15 +1460,15 @@
         # note: set --verbose/-v flag to get the skip message.
         out, err = self.run_bzr(['grep', '-v', '-r', 'last:1',
             'lineNN', 'file0.bin'])
-        self.assertNotContainsRe(out, b"file0.bin", flags=TestGrep._reflags)
-        self.assertContainsRe(err, b"Binary file.*file0.bin.*skipped", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.bin", flags=TestGrep._reflags)
+        self.assertContainsRe(err, "Binary file.*file0.bin.*skipped", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 0)
         self.assertEqual(len(err.splitlines()), 1)
 
         out, err = self.run_bzr(['grep', '-v', '-r', 'last:1',
             'line.N', 'file0.bin'])
-        self.assertNotContainsRe(out, b"file0.bin", flags=TestGrep._reflags)
-        self.assertContainsRe(err, b"Binary file.*file0.bin.*skipped", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.bin", flags=TestGrep._reflags)
+        self.assertContainsRe(err, "Binary file.*file0.bin.*skipped", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 0)
         self.assertEqual(len(err.splitlines()), 1)
 
@@ -1483,13 +1483,13 @@
 
         # note: set --verbose/-v flag to get the skip message.
         out, err = self.run_bzr(['grep', '-v', 'lineNN', 'file0.bin'])
-        self.assertNotContainsRe(out, b"file0.bin:line1", flags=TestGrep._reflags)
-        self.assertContainsRe(err, b"Binary file.*file0.bin.*skipped", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.bin:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(err, "Binary file.*file0.bin.*skipped", flags=TestGrep._reflags)
 
         # binary warning should not be shown without --verbose
         out, err = self.run_bzr(['grep', 'lineNN', 'file0.bin'])
-        self.assertNotContainsRe(out, b"file0.bin:line1", flags=TestGrep._reflags)
-        self.assertNotContainsRe(err, b"Binary file", flags=TestGrep._reflags)
+        self.assertNotContainsRe(out, "file0.bin:line1", flags=TestGrep._reflags)
+        self.assertNotContainsRe(err, "Binary file", flags=TestGrep._reflags)
 
     def test_revspec(self):
         """Ensure various revspecs work
@@ -1508,7 +1508,7 @@
         self.assertEqual(len(out.splitlines()), 0)
 
         out, err = self.run_bzr(['grep', '-r', 'revno:4..', 'v4'])
-        self.assertContainsRe(out, b"^dir0/file0.txt", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file0.txt", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 2) # find v4 in rev4 and rev5
 
         out, err = self.run_bzr(['grep', '-r', '..revno:3', 'v4'])
@@ -1516,7 +1516,7 @@
         self.assertEqual(len(out.splitlines()), 0)
 
         out, err = self.run_bzr(['grep', '-r', '..revno:3', 'v3'])
-        self.assertContainsRe(out, b"^dir0/file0.txt", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file0.txt", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 1)
 
     def test_wtree_files_with_matches(self):
@@ -1538,65 +1538,65 @@
         # fixed-string
         out, err = self.run_bzr(['grep', '--files-with-matches', 'HELLO'])
 
-        self.assertContainsRe(out, b"^file0.txt$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^dir0/file00.txt$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file00.txt$", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 2)
 
         # regex
         out, err = self.run_bzr(['grep', '--files-with-matches', 'HE.LO'])
 
-        self.assertContainsRe(out, b"^file0.txt$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^dir0/file00.txt$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file00.txt$", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 2)
 
         # fixed-string
         out, err = self.run_bzr(['grep', '-l', 'HELLO'])
 
-        self.assertContainsRe(out, b"^file0.txt$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^dir0/file00.txt$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file00.txt$", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 2)
 
         # regex
         out, err = self.run_bzr(['grep', '-l', 'HE.LO'])
 
-        self.assertContainsRe(out, b"^file0.txt$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^dir0/file00.txt$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file00.txt$", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 2)
 
         # fixed-string
         out, err = self.run_bzr(['grep', '-l', 'HELLO', 'dir0', 'file1.txt'])
 
-        self.assertContainsRe(out, b"^dir0/file00.txt$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file00.txt$", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 1)
 
         # regex
         out, err = self.run_bzr(['grep', '-l', '.ELLO', 'dir0', 'file1.txt'])
 
-        self.assertContainsRe(out, b"^dir0/file00.txt$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file00.txt$", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 1)
 
         # fixed-string
         out, err = self.run_bzr(['grep', '-l', 'HELLO', 'file0.txt'])
 
-        self.assertContainsRe(out, b"^file0.txt$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 1)
 
         # regex
         out, err = self.run_bzr(['grep', '-l', '.ELLO', 'file0.txt'])
 
-        self.assertContainsRe(out, b"^file0.txt$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 1)
 
         # fixed-string
         out, err = self.run_bzr(['grep', '--no-recursive', '-l', 'HELLO'])
 
-        self.assertContainsRe(out, b"^file0.txt$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 1)
 
         # regex
         out, err = self.run_bzr(['grep', '--no-recursive', '-l', '.ELLO'])
 
-        self.assertContainsRe(out, b"^file0.txt$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file0.txt$", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 1)
 
     def test_ver_files_with_matches(self):
@@ -1619,90 +1619,90 @@
         out, err = self.run_bzr(['grep', '-r', '-1', '--files-with-matches',
             'HELLO'])
 
-        self.assertContainsRe(out, b"^file0.txt~7$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^dir0/file00.txt~7$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file00.txt~7$", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 2)
 
         # regex
         out, err = self.run_bzr(['grep', '-r', '-1', '--files-with-matches',
             'H.LLO'])
 
-        self.assertContainsRe(out, b"^file0.txt~7$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^dir0/file00.txt~7$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file00.txt~7$", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 2)
 
         # fixed-string
         out, err = self.run_bzr(['grep', '-r', '6..7', '--files-with-matches',
             'HELLO'])
 
-        self.assertContainsRe(out, b"^file0.txt~6$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^file0.txt~7$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^dir0/file00.txt~7$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file0.txt~6$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file00.txt~7$", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 3)
 
         # regex
         out, err = self.run_bzr(['grep', '-r', '6..7', '--files-with-matches',
             'H.LLO'])
 
-        self.assertContainsRe(out, b"^file0.txt~6$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^file0.txt~7$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^dir0/file00.txt~7$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file0.txt~6$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file00.txt~7$", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 3)
 
         # fixed-string
         out, err = self.run_bzr(['grep', '-r', '-1', '-l', 'HELLO'])
 
-        self.assertContainsRe(out, b"^file0.txt~7$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^dir0/file00.txt~7$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file00.txt~7$", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 2)
 
         # regex
         out, err = self.run_bzr(['grep', '-r', '-1', '-l', 'H.LLO'])
 
-        self.assertContainsRe(out, b"^file0.txt~7$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^dir0/file00.txt~7$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file00.txt~7$", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 2)
 
         # fixed-string
         out, err = self.run_bzr(['grep', '-l', 'HELLO', '-r', '-1',
             'dir0', 'file1.txt'])
 
-        self.assertContainsRe(out, b"^dir0/file00.txt~7$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file00.txt~7$", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 1)
 
         # regex
         out, err = self.run_bzr(['grep', '-l', 'H.LLO', '-r', '-1',
             'dir0', 'file1.txt'])
 
-        self.assertContainsRe(out, b"^dir0/file00.txt~7$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file00.txt~7$", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 1)
 
         # fixed-string
         out, err = self.run_bzr(['grep', '-l', 'HELLO',
             '-r', '-2', 'file0.txt'])
 
-        self.assertContainsRe(out, b"^file0.txt~6$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file0.txt~6$", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 1)
 
         # regex
         out, err = self.run_bzr(['grep', '-l', 'HE.LO',
             '-r', '-2', 'file0.txt'])
 
-        self.assertContainsRe(out, b"^file0.txt~6$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file0.txt~6$", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 1)
 
         # fixed-string
         out, err = self.run_bzr(['grep', '--no-recursive', '-r', '-1',
             '-l', 'HELLO'])
 
-        self.assertContainsRe(out, b"^file0.txt~7$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 1)
 
         # regex
         out, err = self.run_bzr(['grep', '--no-recursive', '-r', '-1',
             '-l', '.ELLO'])
 
-        self.assertContainsRe(out, b"^file0.txt~7$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file0.txt~7$", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 1)
 
     def test_wtree_files_without_matches(self):
@@ -1724,67 +1724,67 @@
         # fixed-string
         out, err = self.run_bzr(['grep', '--files-without-match', 'HELLO'])
 
-        self.assertContainsRe(out, b"^file1.txt$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^dir0/file01.txt$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file01.txt$", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 2)
 
         # regex
         out, err = self.run_bzr(['grep', '--files-without-match', 'HE.LO'])
 
-        self.assertContainsRe(out, b"^file1.txt$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^dir0/file01.txt$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file01.txt$", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 2)
 
         # fixed-string
         out, err = self.run_bzr(['grep', '-L', 'HELLO'])
 
-        self.assertContainsRe(out, b"^file1.txt$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^dir0/file01.txt$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file01.txt$", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 2)
 
         # regex
         out, err = self.run_bzr(['grep', '-L', 'HE.LO'])
 
-        self.assertContainsRe(out, b"^file1.txt$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^dir0/file01.txt$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file01.txt$", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 2)
 
         # fixed-string
         out, err = self.run_bzr(['grep', '-L', 'HELLO', 'dir0', 'file1.txt'])
 
-        self.assertContainsRe(out, b"^file1.txt$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^dir0/file01.txt$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file01.txt$", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 2)
 
         # regex
         out, err = self.run_bzr(['grep', '-L', '.ELLO', 'dir0', 'file1.txt'])
 
-        self.assertContainsRe(out, b"^file1.txt$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^dir0/file01.txt$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file01.txt$", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 2)
 
         # fixed-string
         out, err = self.run_bzr(['grep', '-L', 'HELLO', 'file1.txt'])
 
-        self.assertContainsRe(out, b"^file1.txt$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 1)
 
         # regex
         out, err = self.run_bzr(['grep', '-L', '.ELLO', 'file1.txt'])
 
-        self.assertContainsRe(out, b"^file1.txt$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 1)
 
         # fixed-string
         out, err = self.run_bzr(['grep', '--no-recursive', '-L', 'HELLO'])
 
-        self.assertContainsRe(out, b"^file1.txt$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 1)
 
         # regex
         out, err = self.run_bzr(['grep', '--no-recursive', '-L', '.ELLO'])
 
-        self.assertContainsRe(out, b"^file1.txt$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.txt$", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 1)
 
     def test_ver_files_without_matches(self):
@@ -1807,96 +1807,96 @@
         out, err = self.run_bzr(['grep', '-r', '-1', '--files-without-match',
             'HELLO'])
 
-        self.assertContainsRe(out, b"^file1.txt~7$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^dir0/file01.txt~7$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file01.txt~7$", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 2)
 
         # regex
         out, err = self.run_bzr(['grep', '-r', '-1', '--files-without-match',
             'H.LLO'])
 
-        self.assertContainsRe(out, b"^file1.txt~7$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^dir0/file01.txt~7$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file01.txt~7$", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 2)
 
         # fixed-string
         out, err = self.run_bzr(['grep', '-r', '6..7', '--files-without-match',
             'HELLO'])
 
-        self.assertContainsRe(out, b"^file1.txt~6$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^dir0/file00.txt~6$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^dir0/file01.txt~6$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^file1.txt~7$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^dir0/file01.txt~7$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.txt~6$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file00.txt~6$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file01.txt~6$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file01.txt~7$", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 5)
 
         # regex
         out, err = self.run_bzr(['grep', '-r', '6..7', '--files-without-match',
             'H.LLO'])
 
-        self.assertContainsRe(out, b"^file1.txt~6$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^dir0/file00.txt~6$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^dir0/file01.txt~6$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^file1.txt~7$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^dir0/file01.txt~7$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.txt~6$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file00.txt~6$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file01.txt~6$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file01.txt~7$", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 5)
 
         # fixed-string
         out, err = self.run_bzr(['grep', '-r', '-1', '-L', 'HELLO'])
 
-        self.assertContainsRe(out, b"^file1.txt~7$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^dir0/file01.txt~7$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file01.txt~7$", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 2)
 
         # regex
         out, err = self.run_bzr(['grep', '-r', '-1', '-L', 'H.LLO'])
 
-        self.assertContainsRe(out, b"^file1.txt~7$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^dir0/file01.txt~7$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file01.txt~7$", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 2)
 
         # fixed-string
         out, err = self.run_bzr(['grep', '-L', 'HELLO', '-r', '-1',
             'dir0', 'file1.txt'])
 
-        self.assertContainsRe(out, b"^file1.txt~7$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^dir0/file01.txt~7$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file01.txt~7$", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 2)
 
         # regex
         out, err = self.run_bzr(['grep', '-L', 'H.LLO', '-r', '-1',
             'dir0', 'file1.txt'])
 
-        self.assertContainsRe(out, b"^file1.txt~7$", flags=TestGrep._reflags)
-        self.assertContainsRe(out, b"^dir0/file01.txt~7$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^dir0/file01.txt~7$", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 2)
 
         # fixed-string
         out, err = self.run_bzr(['grep', '-L', 'HELLO',
             '-r', '-2', 'file1.txt'])
 
-        self.assertContainsRe(out, b"^file1.txt~6$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.txt~6$", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 1)
 
         # regex
         out, err = self.run_bzr(['grep', '-L', 'HE.LO',
             '-r', '-2', 'file1.txt'])
 
-        self.assertContainsRe(out, b"^file1.txt~6$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.txt~6$", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 1)
 
         # fixed-string
         out, err = self.run_bzr(['grep', '--no-recursive', '-r', '-1',
             '-L', 'HELLO'])
 
-        self.assertContainsRe(out, b"^file1.txt~7$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 1)
 
         # regex
         out, err = self.run_bzr(['grep', '--no-recursive', '-r', '-1',
             '-L', '.ELLO'])
 
-        self.assertContainsRe(out, b"^file1.txt~7$", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "^file1.txt~7$", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 1)
 
     def test_no_tree(self):
@@ -1912,11 +1912,11 @@
         os.chdir(wd1)
 
         out, err = self.run_bzr(['grep', 'line1'], 3)
-        self.assertContainsRe(err, b"Cannot search working tree", flags=TestGrep._reflags)
+        self.assertContainsRe(err, "Cannot search working tree", flags=TestGrep._reflags)
         self.assertEqual(out, '')
 
         out, err = self.run_bzr(['grep', '-r', '1', 'line1'])
-        self.assertContainsRe(out, b"file0.txt~1:line1", flags=TestGrep._reflags)
+        self.assertContainsRe(out, "file0.txt~1:line1", flags=TestGrep._reflags)
         self.assertEqual(len(out.splitlines()), 2) # finds line1 and line10
 
 
@@ -1969,7 +1969,7 @@
         """
         out, err = self.run_bzr(['grep', '--color', 'foo', 'bar'], 3)
         self.assertEqual(out, '')
-        self.assertContainsRe(err, b'Valid values for --color are', flags=TestGrep._reflags)
+        self.assertContainsRe(err, 'Valid values for --color are', flags=TestGrep._reflags)
 
     def test_ver_matching_files(self):
         """(versioned) Search for matches or no matches only"""
@@ -2249,5 +2249,5 @@
         out, err = self.run_bzr(['init'])
         out, err = self.run_bzr(['grep', '--diff', 'foo'], 3)
         self.assertEqual(out, b'')
-        self.assertContainsRe(err, b"ERROR:.*revision.* does not exist in branch")
+        self.assertContainsRe(err, "ERROR:.*revision.* does not exist in branch")
 

=== modified file 'breezy/plugins/repodebug/tests/__init__.py'
--- breezy/plugins/repodebug/tests/__init__.py	2018-05-27 18:00:21 +0000
+++ breezy/plugins/repodebug/tests/__init__.py	2018-07-14 19:37:12 +0000
@@ -24,21 +24,21 @@
 
     def test_check_chk(self):
         out, err = self.run_bzr('check-chk')
-        self.assertEqual(out, b'')
-        self.assertEqual(err, b'')
+        self.assertEqual(out, '')
+        self.assertEqual(err, '')
 
     def test_chk_used_by(self):
         self.make_branch_and_tree('.')
         out, err = self.run_bzr('chk-used-by chk')
-        self.assertEqual(out, b'')
-        self.assertEqual(err, b'')
+        self.assertEqual(out, '')
+        self.assertEqual(err, '')
 
     def test_fetch_all_records(self):
         self.make_branch_and_tree('source')
         self.make_branch_and_tree('dest')
         out, err = self.run_bzr('fetch-all-records source -d dest')
-        self.assertEqual(out, b'Done.\n')
-        self.assertEqual(err, b'')
+        self.assertEqual(out, 'Done.\n')
+        self.assertEqual(err, '')
 
     def test_file_refs(self):
         tree = self.make_branch_and_tree('.')
@@ -47,34 +47,34 @@
         revid = tree.commit('a commit')
         out, err = self.run_bzr(
                 'file-refs ' + tree.path2id('foo').decode() + ' ' + revid.decode())
-        self.assertEqual(out, revid + b'\n')
-        self.assertEqual(err, b'')
+        self.assertEqual(out, revid.decode('utf-8') + '\n')
+        self.assertEqual(err, '')
 
     def test_fix_missing_keys_for_stacking(self):
         self.make_branch_and_tree('stacked')
         self.run_bzr('branch --stacked stacked new')
         out, err = self.run_bzr('fix-missing-keys-for-stacking new')
-        self.assertEqual(out, b'')
-        self.assertEqual(err, b'')
+        self.assertEqual(out, '')
+        self.assertEqual(err, '')
 
     def test_mirror_revs_into(self):
         self.make_branch_and_tree('source')
         self.make_branch_and_tree('dest')
         out, err = self.run_bzr('mirror-revs-into source dest')
-        self.assertEqual(out, b'')
-        self.assertEqual(err, b'')
+        self.assertEqual(out, '')
+        self.assertEqual(err, '')
 
     def test_repo_has_key(self):
         self.make_branch_and_tree('repo')
         out, err = self.run_bzr('repo-has-key repo revisions revid', retcode=1)
-        self.assertEqual(out, b'False\n')
-        self.assertEqual(err, b'')
+        self.assertEqual(out, 'False\n')
+        self.assertEqual(err, '')
 
     def test_repo_keys(self):
         self.make_branch_and_tree('a')
         out, err = self.run_bzr('repo-keys a texts')
-        self.assertEqual(out, b'')
-        self.assertEqual(err, b'')
+        self.assertEqual(out, '')
+        self.assertEqual(err, '')
 
 
 def test_suite():

=== modified file 'breezy/plugins/weave_fmt/test_bzrdir.py'
--- breezy/plugins/weave_fmt/test_bzrdir.py	2018-06-16 23:27:50 +0000
+++ breezy/plugins/weave_fmt/test_bzrdir.py	2018-07-14 19:37:12 +0000
@@ -124,8 +124,8 @@
         # break lock on a format 5 bzrdir should just return
         self.make_branch_and_tree('foo', format=BzrDirFormat5())
         out, err = self.run_bzr('break-lock foo')
-        self.assertEqual(b'', out)
-        self.assertEqual(b'', err)
+        self.assertEqual('', out)
+        self.assertEqual('', err)
 
 
 _upgrade1_template = \
@@ -455,7 +455,7 @@
         # U U U
         out, err = self.run_bzr('info -v branch')
         self.assertEqualDiff(
-b"""Standalone tree (format: weave)
+"""Standalone tree (format: weave)
 Location:
   branch root: %s
 
@@ -480,14 +480,14 @@
 
 Repository:
          0 revisions
-""" % (b'branch', tree.branch.repository._format.get_format_description().encode(),
+""" % ('branch', tree.branch.repository._format.get_format_description(),
        ), out)
-        self.assertEqual(b'', err)
+        self.assertEqual('', err)
         # L L L
         tree.lock_write()
         out, err = self.run_bzr('info -v branch')
         self.assertEqualDiff(
-b"""Standalone tree (format: weave)
+"""Standalone tree (format: weave)
 Location:
   branch root: %s
 
@@ -512,9 +512,9 @@
 
 Repository:
          0 revisions
-""" % (b'branch', tree.branch.repository._format.get_format_description().encode(),
+""" % ('branch', tree.branch.repository._format.get_format_description(),
        ), out)
-        self.assertEqual(b'', err)
+        self.assertEqual('', err)
         tree.unlock()
 
 
@@ -552,16 +552,16 @@
         # TODO: jam 20060427 Probably something like this really should
         #       print out the actual path, rather than the URL
         cwd = urlutils.local_path_to_url(getcwd())
-        self.assertEqual(b'brz: ERROR: To use this feature you must '
-                         b'upgrade your branch at %s/.\n' % cwd, err)
+        self.assertEqual('brz: ERROR: To use this feature you must '
+                         'upgrade your branch at %s/.\n' % cwd, err)
 
     def test_unbind_format_6_bzrdir(self):
         # bind on a format 6 bzrdir should error
         out, err = self.run_bzr('unbind', retcode=3)
         self.assertEqual(b'', out)
         cwd = urlutils.local_path_to_url(getcwd())
-        self.assertEqual(b'brz: ERROR: To use this feature you must '
-                         b'upgrade your branch at %s/.\n' % cwd, err)
+        self.assertEqual('brz: ERROR: To use this feature you must '
+                         'upgrade your branch at %s/.\n' % cwd, err)
 
 
 class TestInit(TestCaseWithTransport):
@@ -570,9 +570,9 @@
         # --format=weave should be accepted to allow interoperation with
         # old releases when desired.
         out, err = self.run_bzr('init --format=weave')
-        self.assertEqual(b"""Created a standalone tree (format: weave)\n""",
+        self.assertEqual("""Created a standalone tree (format: weave)\n""",
             out)
-        self.assertEqual(b'', err)
+        self.assertEqual('', err)
 
 
 class V4WeaveBundleTester(test_bundle.V4BundleTester):

=== modified file 'breezy/plugins/weave_fmt/test_repository.py'
--- breezy/plugins/weave_fmt/test_repository.py	2018-06-17 20:17:39 +0000
+++ breezy/plugins/weave_fmt/test_repository.py	2018-07-14 19:37:12 +0000
@@ -265,11 +265,11 @@
     def test_make_repository(self):
         out, err = self.run_bzr("init-repository --format=weave a")
         self.assertEqual(out,
-b"""Standalone tree (format: weave)
+"""Standalone tree (format: weave)
 Location:
   branch root: a
 """)
-        self.assertEqual(err, b"")
+        self.assertEqual(err, "")
 
     def test_is_compatible_and_registered(self):
         # InterWeaveRepo is compatible when either side

=== modified file 'breezy/tests/__init__.py'
--- breezy/tests/__init__.py	2018-07-09 20:53:02 +0000
+++ breezy/tests/__init__.py	2018-07-14 19:37:12 +0000
@@ -1934,9 +1934,14 @@
 
         self.log('run brz: %r', args)
 
-        stdout = ui_testing.BytesIOWithEncoding()
-        stderr = ui_testing.BytesIOWithEncoding()
-        stdout.encoding = stderr.encoding = encoding
+        if sys.version_info[0] == 2:
+            stdout = ui_testing.BytesIOWithEncoding()
+            stderr = ui_testing.BytesIOWithEncoding()
+            stdout.encoding = stderr.encoding = encoding
+        else:
+            stdout = ui_testing.StringIOWithEncoding()
+            stderr = ui_testing.StringIOWithEncoding()
+            stdout.encoding = stderr.encoding = encoding
 
         # FIXME: don't call into logging here
         handler = trace.EncodedStreamHandler(
@@ -2044,12 +2049,12 @@
         Examples of use::
 
             # Make sure that commit is failing because there is nothing to do
-            self.run_bzr_error([b'no changes to commit'],
+            self.run_bzr_error(['no changes to commit'],
                                ['commit', '-m', 'my commit comment'])
             # Make sure --strict is handling an unknown file, rather than
             # giving us the 'nothing to do' error
             self.build_tree(['unknown'])
-            self.run_bzr_error([b'Commit refused because there are unknown files'],
+            self.run_bzr_error(['Commit refused because there are unknown files'],
                                ['commit', --strict', '-m', 'my commit comment'])
         """
         kwargs.setdefault('retcode', 3)

=== modified file 'breezy/tests/blackbox/test_add.py'
--- breezy/tests/blackbox/test_add.py	2018-07-02 23:41:13 +0000
+++ breezy/tests/blackbox/test_add.py	2018-07-14 19:37:12 +0000
@@ -51,15 +51,15 @@
         self.build_tree_contents([('.bzrignore', b'CVS\n')])
         out = self.run_bzr('add')[0]
         # the ordering is not defined at the moment
-        results = sorted(out.rstrip(b'\n').split(b'\n'))
-        self.assertEqual([b'adding .bzrignore',
-                          b'adding dir',
-                          b'adding dir/sub.txt',
-                          b'adding top.txt'],
+        results = sorted(out.rstrip('\n').split('\n'))
+        self.assertEqual(['adding .bzrignore',
+                          'adding dir',
+                          'adding dir/sub.txt',
+                          'adding top.txt'],
                           results)
         out = self.run_bzr('add -v')[0]
-        results = sorted(out.rstrip(b'\n').split(b'\n'))
-        self.assertEqual([b'ignored CVS matching "CVS"'],
+        results = sorted(out.rstrip('\n').split('\n'))
+        self.assertEqual(['ignored CVS matching "CVS"'],
                           results)
 
     def test_add_quiet_is(self):
@@ -68,8 +68,8 @@
         self.build_tree(['top.txt', 'dir/', 'dir/sub.txt'])
         out = self.run_bzr('add -q')[0]
         # the ordering is not defined at the moment
-        results = sorted(out.rstrip(b'\n').split(b'\n'))
-        self.assertEqual([b''], results)
+        results = sorted(out.rstrip('\n').split('\n'))
+        self.assertEqual([''], results)
 
     def test_add_in_unversioned(self):
         """Try to add a file in an unversioned directory.
@@ -78,28 +78,28 @@
         """
         tree = self.make_branch_and_tree('.')
         self.build_tree(['inertiatic/', 'inertiatic/esp'])
-        self.assertEqual(self.run_bzr('unknowns')[0], b'inertiatic\n')
+        self.assertEqual(self.run_bzr('unknowns')[0], 'inertiatic\n')
         self.run_bzr('add inertiatic/esp')
-        self.assertEqual(self.run_bzr('unknowns')[0], b'')
+        self.assertEqual(self.run_bzr('unknowns')[0], '')
 
         # Multiple unversioned parents
         self.build_tree(['veil/', 'veil/cerpin/', 'veil/cerpin/taxt'])
-        self.assertEqual(self.run_bzr('unknowns')[0], b'veil\n')
+        self.assertEqual(self.run_bzr('unknowns')[0], 'veil\n')
         self.run_bzr('add veil/cerpin/taxt')
-        self.assertEqual(self.run_bzr('unknowns')[0], b'')
+        self.assertEqual(self.run_bzr('unknowns')[0], '')
 
         # Check whacky paths work
         self.build_tree(['cicatriz/', 'cicatriz/esp'])
-        self.assertEqual(self.run_bzr('unknowns')[0], b'cicatriz\n')
+        self.assertEqual(self.run_bzr('unknowns')[0], 'cicatriz\n')
         self.run_bzr('add inertiatic/../cicatriz/esp')
-        self.assertEqual(self.run_bzr('unknowns')[0], b'')
+        self.assertEqual(self.run_bzr('unknowns')[0], '')
 
     def test_add_no_recurse(self):
         tree = self.make_branch_and_tree('.')
         self.build_tree(['inertiatic/', 'inertiatic/esp'])
-        self.assertEqual(self.run_bzr('unknowns')[0], b'inertiatic\n')
+        self.assertEqual(self.run_bzr('unknowns')[0], 'inertiatic\n')
         self.run_bzr('add -N inertiatic')
-        self.assertEqual(self.run_bzr('unknowns')[0], b'inertiatic/esp\n')
+        self.assertEqual(self.run_bzr('unknowns')[0], 'inertiatic/esp\n')
 
     def test_add_in_versioned(self):
         """Try to add a file in a versioned directory.
@@ -108,11 +108,11 @@
         """
         tree = self.make_branch_and_tree('.')
         self.build_tree(['inertiatic/', 'inertiatic/esp'])
-        self.assertEqual(self.run_bzr('unknowns')[0], b'inertiatic\n')
+        self.assertEqual(self.run_bzr('unknowns')[0], 'inertiatic\n')
         self.run_bzr('add --no-recurse inertiatic')
-        self.assertEqual(self.run_bzr('unknowns')[0], b'inertiatic/esp\n')
+        self.assertEqual(self.run_bzr('unknowns')[0], 'inertiatic/esp\n')
         self.run_bzr('add inertiatic/esp')
-        self.assertEqual(self.run_bzr('unknowns')[0], b'')
+        self.assertEqual(self.run_bzr('unknowns')[0], '')
 
     def test_subdir_add(self):
         """Add in subdirectory should add only things from there down"""
@@ -133,7 +133,7 @@
         # add with no arguments in a subdirectory gets only files below that
         # subdirectory
         self.run_bzr('add', working_dir='src')
-        self.assertEqual(b'README\n',
+        self.assertEqual('README\n',
                           self.run_bzr('unknowns', working_dir='src')[0])
         # reopen to see the new changes
         t = t.controldir.open_workingtree('src')
@@ -142,7 +142,7 @@
 
         # add from the parent directory should pick up all file names
         self.run_bzr('add')
-        self.assertEqual(self.run_bzr('unknowns')[0], b'')
+        self.assertEqual(self.run_bzr('unknowns')[0], '')
         self.run_bzr('check')
 
     def test_add_missing(self):
@@ -161,10 +161,10 @@
 
         out, err = self.run_bzr('add --file-ids-from ../base',
                                 working_dir='new')
-        self.assertEqual(b'', err)
-        self.assertEqualDiff(b'adding a w/ file id from a\n'
-                             b'adding b w/ file id from b\n'
-                             b'adding b/c w/ file id from b/c\n',
+        self.assertEqual('', err)
+        self.assertEqualDiff('adding a w/ file id from a\n'
+                             'adding b w/ file id from b\n'
+                             'adding b/c w/ file id from b/c\n',
                              out)
         new_tree = new_tree.controldir.open_workingtree()
         self.assertEqual(base_tree.path2id('a'), new_tree.path2id('a'))
@@ -182,9 +182,9 @@
 
         out, err = self.run_bzr('add --file-ids-from ../base/b',
                                 working_dir='new')
-        self.assertEqual(b'', err)
-        self.assertEqualDiff(b'adding c w/ file id from b/c\n'
-                             b'adding d w/ file id from b/d\n',
+        self.assertEqual('', err)
+        self.assertEqualDiff('adding c w/ file id from b/c\n'
+                             'adding d w/ file id from b/d\n',
                              out)
 
         new_tree = new_tree.controldir.open_workingtree('new')
@@ -203,12 +203,12 @@
         """The control dir and its content should be refused."""
         self.make_branch_and_tree('.')
         err = self.run_bzr('add .bzr', retcode=3)[1]
-        self.assertContainsRe(err, br'ERROR:.*\.bzr.*control file')
+        self.assertContainsRe(err, r'ERROR:.*\.bzr.*control file')
         err = self.run_bzr('add .bzr/README', retcode=3)[1]
-        self.assertContainsRe(err, br'ERROR:.*\.bzr.*control file')
+        self.assertContainsRe(err, r'ERROR:.*\.bzr.*control file')
         self.build_tree(['.bzr/crescent'])
         err = self.run_bzr('add .bzr/crescent', retcode=3)[1]
-        self.assertContainsRe(err, br'ERROR:.*\.bzr.*control file')
+        self.assertContainsRe(err, r'ERROR:.*\.bzr.*control file')
 
     def test_add_via_symlink(self):
         self.requireFeature(features.SymlinkFeature)
@@ -216,14 +216,14 @@
         self.build_tree(['source/top.txt'])
         os.symlink('source', 'link')
         out = self.run_bzr(['add', 'link/top.txt'])[0]
-        self.assertEqual(out, b'adding top.txt\n')
+        self.assertEqual(out, 'adding top.txt\n')
 
     def test_add_symlink_to_abspath(self):
         self.requireFeature(features.SymlinkFeature)
         self.make_branch_and_tree('tree')
         os.symlink(osutils.abspath('target'), 'tree/link')
         out = self.run_bzr(['add', 'tree/link'])[0]
-        self.assertEqual(out, b'adding link\n')
+        self.assertEqual(out, 'adding link\n')
 
     def test_add_not_child(self):
         # https://bugs.launchpad.net/bzr/+bug/98735
@@ -242,8 +242,8 @@
         self.make_branch_and_tree(u"\xA7")
         self.build_tree([u"\xA7/a", u"\xA7/b"])
         out, err = self.run_bzr(["add", "a", "b"], working_dir=u"\xA7")
-        self.assertEqual(out, b"adding a\n" b"adding b\n")
-        self.assertEqual(err, b"")
+        self.assertEqual(out, "adding a\n" "adding b\n")
+        self.assertEqual(err, "")
 
     def test_add_skip_large_files(self):
         """Test skipping files larger than add.maximum_file_size"""
@@ -254,14 +254,14 @@
         self.build_tree_contents([('big2.txt', b'01234567890123456789\n')])
         tree.branch.get_config_stack().set('add.maximum_file_size', 5)
         out = self.run_bzr('add')[0]
-        results = sorted(out.rstrip(b'\n').split(b'\n'))
-        self.assertEqual([b'adding small.txt'], results)
+        results = sorted(out.rstrip('\n').split('\n'))
+        self.assertEqual(['adding small.txt'], results)
         # named items never skipped, even if over max
         out, err = self.run_bzr(["add", "big2.txt"])
-        results = sorted(out.rstrip(b'\n').split(b'\n'))
-        self.assertEqual([b'adding big2.txt'], results)
-        self.assertEqual(b"", err)
+        results = sorted(out.rstrip('\n').split('\n'))
+        self.assertEqual(['adding big2.txt'], results)
+        self.assertEqual("", err)
         tree.branch.get_config_stack().set('add.maximum_file_size', 30)
         out = self.run_bzr('add')[0]
-        results = sorted(out.rstrip(b'\n').split(b'\n'))
-        self.assertEqual([b'adding big.txt'], results)
+        results = sorted(out.rstrip('\n').split('\n'))
+        self.assertEqual(['adding big.txt'], results)

=== modified file 'breezy/tests/blackbox/test_added.py'
--- breezy/tests/blackbox/test_added.py	2018-06-29 15:36:29 +0000
+++ breezy/tests/blackbox/test_added.py	2018-07-14 19:37:12 +0000
@@ -28,15 +28,15 @@
 
     def test_added(self):
         """Test that 'added' command reports added files"""
-        self._test_added('a', b'a\n')
+        self._test_added('a', 'a\n')
 
     def test_added_with_spaces(self):
         """Test that 'added' command reports added files with spaces in their names quoted"""
-        self._test_added('a filename with spaces', b'"a filename with spaces"\n')
+        self._test_added('a filename with spaces', '"a filename with spaces"\n')
 
     def test_added_null_separator(self):
         """Test that added uses its null operator properly"""
-        self._test_added('a', b'a\0', null=True)
+        self._test_added('a', 'a\0', null=True)
 
     def _test_added(self, name, output, null=False):
 
@@ -48,15 +48,15 @@
 
             out, err = self.run_bzr(command)
             self.assertEqual(out, expected)
-            self.assertEqual(err, b'')
+            self.assertEqual(err, '')
 
         # in empty directory, nothing added
         tree = self.make_branch_and_tree('.')
-        check_added(b'')
+        check_added('')
 
         # with unknown file, still nothing added
         self.build_tree_contents([(name, b'contents of %s\n' % (name.encode('utf-8'),))])
-        check_added(b'')
+        check_added('')
 
         # after add, shows up in list
         # bug report 20060119 by Nathan McCallum -- 'brz added' causes
@@ -66,7 +66,7 @@
 
         # after commit, now no longer listed
         tree.commit(message='add "%s"' % (name))
-        check_added(b'')
+        check_added('')
 
     def test_added_directory(self):
         """Test --directory option"""
@@ -74,4 +74,4 @@
         self.build_tree(['a/README'])
         tree.add('README')
         out, err = self.run_bzr(['added', '--directory=a'])
-        self.assertEqual(b'README\n', out)
+        self.assertEqual('README\n', out)

=== modified file 'breezy/tests/blackbox/test_alias.py'
--- breezy/tests/blackbox/test_alias.py	2018-06-29 15:36:29 +0000
+++ breezy/tests/blackbox/test_alias.py	2018-07-14 19:37:12 +0000
@@ -31,21 +31,21 @@
     def test_list_alias_with_none(self):
         """Calling alias with no parameters lists existing aliases."""
         out, err = self.run_bzr('alias')
-        self.assertEqual(b'', out)
+        self.assertEqual('', out)
 
     def test_list_unknown_alias(self):
         out, err = self.run_bzr('alias commit')
-        self.assertEqual(b'brz alias: commit: not found\n', out)
+        self.assertEqual('brz alias: commit: not found\n', out)
 
     def test_add_alias_outputs_nothing(self):
         out, err = self.run_bzr('alias commit="commit --strict"')
-        self.assertEqual(b'', out)
+        self.assertEqual('', out)
 
     def test_add_alias_visible(self):
         """Adding an alias makes it ..."""
         self.run_bzr('alias commit="commit --strict"')
         out, err = self.run_bzr('alias commit')
-        self.assertEqual(b'brz alias commit="commit --strict"\n', out)
+        self.assertEqual('brz alias commit="commit --strict"\n', out)
 
     def test_unicode_alias(self):
         """Unicode aliases should work (Bug #529930)"""
@@ -63,8 +63,8 @@
             u'[ALIASES]\nust=st %s\n' % (file_name,), save=True)
 
         out, err = self.run_bzr('ust')
-        self.assertEqual(err, b'')
-        self.assertEqual(out, b'')
+        self.assertEqual(err, '')
+        self.assertEqual(out, '')
 
     def test_alias_listing_alphabetical(self):
         self.run_bzr('alias commit="commit --strict"')
@@ -73,23 +73,23 @@
 
         out, err = self.run_bzr('alias')
         self.assertEqual(
-            b'brz alias add="add -q"\n'
-            b'brz alias commit="commit --strict"\n'
-            b'brz alias ll="log --short"\n',
+            'brz alias add="add -q"\n'
+            'brz alias commit="commit --strict"\n'
+            'brz alias ll="log --short"\n',
             out)
 
     def test_remove_unknown_alias(self):
         out, err = self.run_bzr('alias --remove fooix', retcode=3)
-        self.assertEqual(b'brz: ERROR: The alias "fooix" does not exist.\n',
-                          err)
+        self.assertEqual('brz: ERROR: The alias "fooix" does not exist.\n',
+                         err)
 
     def test_remove_known_alias(self):
         self.run_bzr('alias commit="commit --strict"')
         out, err = self.run_bzr('alias commit')
-        self.assertEqual(b'brz alias commit="commit --strict"\n', out)
+        self.assertEqual('brz alias commit="commit --strict"\n', out)
         # No output when removing an existing alias.
         out, err = self.run_bzr('alias --remove commit')
-        self.assertEqual(b'', out)
+        self.assertEqual('', out)
         # Now its not.
         out, err = self.run_bzr('alias commit')
-        self.assertEqual(b"brz alias: commit: not found\n", out)
+        self.assertEqual("brz alias: commit: not found\n", out)

=== modified file 'breezy/tests/blackbox/test_aliases.py'
--- breezy/tests/blackbox/test_aliases.py	2018-06-29 15:36:29 +0000
+++ breezy/tests/blackbox/test_aliases.py	2018-07-14 19:37:12 +0000
@@ -41,8 +41,8 @@
 c2=cat -r 1 -r2
 ''', save=True)
 
-        str1 = b'foo\n'
-        str2 = b'bar\n'
+        str1 = 'foo\n'
+        str2 = 'bar\n'
 
         tree = self.make_branch_and_tree('.')
         self.build_tree_contents([('a', str1)])

=== modified file 'breezy/tests/blackbox/test_ancestry.py'
--- breezy/tests/blackbox/test_ancestry.py	2018-07-02 23:41:13 +0000
+++ breezy/tests/blackbox/test_ancestry.py	2018-07-14 19:37:12 +0000
@@ -45,9 +45,9 @@
         else:
             # A2 and B1 can be in either order, because they are parallel, and
             # thus their topological order is not defined
-            result = b"A1\nB1\nA2\nA3\n"
+            result = "A1\nB1\nA2\nA3\n"
             if result != out:
-                result = b"A1\nA2\nB1\nA3\n"
+                result = "A1\nA2\nB1\nA3\n"
             self.assertEqualDiff(result, out)
 
     def test_ancestry(self):
@@ -97,7 +97,7 @@
         repo_branch = a_tree.controldir.sprout('repo/A').open_branch()
         repo_branch.create_checkout('A-checkout',
                                     revision_id=repo_branch.get_rev_id(2))
-        self._check_ancestry('A-checkout', b"A1\nA2\n")
+        self._check_ancestry('A-checkout', "A1\nA2\n")
 
     def test_ancestry_with_truncated_lightweight_checkout(self):
         """Tests 'ancestry' command with a location that is a lightweight
@@ -108,4 +108,4 @@
         repo_branch.create_checkout('A-checkout',
                                     revision_id=repo_branch.get_rev_id(2),
                                     lightweight=True)
-        self._check_ancestry('A-checkout', b"A1\nA2\n")
+        self._check_ancestry('A-checkout', "A1\nA2\n")

=== modified file 'breezy/tests/blackbox/test_annotate.py'
--- breezy/tests/blackbox/test_annotate.py	2018-06-30 22:25:16 +0000
+++ breezy/tests/blackbox/test_annotate.py	2018-07-14 19:37:12 +0000
@@ -69,8 +69,8 @@
 
     def test_annotate_cmd(self):
         out, err = self.run_bzr('annotate hello.txt')
-        self.assertEqual(b'', err)
-        self.assertEqualDiff(b'''\
+        self.assertEqual('', err)
+        self.assertEqualDiff('''\
 1   test@us | my helicopter
 3   user@te | your helicopter
 4   user@te | all of
@@ -79,8 +79,8 @@
 
     def test_annotate_cmd_full(self):
         out, err = self.run_bzr('annotate hello.txt --all')
-        self.assertEqual(b'', err)
-        self.assertEqualDiff(b'''\
+        self.assertEqual('', err)
+        self.assertEqualDiff('''\
 1   test@us | my helicopter
 3   user@te | your helicopter
 4   user@te | all of
@@ -89,8 +89,8 @@
 
     def test_annotate_cmd_long(self):
         out, err = self.run_bzr('annotate hello.txt --long')
-        self.assertEqual(b'', err)
-        self.assertEqualDiff(b'''\
+        self.assertEqual('', err)
+        self.assertEqualDiff('''\
 1   test@user 20061212 | my helicopter
 3   user@test 20061213 | your helicopter
 4   user@test 20061213 | all of
@@ -102,37 +102,37 @@
         max_len = max([len(self.revision_id_1),
                        len(self.revision_id_3),
                        len(self.revision_id_4)])
-        self.assertEqual(b'', err)
-        self.assertEqualDiff(b'''\
+        self.assertEqual('', err)
+        self.assertEqualDiff('''\
 %*s | my helicopter
 %*s | your helicopter
 %*s | all of
 %*s | our helicopters
-''' % (max_len, self.revision_id_1,
-       max_len, self.revision_id_3,
-       max_len, self.revision_id_4,
-       max_len, b'',
+''' % (max_len, self.revision_id_1.decode('utf-8'),
+       max_len, self.revision_id_3.decode('utf-8'),
+       max_len, self.revision_id_4.decode('utf-8'),
+       max_len, '',
       )
 , out)
 
     def test_no_mail(self):
         out, err = self.run_bzr('annotate nomail.txt')
-        self.assertEqual(b'', err)
-        self.assertEqualDiff(b'''\
+        self.assertEqual('', err)
+        self.assertEqualDiff('''\
 2   no mail | nomail
 ''', out)
 
     def test_annotate_cmd_revision(self):
         out, err = self.run_bzr('annotate hello.txt -r1')
-        self.assertEqual(b'', err)
-        self.assertEqualDiff(b'''\
+        self.assertEqual('', err)
+        self.assertEqualDiff('''\
 1   test@us | my helicopter
 ''', out)
 
     def test_annotate_cmd_revision3(self):
         out, err = self.run_bzr('annotate hello.txt -r3')
-        self.assertEqual(b'', err)
-        self.assertEqualDiff(b'''\
+        self.assertEqual('', err)
+        self.assertEqualDiff('''\
 1   test@us | my helicopter
 3   user@te | your helicopter
 ''', out)
@@ -140,15 +140,15 @@
     def test_annotate_cmd_unknown_revision(self):
         out, err = self.run_bzr('annotate hello.txt -r 10',
                                 retcode=3)
-        self.assertEqual(b'', out)
-        self.assertContainsRe(err, b"Requested revision: '10' does not exist")
+        self.assertEqual('', out)
+        self.assertContainsRe(err, "Requested revision: '10' does not exist")
 
     def test_annotate_cmd_two_revisions(self):
         out, err = self.run_bzr('annotate hello.txt -r1..2',
                                 retcode=3)
-        self.assertEqual(b'', out)
-        self.assertEqual(b'brz: ERROR: brz annotate --revision takes'
-                         b' exactly one revision identifier\n',
+        self.assertEqual('', out)
+        self.assertEqual('brz: ERROR: brz annotate --revision takes'
+                         ' exactly one revision identifier\n',
                          err)
 
 
@@ -170,10 +170,10 @@
         tree.branch.create_checkout(self.get_url('work'), lightweight=True)
         out, err = self.run_bzr(['annotate', 'file', '-r', 'branch:../trunk'],
                                 working_dir='work')
-        self.assertEqual(b'', err)
+        self.assertEqual('', err)
         self.assertEqual(
-            b'1   test@ho | foo\n'
-            b'            | gam\n',
+            '1   test@ho | foo\n'
+            '            | gam\n',
             out)
 
     def test_annotate_edited_file(self):
@@ -260,7 +260,7 @@
         tree.add('empty')
         tree.commit('add empty file')
         out, err = self.run_bzr(['annotate', 'empty'])
-        self.assertEqual(b'', out)
+        self.assertEqual('', out)
 
     def test_annotate_removed_file(self):
         tree = self.make_branch_and_tree('.')
@@ -271,7 +271,7 @@
         tree.remove('empty')
         tree.commit('remove empty file')
         out, err = self.run_bzr(['annotate', '-r1', 'empty'])
-        self.assertEqual(b'', out)
+        self.assertEqual('', out)
 
     def test_annotate_empty_file_show_ids(self):
         tree = self.make_branch_and_tree('.')
@@ -279,7 +279,7 @@
         tree.add('empty')
         tree.commit('add empty file')
         out, err = self.run_bzr(['annotate', '--show-ids', 'empty'])
-        self.assertEqual(b'', out)
+        self.assertEqual('', out)
 
     def test_annotate_nonexistant_file(self):
         tree = self.make_branch_and_tree('.')
@@ -287,8 +287,8 @@
         tree.add(['file'])
         tree.commit('add a file')
         out, err = self.run_bzr(['annotate', 'doesnotexist'], retcode=3)
-        self.assertEqual(b'', out)
-        self.assertEqual(b"brz: ERROR: doesnotexist is not versioned.\n", err)
+        self.assertEqual('', out)
+        self.assertEqual("brz: ERROR: doesnotexist is not versioned.\n", err)
 
     def test_annotate_without_workingtree(self):
         tree = self.make_branch_and_tree('.')
@@ -299,7 +299,7 @@
         bzrdir.destroy_workingtree()
         self.assertFalse(bzrdir.has_workingtree())
         out, err = self.run_bzr(['annotate', 'empty'])
-        self.assertEqual(b'', out)
+        self.assertEqual('', out)
 
     def test_annotate_directory(self):
         """Test --directory option"""

=== modified file 'breezy/tests/blackbox/test_bound_branches.py'
--- breezy/tests/blackbox/test_bound_branches.py	2018-06-29 15:36:29 +0000
+++ breezy/tests/blackbox/test_bound_branches.py	2018-07-14 19:37:12 +0000
@@ -278,7 +278,7 @@
         """We should not be able to bind to a missing branch."""
         tree = self.make_branch_and_tree('tree_1')
         tree.commit('dummy commit')
-        self.run_bzr_error([b'Not a branch.*no-such-branch/'],
+        self.run_bzr_error(['Not a branch.*no-such-branch/'],
                            ['bind', '../no-such-branch'],
                            working_dir='tree_1')
         self.assertIs(None, tree.branch.get_bound_location())

=== modified file 'breezy/tests/blackbox/test_branch.py'
--- breezy/tests/blackbox/test_branch.py	2018-06-30 23:15:13 +0000
+++ breezy/tests/blackbox/test_branch.py	2018-07-14 19:37:12 +0000
@@ -83,18 +83,18 @@
         self.assertEqual(
             """Created a standalone tree (format: development-colo)\n""",
             out)
-        self.assertEqual(b'', err)
+        self.assertEqual('', err)
         out, err = self.run_bzr(
             'branch a file:b,branch=thiswasa')
-        self.assertEqual(b'', out)
-        self.assertEqual(b'Branched 2 revisions.\n', err)
+        self.assertEqual('', out)
+        self.assertEqual('Branched 2 revisions.\n', err)
         out, err = self.run_bzr('branches b')
-        self.assertEqual(b"  orig\n  thiswasa\n", out)
-        self.assertEqual(b'', err)
+        self.assertEqual("  orig\n  thiswasa\n", out)
+        self.assertEqual('', err)
         out, err = self.run_bzr('branch a file:b,branch=orig', retcode=3)
-        self.assertEqual(b'', out)
+        self.assertEqual('', out)
         self.assertEqual(
-            b'brz: ERROR: Already a branch: "file:b,branch=orig".\n', err)
+            'brz: ERROR: Already a branch: "file:b,branch=orig".\n', err)
 
     def test_from_colocated(self):
         """Branch from a colocated branch into a regular branch."""
@@ -102,8 +102,8 @@
         tree.controldir.create_branch(name='somecolo')
         out, err = self.run_bzr('branch %s,branch=somecolo' %
             local_path_to_url('a'))
-        self.assertEqual(b'', out)
-        self.assertEqual(b'Branched 0 revisions.\n', err)
+        self.assertEqual('', out)
+        self.assertEqual('Branched 0 revisions.\n', err)
         self.assertPathExists("somecolo")
 
     def test_branch_broken_pack(self):
@@ -124,7 +124,7 @@
             else:
                 corrupt = b'\xFF'
             f.write(corrupt) # make sure we corrupt something
-        self.run_bzr_error([b'Corruption while decompressing repository file'],
+        self.run_bzr_error(['Corruption while decompressing repository file'],
                             'branch a b', retcode=3)
 
     def test_branch_switch_no_branch(self):
@@ -132,7 +132,7 @@
         #  => new branch will be created, but switch fails
         self.example_branch('a')
         self.make_repository('current')
-        self.run_bzr_error([b'No WorkingTree exists for'],
+        self.run_bzr_error(['No WorkingTree exists for'],
             'branch --switch ../a ../b', working_dir='current')
         a = branch.Branch.open('a')
         b = branch.Branch.open('b')
@@ -144,7 +144,7 @@
         #     branch is unmodified
         self.example_branch('a')
         self.make_branch('current')
-        self.run_bzr_error([b'No WorkingTree exists for'],
+        self.run_bzr_error(['No WorkingTree exists for'],
             'branch --switch ../a ../b', working_dir='current')
         a = branch.Branch.open('a')
         b = branch.Branch.open('b')
@@ -159,7 +159,7 @@
         self.example_branch('a')
         tree = self.make_branch_and_tree('current')
         c1 = tree.commit('some diverged change')
-        self.run_bzr_error([b'Cannot switch a branch, only a checkout'],
+        self.run_bzr_error(['Cannot switch a branch, only a checkout'],
             'branch --switch ../a ../b', working_dir='current')
         a = branch.Branch.open('a')
         b = branch.Branch.open('b')
@@ -185,7 +185,7 @@
         self.assertEqual(a.last_revision(), b.last_revision())
         work = WorkingTree.open('current')
         self.assertEndsWith(work.branch.get_bound_location(), '/b/')
-        self.assertContainsRe(err, b"Switched to branch: .*/b/")
+        self.assertContainsRe(err, "Switched to branch: .*/b/")
 
     def test_branch_switch_lightweight_checkout(self):
         # Lightweight checkout in the current directory:
@@ -200,7 +200,7 @@
         self.assertEqual(a.last_revision(), b.last_revision())
         work = WorkingTree.open('current')
         self.assertEndsWith(work.branch.base, '/b/')
-        self.assertContainsRe(err, b"Switched to branch: .*/b/")
+        self.assertContainsRe(err, "Switched to branch: .*/b/")
 
     def test_branch_only_copies_history(self):
         # Knit branches should only push the history for the current revision.
@@ -296,8 +296,8 @@
         self.build_tree_contents([('b/goodbye', b'baz')])# same content
         # fails without --use-existing-dir
         out, err = self.run_bzr('branch a b', retcode=3)
-        self.assertEqual(b'', out)
-        self.assertEqual(b'brz: ERROR: Target directory "b" already exists.\n',
+        self.assertEqual('', out)
+        self.assertEqual('brz: ERROR: Target directory "b" already exists.\n',
             err)
         # force operation
         self.run_bzr('branch a b --use-existing-dir')
@@ -306,13 +306,13 @@
         self.assertPathDoesNotExist('b/godbye.moved')
         # we can't branch into branch
         out, err = self.run_bzr('branch a b --use-existing-dir', retcode=3)
-        self.assertEqual(b'', out)
-        self.assertEqual(b'brz: ERROR: Already a branch: "b".\n', err)
+        self.assertEqual('', out)
+        self.assertEqual('brz: ERROR: Already a branch: "b".\n', err)
 
     def test_branch_bind(self):
         self.example_branch('a')
         out, err = self.run_bzr('branch a b --bind')
-        self.assertEndsWith(err, b"New branch bound to a\n")
+        self.assertEndsWith(err, "New branch bound to a\n")
         b = branch.Branch.open('b')
         self.assertEndsWith(b.get_bound_location(), '/a/')
 
@@ -394,8 +394,8 @@
         # branching our local branch gives us a new stacked branch pointing at
         # mainline.
         out, err = self.run_bzr(['branch', 'branch', 'newbranch'])
-        self.assertEqual(b'', out)
-        self.assertEqual(b'Branched 2 revisions.\n',
+        self.assertEqual('', out)
+        self.assertEqual('Branched 2 revisions.\n',
             err)
         # it should have preserved the branch format, and so it should be
         # capable of supporting stacking, but not actually have a stacked_on
@@ -419,9 +419,9 @@
         work_tree.branch.push(branch_tree.branch)
         # you can chain branches on from there
         out, err = self.run_bzr(['branch', 'branch', '--stacked', 'branch2'])
-        self.assertEqual(b'', out)
-        self.assertEqual(b'Created new stacked branch referring to %s.\n' %
-            branch_tree.branch.base.encode('utf-8'), err)
+        self.assertEqual('', out)
+        self.assertEqual('Created new stacked branch referring to %s.\n' %
+            branch_tree.branch.base, err)
         self.assertEqual(branch_tree.branch.base,
             branch.Branch.open('branch2').get_stacked_on_url())
         branch2_tree = WorkingTree.open('branch2')
@@ -441,9 +441,9 @@
         # and a branch from it which is stacked
         out, err = self.run_bzr(['branch', '--stacked', 'mainline',
             'newbranch'])
-        self.assertEqual(b'', out)
-        self.assertEqual(b'Created new stacked branch referring to %s.\n' %
-            trunk_tree.branch.base.encode('utf-8'), err)
+        self.assertEqual('', out)
+        self.assertEqual('Created new stacked branch referring to %s.\n' %
+            trunk_tree.branch.base, err)
         self.assertRevisionNotInRepository('newbranch', original_revid)
         new_branch = branch.Branch.open('newbranch')
         self.assertEqual(trunk_tree.branch.base,
@@ -463,14 +463,14 @@
             ['branch', '--stacked', 'trunk', 'shallow'])
         # We should notify the user that we upgraded their format
         self.assertEqualDiff(
-            b'Source repository format does not support stacking, using format:\n'
-            b'  Packs 5 (adds stacking support, requires bzr 1.6)\n'
-            b'Source branch format does not support stacking, using format:\n'
-            b'  Branch format 7\n'
-            b'Doing on-the-fly conversion from RepositoryFormatKnitPack1() to RepositoryFormatKnitPack5().\n'
-            b'This may take some time. Upgrade the repositories to the same format for better performance.\n'
-            b'Created new stacked branch referring to %s.\n' %
-            (trunk.base.encode('utf-8'),),
+            'Source repository format does not support stacking, using format:\n'
+            '  Packs 5 (adds stacking support, requires bzr 1.6)\n'
+            'Source branch format does not support stacking, using format:\n'
+            '  Branch format 7\n'
+            'Doing on-the-fly conversion from RepositoryFormatKnitPack1() to RepositoryFormatKnitPack5().\n'
+            'This may take some time. Upgrade the repositories to the same format for better performance.\n'
+            'Created new stacked branch referring to %s.\n' %
+            (trunk.base,),
             err)
 
     def test_branch_stacked_from_rich_root_non_stackable(self):
@@ -479,13 +479,13 @@
             ['branch', '--stacked', 'trunk', 'shallow'])
         # We should notify the user that we upgraded their format
         self.assertEqualDiff(
-            b'Source repository format does not support stacking, using format:\n'
-            b'  Packs 5 rich-root (adds stacking support, requires bzr 1.6.1)\n'
-            b'Source branch format does not support stacking, using format:\n'
-            b'  Branch format 7\n'
-            b'Doing on-the-fly conversion from RepositoryFormatKnitPack4() to RepositoryFormatKnitPack5RichRoot().\n'
-            b'This may take some time. Upgrade the repositories to the same format for better performance.\n'
-            b'Created new stacked branch referring to %s.\n' % (trunk.base.encode('utf-8'),),
+            'Source repository format does not support stacking, using format:\n'
+            '  Packs 5 rich-root (adds stacking support, requires bzr 1.6.1)\n'
+            'Source branch format does not support stacking, using format:\n'
+            '  Branch format 7\n'
+            'Doing on-the-fly conversion from RepositoryFormatKnitPack4() to RepositoryFormatKnitPack5RichRoot().\n'
+            'This may take some time. Upgrade the repositories to the same format for better performance.\n'
+            'Created new stacked branch referring to %s.\n' % (trunk.base,),
             err)
 
 

=== modified file 'breezy/tests/blackbox/test_branches.py'
--- breezy/tests/blackbox/test_branches.py	2018-06-29 15:36:29 +0000
+++ breezy/tests/blackbox/test_branches.py	2018-07-14 19:37:12 +0000
@@ -28,24 +28,24 @@
         # support.
         self.run_bzr('init a')
         out, err = self.run_bzr('branches a')
-        self.assertEqual(out, b"* (default)\n")
+        self.assertEqual(out, "* (default)\n")
 
     def test_no_branch(self):
         # Listing the branches in a control directory without branches.
         self.run_bzr('init-repo a')
         out, err = self.run_bzr('branches a')
-        self.assertEqual(out, b"")
+        self.assertEqual(out, "")
 
     def test_default_current_dir(self):
         # "brz branches" list the branches in the current directory
         # if no location was specified.
         self.run_bzr('init-repo a')
         out, err = self.run_bzr('branches', working_dir='a')
-        self.assertEqual(out, b"")
+        self.assertEqual(out, "")
 
     def test_recursive_current(self):
         self.run_bzr('init .')
-        self.assertEqual(b".\n", self.run_bzr('branches --recursive')[0])
+        self.assertEqual(".\n", self.run_bzr('branches --recursive')[0])
 
     def test_recursive(self):
         self.run_bzr('init source')
@@ -54,20 +54,20 @@
         self.run_bzr('init checkout/subcheckout')
         self.run_bzr('init checkout/.bzr/subcheckout')
         out = self.run_bzr('branches --recursive')[0]
-        lines = out.split(b'\n')
-        self.assertIs(True, b'source' in lines, lines)
-        self.assertIs(True, b'source/subsource' in lines, lines)
-        self.assertIs(True, b'checkout/subcheckout' in lines, lines)
-        self.assertIs(True, b'checkout' not in lines, lines)
+        lines = out.split('\n')
+        self.assertIs(True, 'source' in lines, lines)
+        self.assertIs(True, 'source/subsource' in lines, lines)
+        self.assertIs(True, 'checkout/subcheckout' in lines, lines)
+        self.assertIs(True, 'checkout' not in lines, lines)
 
     def test_indicates_non_branch(self):
         t = self.make_branch_and_tree('a', format='development-colo')
         t.controldir.create_branch(name='another')
         t.controldir.create_branch(name='colocated')
         out, err = self.run_bzr('branches a')
-        self.assertEqual(out, b"* (default)\n"
-                              b"  another\n"
-                              b"  colocated\n")
+        self.assertEqual(out, "* (default)\n"
+                              "  another\n"
+                              "  colocated\n")
 
     def test_indicates_branch(self):
         t = self.make_repository('a', format='development-colo')
@@ -75,8 +75,8 @@
         branch = t.controldir.create_branch(name='colocated')
         t.controldir.set_branch_reference(target_branch=branch)
         out, err = self.run_bzr('branches a')
-        self.assertEqual(out, b"  another\n"
-                              b"* colocated\n")
+        self.assertEqual(out, "  another\n"
+                              "* colocated\n")
 
     def test_shared_repos(self):
         self.make_repository('a', shared=True)
@@ -84,10 +84,10 @@
         b = BzrDir.create_branch_convenience('a/branch2')
         b.create_checkout(lightweight=True, to_location='b')
         out, err = self.run_bzr('branches b')
-        self.assertEqual(out, b"  branch1\n"
-                              b"* branch2\n")
+        self.assertEqual(out, "  branch1\n"
+                              "* branch2\n")
 
     def test_standalone_branch(self):
         self.make_branch('a')
         out, err = self.run_bzr('branches a')
-        self.assertEqual(out, b"* (default)\n")
+        self.assertEqual(out, "* (default)\n")

=== modified file 'breezy/tests/blackbox/test_break_lock.py'
--- breezy/tests/blackbox/test_break_lock.py	2018-06-29 15:36:29 +0000
+++ breezy/tests/blackbox/test_break_lock.py	2018-07-14 19:37:12 +0000
@@ -67,7 +67,7 @@
     def test_break_lock_help(self):
         out, err = self.run_bzr('break-lock --help')
         # shouldn't fail and should not produce error output
-        self.assertEqual(b'', err)
+        self.assertEqual('', err)
 
     def test_break_lock_no_interaction(self):
         """With --force, the user isn't asked for confirmation"""

=== modified file 'breezy/tests/blackbox/test_bundle_info.py'
--- breezy/tests/blackbox/test_bundle_info.py	2018-06-29 17:57:21 +0000
+++ breezy/tests/blackbox/test_bundle_info.py	2018-07-14 19:37:12 +0000
@@ -37,7 +37,7 @@
         self.assertContainsRe(info, b'file: [12] .0 multiparent.')
         self.assertContainsRe(info, b'nicks: source')
         self.assertNotContainsRe(info, b'foo')
-        self.run_bzr_error([b'--verbose requires a merge directive'],
+        self.run_bzr_error(['--verbose requires a merge directive'],
                            'bundle-info -v bundle')
         target = self.make_branch('target')
         md = merge_directive.MergeDirective2.from_objects(

=== modified file 'breezy/tests/blackbox/test_cat.py'
--- breezy/tests/blackbox/test_cat.py	2018-06-29 15:36:29 +0000
+++ breezy/tests/blackbox/test_cat.py	2018-07-14 19:37:12 +0000
@@ -93,28 +93,28 @@
             tree.add(['e-rev'])
 
         # 'b-tree' is not present in the old tree.
-        self.run_bzr_error([b"^brz: ERROR: u?'b-tree' "
-                            b"is not present in revision .+$"],
+        self.run_bzr_error(["^brz: ERROR: u?'b-tree' "
+                            "is not present in revision .+$"],
                            'cat b-tree --name-from-revision')
 
         # get to the old file automatically
         out, err = self.run_bzr('cat d-rev')
-        self.assertEqual(b'', err)
-        self.assertEqual(b'bar\n', out)
+        self.assertEqual('', err)
+        self.assertEqual('bar\n', out)
 
         out, err = \
                 self.run_bzr('cat a-rev-tree --name-from-revision')
-        self.assertEqual(b'foo\n', out)
-        self.assertEqual(b'', err)
+        self.assertEqual('foo\n', out)
+        self.assertEqual('', err)
 
         out, err = self.run_bzr('cat a-rev-tree')
-        self.assertEqual(b'baz\n', out)
-        self.assertEqual(b'', err)
+        self.assertEqual('baz\n', out)
+        self.assertEqual('', err)
 
         # the actual file-id for e-rev doesn't exist in the old tree
         out, err = self.run_bzr('cat e-rev -rrevid:first')
-        self.assertEqual(b'qux\n', out)
-        self.assertEqual(b'', err)
+        self.assertEqual('qux\n', out)
+        self.assertEqual('', err)
 
     def test_remote_cat(self):
         wt = self.make_branch_and_tree('.')
@@ -124,7 +124,7 @@
 
         url = self.get_readonly_url() + '/README'
         out, err = self.run_bzr(['cat', url])
-        self.assertEqual(b'contents of README\n', out)
+        self.assertEqual('contents of README\n', out)
 
     def test_cat_branch_revspec(self):
         wt = self.make_branch_and_tree('a')
@@ -135,7 +135,7 @@
 
         out, err = self.run_bzr(['cat', '-r', 'branch:../a', 'README'],
                                 working_dir='b')
-        self.assertEqual(b'contents of a/README\n', out)
+        self.assertEqual('contents of a/README\n', out)
 
     def test_cat_filters(self):
         wt = self.make_branch_and_tree('.')
@@ -146,11 +146,11 @@
 
         # Test unfiltered output
         out, err = self.run_bzr(['cat', url])
-        self.assertEqual(b'contents of README\n', out)
+        self.assertEqual('contents of README\n', out)
 
         # Test --filters option is legal but has no impact if no filters
         out, err = self.run_bzr(['cat', '--filters', url])
-        self.assertEqual(b'contents of README\n', out)
+        self.assertEqual('contents of README\n', out)
 
     def test_cat_filters_applied(self):
         # Test filtering applied to output. This is tricky to do in a
@@ -173,8 +173,8 @@
         try:
             out, err = self.run_bzr(['cat', url, '--filters'])
             # The filter stack will remove the first line and swapcase the rest
-            self.assertEqual(b'LINE 1 OF readme\nLINE 2 OF readme\n', out)
-            self.assertEqual(b'', err)
+            self.assertEqual('LINE 1 OF readme\nLINE 2 OF readme\n', out)
+            self.assertEqual('', err)
         finally:
             Tree._content_filter_stack = real_content_filter_stack
 
@@ -187,11 +187,11 @@
 
         url = self.get_readonly_url() + '/README'
         out, err = self.run_bzr(['cat', url])
-        self.assertEqual(b'contents of README\n', out)
+        self.assertEqual('contents of README\n', out)
 
     def test_cat_nonexistent_branch(self):
         self.vfs_transport_factory = memory.MemoryServer
-        self.run_bzr_error([b'^brz: ERROR: Not a branch'],
+        self.run_bzr_error(['^brz: ERROR: Not a branch'],
                            ['cat', self.get_url()])
 
     def test_cat_directory(self):
@@ -201,7 +201,7 @@
         wt.commit('Making sure there is a basis_tree available')
 
         out, err = self.run_bzr(['cat', '--directory=a', 'README'])
-        self.assertEqual(b'contents of a/README\n', out)
+        self.assertEqual('contents of a/README\n', out)
 
     def test_cat_remote_directory(self):
         wt = self.make_branch_and_tree('a')
@@ -211,7 +211,7 @@
 
         url = self.get_readonly_url() + '/a'
         out, err = self.run_bzr(['cat', '-d', url, 'README'])
-        self.assertEqual(b'contents of a/README\n', out)
+        self.assertEqual('contents of a/README\n', out)
 
 
 class TestSmartServerCat(tests.TestCaseWithTransport):

=== modified file 'breezy/tests/blackbox/test_cat_revision.py'
--- breezy/tests/blackbox/test_cat_revision.py	2018-07-03 02:40:57 +0000
+++ breezy/tests/blackbox/test_cat_revision.py	2018-07-14 19:37:12 +0000
@@ -24,8 +24,8 @@
         tree = self.make_branch_and_tree('.')
         tree.commit('This revision', rev_id=b'abcd')
         output, errors = self.run_bzr(['cat-revision', u'abcd'])
-        self.assertContainsRe(output, b'This revision')
-        self.assertEqual(b'', errors)
+        self.assertContainsRe(output, 'This revision')
+        self.assertEqual('', errors)
 
     def test_cat_revision(self):
         """Test brz cat-revision.
@@ -56,20 +56,20 @@
     def test_cat_no_such_revid(self):
         tree = self.make_branch_and_tree('.')
         err = self.run_bzr('cat-revision abcd', retcode=3)[1]
-        self.assertContainsRe(err, b'The repository .* contains no revision abcd.')
+        self.assertContainsRe(err, 'The repository .* contains no revision abcd.')
 
     def test_cat_revision_directory(self):
         """Test --directory option"""
         tree = self.make_branch_and_tree('a')
         tree.commit('This revision', rev_id=b'abcd')
         output, errors = self.run_bzr(['cat-revision', '-d', 'a', u'abcd'])
-        self.assertContainsRe(output, b'This revision')
-        self.assertEqual(b'', errors)
+        self.assertContainsRe(output, 'This revision')
+        self.assertEqual('', errors)
 
     def test_cat_tree_less_branch(self):
         tree = self.make_branch_and_tree('.')
         tree.commit('This revision', rev_id=b'abcd')
         tree.controldir.destroy_workingtree()
         output, errors = self.run_bzr(['cat-revision', '-d', 'a', u'abcd'])
-        self.assertContainsRe(output, b'This revision')
-        self.assertEqual(b'', errors)
+        self.assertContainsRe(output, 'This revision')
+        self.assertEqual('', errors)

=== modified file 'breezy/tests/blackbox/test_check.py'
--- breezy/tests/blackbox/test_check.py	2018-06-29 15:36:29 +0000
+++ breezy/tests/blackbox/test_check.py	2018-07-14 19:37:12 +0000
@@ -34,46 +34,46 @@
         tree = self.make_branch_and_tree('.')
         tree.commit('hallelujah')
         out, err = self.run_bzr('check')
-        self.assertContainsRe(err, br"Checking working tree at '.*'\.\n")
-        self.assertContainsRe(err, br"Checking repository at '.*'\.\n")
+        self.assertContainsRe(err, r"Checking working tree at '.*'\.\n")
+        self.assertContainsRe(err, r"Checking repository at '.*'\.\n")
         # the root directory may be in the texts for rich root formats
-        self.assertContainsRe(err, br"checked repository.*\n"
-                                   br"     1 revisions\n"
-                                   br"     [01] file-ids\n"
+        self.assertContainsRe(err, r"checked repository.*\n"
+                                   r"     1 revisions\n"
+                                   r"     [01] file-ids\n"
                                    )
-        self.assertContainsRe(err, br"Checking branch at '.*'\.\n")
-        self.assertContainsRe(err, br"checked branch.*")
+        self.assertContainsRe(err, r"Checking branch at '.*'\.\n")
+        self.assertContainsRe(err, r"checked branch.*")
 
     def test_check_branch(self):
         tree = self.make_branch_and_tree('.')
         tree.commit('foo')
         out, err = self.run_bzr('check --branch')
-        self.assertContainsRe(err, br"^Checking branch at '.*'\.\n"
-                                   br"checked branch.*")
+        self.assertContainsRe(err, r"^Checking branch at '.*'\.\n"
+                                   r"checked branch.*")
 
     def test_check_repository(self):
         tree = self.make_branch_and_tree('.')
         tree.commit('foo')
         out, err = self.run_bzr('check --repo')
-        self.assertContainsRe(err, br"^Checking repository at '.*'\.\n"
-                                   br"checked repository.*\n"
-                                   br"     1 revisions\n"
-                                   br"     [01] file-ids\n"
+        self.assertContainsRe(err, r"^Checking repository at '.*'\.\n"
+                                   r"checked repository.*\n"
+                                   r"     1 revisions\n"
+                                   r"     [01] file-ids\n"
                                    )
 
     def test_check_tree(self):
         tree = self.make_branch_and_tree('.')
         tree.commit('foo')
         out, err = self.run_bzr('check --tree')
-        self.assertContainsRe(err, br"^Checking working tree at '.*'\.\n$")
+        self.assertContainsRe(err, r"^Checking working tree at '.*'\.\n$")
 
     def test_partial_check(self):
         tree = self.make_branch_and_tree('.')
         tree.commit('foo')
         out, err = self.run_bzr('check --tree --branch')
-        self.assertContainsRe(err, br"^Checking working tree at '.*'\.\n"
-                                   br"Checking branch at '.*'\.\n"
-                                   br"checked branch.*")
+        self.assertContainsRe(err, r"^Checking working tree at '.*'\.\n"
+                                   r"Checking branch at '.*'\.\n"
+                                   r"checked branch.*")
 
     def test_check_missing_tree(self):
         branch = self.make_branch('.')
@@ -84,14 +84,14 @@
         branch = self.make_branch('.')
         out, err = self.run_bzr('check --tree --branch')
         self.assertContainsRe(err,
-            br"Checking branch at '.*'\.\n"
-            br"No working tree found at specified location\.\n"
-            br"checked branch.*")
+            r"Checking branch at '.*'\.\n"
+            r"No working tree found at specified location\.\n"
+            r"checked branch.*")
 
     def test_check_missing_branch_in_shared_repo(self):
         self.make_repository('shared', shared=True)
         out, err = self.run_bzr('check --branch shared')
-        self.assertEqual(err, b"No branch found at specified location.\n")
+        self.assertEqual(err, "No branch found at specified location.\n")
 
 
 class ChrootedCheckTests(ChrootedTestCase):
@@ -99,14 +99,14 @@
     def test_check_missing_branch(self):
         out, err = self.run_bzr(
             'check --branch %s' % self.get_readonly_url(''))
-        self.assertEqual(err, b"No branch found at specified location.\n")
+        self.assertEqual(err, "No branch found at specified location.\n")
 
     def test_check_missing_repository(self):
         out, err = self.run_bzr('check --repo %s' % self.get_readonly_url(''))
-        self.assertEqual(err, b"No repository found at specified location.\n")
+        self.assertEqual(err, "No repository found at specified location.\n")
 
     def test_check_missing_everything(self):
         out, err = self.run_bzr('check %s' % self.get_readonly_url(''))
-        self.assertEqual(err, b"No working tree found at specified location.\n"
-                              b"No branch found at specified location.\n"
-                              b"No repository found at specified location.\n")
+        self.assertEqual(err, "No working tree found at specified location.\n"
+                              "No branch found at specified location.\n"
+                              "No repository found at specified location.\n")

=== modified file 'breezy/tests/blackbox/test_command_encoding.py'
--- breezy/tests/blackbox/test_command_encoding.py	2018-06-29 15:36:29 +0000
+++ breezy/tests/blackbox/test_command_encoding.py	2018-07-14 19:37:12 +0000
@@ -54,7 +54,7 @@
 
         register_command(cmd_echo_exact)
         try:
-            self.assertEqual(b'foo', bzr('echo-exact foo'))
+            self.assertEqual('foo', bzr('echo-exact foo'))
             # Exact should fail to decode the string
             self.assertRaises(UnicodeEncodeError,
                 bzr,
@@ -71,7 +71,7 @@
 
         register_command(cmd_echo_strict)
         try:
-            self.assertEqual(b'foo', bzr('echo-strict foo'))
+            self.assertEqual('foo', bzr('echo-strict foo'))
             self.assertEqual(u'foo\xb5'.encode('utf-8'),
                              bzr(['echo-strict', u'foo\xb5']))
         finally:
@@ -84,7 +84,7 @@
 
         register_command(cmd_echo_strict)
         try:
-            self.assertEqual(b'foo', bzr('echo-strict foo'))
+            self.assertEqual('foo', bzr('echo-strict foo'))
             # ascii can't encode \xb5
             self.assertRaises(UnicodeEncodeError,
                 bzr,
@@ -99,7 +99,7 @@
 
         register_command(cmd_echo_replace)
         try:
-            self.assertEqual(b'foo', bzr('echo-replace foo'))
+            self.assertEqual('foo', bzr('echo-replace foo'))
             self.assertEqual(u'foo\xb5'.encode('utf-8'),
                              bzr(['echo-replace', u'foo\xb5']))
         finally:
@@ -112,9 +112,9 @@
 
         register_command(cmd_echo_replace)
         try:
-            self.assertEqual(b'foo', bzr('echo-replace foo'))
+            self.assertEqual('foo', bzr('echo-replace foo'))
             # ascii can't encode \xb5
-            self.assertEqual(b'foo?', bzr(['echo-replace', u'foo\xb5']))
+            self.assertEqual('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-08 15:47:10 +0000
+++ breezy/tests/blackbox/test_commit.py	2018-07-14 19:37:12 +0000
@@ -47,7 +47,7 @@
         self.make_branch_and_tree('.')
         self.build_tree(['hello.txt'])
         out, err = self.run_bzr('commit -m empty', retcode=3)
-        self.assertEqual(b'', out)
+        self.assertEqual('', out)
         # Two ugly bits here.
         # 1) We really don't want 'aborting commit write group' anymore.
         # 2) brz: ERROR: is a really long line, so we wrap it with '\'
@@ -109,10 +109,10 @@
         self.build_tree(['hello.txt'])
         tree.add("hello.txt")
         out, err = self.run_bzr('commit -m added')
-        self.assertEqual(b'', out)
-        self.assertContainsRe(err, b'^Committing to: .*\n'
-                              b'added hello.txt\n'
-                              b'Committed revision 1.\n$',)
+        self.assertEqual('', out)
+        self.assertContainsRe(err, '^Committing to: .*\n'
+                              'added hello.txt\n'
+                              'Committed revision 1.\n$',)
 
     def prepare_simple_history(self):
         """Prepare and return a working tree with one commit of one file"""
@@ -128,10 +128,10 @@
         wt = self.prepare_simple_history()
         self.build_tree_contents([('hello.txt', b'new contents')])
         out, err = self.run_bzr('commit -m modified')
-        self.assertEqual(b'', out)
-        self.assertContainsRe(err, b'^Committing to: .*\n'
-                              b'modified hello\\.txt\n'
-                              b'Committed revision 2\\.\n$')
+        self.assertEqual('', out)
+        self.assertContainsRe(err, '^Committing to: .*\n'
+                              'modified hello\\.txt\n'
+                              'Committed revision 2\\.\n$')
 
     def test_unicode_commit_message_is_filename(self):
         """Unicode commit message same as a filename (Bug #563646).
@@ -177,7 +177,7 @@
         tree.add(["f"])
         out, err = self.run_bzr(["commit", "-m", "Wrong filename", u"\xa7"],
             encoding="utf-8", retcode=3)
-        self.assertContainsRe(err, b"(?m)not versioned: \"\xc2\xa7\"$")
+        self.assertContainsRe(err, "(?m)not versioned: \"\xc2\xa7\"$")
 
     def test_non_ascii_file_unversioned_iso_8859_5(self):
         self.requireFeature(features.UnicodeFilenameFeature)
@@ -188,7 +188,7 @@
             encoding="iso-8859-5", retcode=3)
         self.expectFailure("Error messages are always written as UTF-8",
             self.assertNotContainsString, err, "\xc2\xa7")
-        self.assertContainsRe(err, b"(?m)not versioned: \"\xfd\"$")
+        self.assertContainsRe(err, "(?m)not versioned: \"\xfd\"$")
 
     def test_warn_about_forgotten_commit_message(self):
         """Test that the lack of -m parameter is caught"""
@@ -196,17 +196,17 @@
         self.build_tree(['one', 'two'])
         wt.add(['two'])
         out, err = self.run_bzr('commit -m one two')
-        self.assertContainsRe(err, b"The commit message is a file name")
+        self.assertContainsRe(err, "The commit message is a file name")
 
     def test_verbose_commit_renamed(self):
         # Verbose commit of renamed file should say so
         wt = self.prepare_simple_history()
         wt.rename_one('hello.txt', 'gutentag.txt')
         out, err = self.run_bzr('commit -m renamed')
-        self.assertEqual(b'', out)
-        self.assertContainsRe(err, b'^Committing to: .*\n'
-                              b'renamed hello\\.txt => gutentag\\.txt\n'
-                              b'Committed revision 2\\.$\n')
+        self.assertEqual('', out)
+        self.assertContainsRe(err, '^Committing to: .*\n'
+                              'renamed hello\\.txt => gutentag\\.txt\n'
+                              'Committed revision 2\\.$\n')
 
     def test_verbose_commit_moved(self):
         # Verbose commit of file moved to new directory should say so
@@ -215,13 +215,13 @@
         wt.add(['subdir'])
         wt.rename_one('hello.txt', 'subdir/hello.txt')
         out, err = self.run_bzr('commit -m renamed')
-        self.assertEqual(b'', out)
+        self.assertEqual('', out)
         self.assertEqual({
-            b'Committing to: %s/' % osutils.getcwd(),
-            b'added subdir',
-            b'renamed hello.txt => subdir/hello.txt',
-            b'Committed revision 2.',
-            b'',
+            'Committing to: %s/' % osutils.getcwd(),
+            'added subdir',
+            'renamed hello.txt => subdir/hello.txt',
+            'Committed revision 2.',
+            '',
             }, set(err.split('\n')))
 
     def test_verbose_commit_with_unknown(self):
@@ -231,10 +231,10 @@
         self.build_tree(['hello.txt', 'extra.txt'])
         wt.add(['hello.txt'])
         out, err = self.run_bzr('commit -m added')
-        self.assertEqual(b'', out)
-        self.assertContainsRe(err, b'^Committing to: .*\n'
-                              b'added hello\\.txt\n'
-                              b'Committed revision 1\\.\n$')
+        self.assertEqual('', out)
+        self.assertContainsRe(err, '^Committing to: .*\n'
+                              'added hello\\.txt\n'
+                              'Committed revision 1\\.\n$')
 
     def test_verbose_commit_with_unchanged(self):
         """Unchanged files should not be listed by default in verbose output"""
@@ -244,10 +244,10 @@
         self.run_bzr('commit -m unchanged unchanged.txt')
         tree.add("hello.txt")
         out, err = self.run_bzr('commit -m added')
-        self.assertEqual(b'', out)
-        self.assertContainsRe(err, b'^Committing to: .*\n'
-                              b'added hello\\.txt\n'
-                              b'Committed revision 2\\.$\n')
+        self.assertEqual('', out)
+        self.assertContainsRe(err, '^Committing to: .*\n'
+                              'added hello\\.txt\n'
+                              'Committed revision 2\\.$\n')
 
     def test_verbose_commit_includes_master_location(self):
         """Location of master is displayed when committing to bound branch"""
@@ -331,21 +331,21 @@
             other_tree.unlock()
         this_tree.merge_from_branch(other_tree.branch)
         out, err = self.run_bzr('commit -m added', working_dir='this')
-        self.assertEqual(b'', out)
+        self.assertEqual('', out)
         self.assertEqual({
-            b'Committing to: %s/' % osutils.pathjoin(osutils.getcwd().encode('utf-8'), 'this'),
-            b'modified filetomodify',
-            b'added newdir',
-            b'added newfile',
-            b'renamed dirtorename => renameddir',
-            b'renamed filetorename => renamedfile',
-            b'renamed dirtoreparent => renameddir/reparenteddir',
-            b'renamed filetoreparent => renameddir/reparentedfile',
-            b'deleted dirtoremove',
-            b'deleted filetoremove',
-            b'Committed revision 2.',
-            b''
-            }, set(err.split(b'\n')))
+            'Committing to: %s/' % osutils.pathjoin(osutils.getcwd(), 'this'),
+            'modified filetomodify',
+            'added newdir',
+            'added newfile',
+            'renamed dirtorename => renameddir',
+            'renamed filetorename => renamedfile',
+            'renamed dirtoreparent => renameddir/reparenteddir',
+            'renamed filetoreparent => renameddir/reparentedfile',
+            'deleted dirtoremove',
+            'deleted filetoremove',
+            'Committed revision 2.',
+            ''
+            }, set(err.split('\n')))
 
     def test_empty_commit_message(self):
         tree = self.make_branch_and_tree('.')
@@ -369,7 +369,7 @@
         # can commit to branch - records bar.c
         self.run_bzr('commit -m newstuff branch')
         # No changes left
-        self.run_bzr_error([b"No changes to commit"], 'commit -m newstuff branch')
+        self.run_bzr_error(["No changes to commit"], 'commit -m newstuff branch')
 
     def test_out_of_date_tree_commit(self):
         # check we get an error code and a clear message committing with an out
@@ -443,12 +443,12 @@
         self.build_tree(['a', 'b', 'c'])
         tree.smart_add(['.'])
         out, err = self.run_bzr(['commit', '-m', 'test', '-x', 'b'])
-        self.assertFalse(b'added b' in out)
-        self.assertFalse(b'added b' in err)
+        self.assertFalse('added b' in out)
+        self.assertFalse('added b' in err)
         # If b was excluded it will still be 'added' in status.
         out, err = self.run_bzr(['added'])
-        self.assertEqual(b'b\n', out)
-        self.assertEqual(b'', err)
+        self.assertEqual('b\n', out)
+        self.assertEqual('', err)
 
     def test_commit_exclude_twice_uses_both_rules(self):
         """Commit -x foo -x bar should ignore changes to foo and bar."""
@@ -456,15 +456,15 @@
         self.build_tree(['a', 'b', 'c'])
         tree.smart_add(['.'])
         out, err = self.run_bzr(['commit', '-m', 'test', '-x', 'b', '-x', 'c'])
-        self.assertFalse(b'added b' in out)
-        self.assertFalse(b'added c' in out)
-        self.assertFalse(b'added b' in err)
-        self.assertFalse(b'added c' in err)
+        self.assertFalse('added b' in out)
+        self.assertFalse('added c' in out)
+        self.assertFalse('added b' in err)
+        self.assertFalse('added c' in err)
         # If b was excluded it will still be 'added' in status.
         out, err = self.run_bzr(['added'])
-        self.assertTrue(b'b\n' in out)
-        self.assertTrue(b'c\n' in out)
-        self.assertEqual(b'', err)
+        self.assertTrue('b\n' in out)
+        self.assertTrue('c\n' in out)
+        self.assertEqual('', err)
 
     def test_commit_respects_spec_for_removals(self):
         """Commit with a file spec should only commit removals that match"""
@@ -497,7 +497,7 @@
 
         # With no changes, it should just be 'no changes'
         # Make sure that commit is failing because there is nothing to do
-        self.run_bzr_error([b'No changes to commit'],
+        self.run_bzr_error(['No changes to commit'],
                            'commit --strict -m no-changes',
                            working_dir='tree')
 
@@ -515,7 +515,7 @@
         # Add one file so there is a change, but forget the other
         self.build_tree(['tree/b', 'tree/c'])
         tree.add('b')
-        self.run_bzr_error([b'Commit refused because there are unknown files'],
+        self.run_bzr_error(['Commit refused because there are unknown files'],
                            'commit --strict -m add-b',
                            working_dir='tree')
 
@@ -530,10 +530,10 @@
         tree.add('hello.txt')
         output, err = self.run_bzr(
             'commit -m hello --fixes=lp:23452 tree/hello.txt')
-        self.assertEqual(b'', output)
-        self.assertContainsRe(err, b'Committing to: .*\n'
-                              b'added hello\\.txt\n'
-                              b'Committed revision 1\\.\n')
+        self.assertEqual('', output)
+        self.assertContainsRe(err, 'Committing to: .*\n'
+                              'added hello\\.txt\n'
+                              'Committed revision 1\\.\n')
 
     def test_fixes_bug_unicode(self):
         """commit --fixes=lp:unicode succeeds without output."""
@@ -544,7 +544,7 @@
             ['commit', '-m', 'hello',
              u'--fixes=generic:\u20ac', 'tree/hello.txt'],
             encoding='utf-8', retcode=3)
-        self.assertEqual(b'', output)
+        self.assertEqual('', output)
         self.assertContainsRe(err,
             b'brz: ERROR: Unrecognized bug generic:\xe2\x82\xac\\. Commit refused.\n')
 
@@ -764,8 +764,8 @@
         self.build_tree_contents([('test', b'changes in test')])
         # partial commit
         out, err = self.run_bzr('commit test -m "partial commit"')
-        self.assertEqual(b'', out)
-        self.assertContainsRe(err, br'modified test\nCommitted revision 2.')
+        self.assertEqual('', out)
+        self.assertContainsRe(err, r'modified test\nCommitted revision 2.')
 
     def test_commit_readonly_checkout(self):
         # https://bugs.launchpad.net/bzr/+bug/129701
@@ -820,10 +820,10 @@
     def test_commit_hook_template_rejected(self):
         tree = self.setup_commit_with_template()
         expected = tree.last_revision()
-        out, err = self.run_bzr_error([b"Empty commit message specified."
-                  b" Please specify a commit message with either"
-                  b" --message or --file or leave a blank message"
-                  b" with --message \"\"."],
+        out, err = self.run_bzr_error(["Empty commit message specified."
+                  " Please specify a commit message with either"
+                  " --message or --file or leave a blank message"
+                  " with --message \"\"."],
             "commit tree/hello.txt", stdin="n\n")
         self.assertEqual(expected, tree.last_revision())
 

=== modified file 'breezy/tests/blackbox/test_config.py'
--- breezy/tests/blackbox/test_config.py	2018-06-29 15:36:29 +0000
+++ breezy/tests/blackbox/test_config.py	2018-07-14 19:37:12 +0000
@@ -32,32 +32,32 @@
 
     def test_config_all(self):
         out, err = self.run_bzr(['config'])
-        self.assertEqual(b'', out)
-        self.assertEqual(b'', err)
+        self.assertEqual('', out)
+        self.assertEqual('', err)
 
     def test_remove_unknown_option(self):
-        self.run_bzr_error([b'The "file" configuration option does not exist',],
+        self.run_bzr_error(['The "file" configuration option does not exist',],
                            ['config', '--remove', 'file'])
 
     def test_all_remove_exclusive(self):
-        self.run_bzr_error([b'--all and --remove are mutually exclusive.',],
+        self.run_bzr_error(['--all and --remove are mutually exclusive.',],
                            ['config', '--remove', '--all'])
 
     def test_all_set_exclusive(self):
-        self.run_bzr_error([b'Only one option can be set.',],
+        self.run_bzr_error(['Only one option can be set.',],
                            ['config', '--all', 'hello=world'])
 
     def test_remove_no_option(self):
-        self.run_bzr_error([b'--remove expects an option to remove.',],
+        self.run_bzr_error(['--remove expects an option to remove.',],
                            ['config', '--remove'])
 
     def test_unknown_option(self):
-        self.run_bzr_error([b'The "file" configuration option does not exist',],
+        self.run_bzr_error(['The "file" configuration option does not exist',],
                            ['config', 'file'])
 
     def test_unexpected_regexp(self):
         self.run_bzr_error(
-            [b'The "\\*file" configuration option does not exist',],
+            ['The "\\*file" configuration option does not exist',],
             ['config', '*file'])
 
     def test_wrong_regexp(self):
@@ -239,7 +239,7 @@
         _t_config.create_configs(self)
 
     def test_unknown_config(self):
-        self.run_bzr_error([b'The "moon" configuration does not exist'],
+        self.run_bzr_error(['The "moon" configuration does not exist'],
                            ['config', '--scope', 'moon', 'hello=world'])
 
     def test_breezy_config_outside_branch(self):
@@ -293,7 +293,7 @@
         _t_config.create_configs_with_file_option(self)
 
     def test_unknown_config(self):
-        self.run_bzr_error([b'The "moon" configuration does not exist'],
+        self.run_bzr_error(['The "moon" configuration does not exist'],
                            ['config', '--scope', 'moon', '--remove', 'file'])
 
     def test_breezy_config_outside_branch(self):
@@ -393,4 +393,4 @@
         clone.get_config_stack().set('test', 'clone')
         out, err = self.run_bzr(['config', '-d', ':parent', 'test'],
                                 working_dir='clone')
-        self.assertEqual(b'base\n', out)
+        self.assertEqual('base\n', out)

=== modified file 'breezy/tests/blackbox/test_conflicts.py'
--- breezy/tests/blackbox/test_conflicts.py	2018-02-18 15:21:06 +0000
+++ breezy/tests/blackbox/test_conflicts.py	2018-07-14 19:37:12 +0000
@@ -111,7 +111,7 @@
         self.assertEqual(out.decode(self.encoding),
             u"\xA7_other_file\n"
             u"\xA7file\n")
-        self.assertEqual(err, "")
+        self.assertEqual(err, b"")
 
 
 class TestUnicodePathsOnAsciiTerminal(TestUnicodePaths):

=== modified file 'breezy/tests/blackbox/test_cp.py'
--- breezy/tests/blackbox/test_cp.py	2018-06-29 15:36:29 +0000
+++ breezy/tests/blackbox/test_cp.py	2018-07-14 19:37:12 +0000
@@ -50,7 +50,7 @@
             'cp doesnotexist somewhereelse')
 
     def test_cp_unqualified(self):
-        self.run_bzr_error([b'^brz: ERROR: missing file argument$'], 'cp')
+        self.run_bzr_error(['^brz: ERROR: missing file argument$'], 'cp')
 
     def test_cp_invalid(self):
         tree = self.make_branch_and_tree('.')

=== modified file 'breezy/tests/blackbox/test_debug.py'
--- breezy/tests/blackbox/test_debug.py	2018-06-30 14:54:27 +0000
+++ breezy/tests/blackbox/test_debug.py	2018-07-14 19:37:12 +0000
@@ -33,7 +33,7 @@
         # error output should contain a traceback; we used to look for code in
         # here but it may be missing if the source is not in sync with the
         # pyc file.
-        self.assertContainsRe(err, b"Traceback \\(most recent call last\\)")
+        self.assertContainsRe(err, "Traceback \\(most recent call last\\)")
 
     def test_dash_dlock(self):
         # With -Dlock, locking and unlocking is recorded into the log

=== modified file 'breezy/tests/blackbox/test_deleted.py'
--- breezy/tests/blackbox/test_deleted.py	2018-06-29 15:36:29 +0000
+++ breezy/tests/blackbox/test_deleted.py	2018-07-14 19:37:12 +0000
@@ -34,4 +34,4 @@
         tree.commit('r1')
         tree.remove('README')
         out, err = self.run_bzr(['deleted', '--directory=a'])
-        self.assertEqual(b'README\n', out)
+        self.assertEqual('README\n', out)

=== modified file 'breezy/tests/blackbox/test_diff.py'
--- breezy/tests/blackbox/test_diff.py	2018-06-29 18:16:34 +0000
+++ breezy/tests/blackbox/test_diff.py	2018-07-14 19:37:12 +0000
@@ -163,7 +163,7 @@
         self.make_example_branch()
         self.build_tree(['unversioned-file'])
         out, err = self.run_bzr('diff unversioned-file', retcode=3)
-        self.assertContainsRe(err, b'not versioned.*unversioned-file')
+        self.assertContainsRe(err, 'not versioned.*unversioned-file')
 
     # TODO: What should diff say for a file deleted in working tree?
 
@@ -182,32 +182,32 @@
     def check_b2_vs_b1(self, cmd):
         # Compare branch2 vs branch1 using cmd and check the result
         out, err = self.run_bzr(cmd, retcode=1)
-        self.assertEqual(b'', err)
-        self.assertEqual(b"=== modified file 'file'\n"
-                         b"--- old/file\tYYYY-MM-DD HH:MM:SS +ZZZZ\n"
-                         b"+++ new/file\tYYYY-MM-DD HH:MM:SS +ZZZZ\n"
-                         b"@@ -1,1 +1,1 @@\n"
-                         b"-new content\n"
-                         b"+contents of branch1/file\n"
-                         b"\n", subst_dates(out))
+        self.assertEqual('', err)
+        self.assertEqual("=== modified file 'file'\n"
+                         "--- old/file\tYYYY-MM-DD HH:MM:SS +ZZZZ\n"
+                         "+++ new/file\tYYYY-MM-DD HH:MM:SS +ZZZZ\n"
+                         "@@ -1,1 +1,1 @@\n"
+                         "-new content\n"
+                         "+contents of branch1/file\n"
+                         "\n", subst_dates(out))
 
     def check_b1_vs_b2(self, cmd):
         # Compare branch1 vs branch2 using cmd and check the result
         out, err = self.run_bzr(cmd, retcode=1)
-        self.assertEqual(b'', err)
-        self.assertEqualDiff(b"=== modified file 'file'\n"
-                             b"--- old/file\tYYYY-MM-DD HH:MM:SS +ZZZZ\n"
-                             b"+++ new/file\tYYYY-MM-DD HH:MM:SS +ZZZZ\n"
-                             b"@@ -1,1 +1,1 @@\n"
-                             b"-contents of branch1/file\n"
-                             b"+new content\n"
-                             b"\n", subst_dates(out))
+        self.assertEqual('', err)
+        self.assertEqualDiff("=== modified file 'file'\n"
+                             "--- old/file\tYYYY-MM-DD HH:MM:SS +ZZZZ\n"
+                             "+++ new/file\tYYYY-MM-DD HH:MM:SS +ZZZZ\n"
+                             "@@ -1,1 +1,1 @@\n"
+                             "-contents of branch1/file\n"
+                             "+new content\n"
+                             "\n", subst_dates(out))
 
     def check_no_diffs(self, cmd):
         # Check that running cmd returns an empty diff
         out, err = self.run_bzr(cmd, retcode=0)
-        self.assertEqual(b'', err)
-        self.assertEqual(b'', out)
+        self.assertEqual('', err)
+        self.assertEqual('', out)
 
     def test_diff_branches(self):
         self.example_branches()
@@ -255,18 +255,18 @@
 
         out, err = self.run_bzr('diff -r revno:1:branch2..revno:1:branch1',
                                 )
-        self.assertEqual(b'', err)
-        self.assertEqual(b'', out)
+        self.assertEqual('', err)
+        self.assertEqual('', out)
         out, err = self.run_bzr('diff -r revno:2:branch2..revno:1:branch1',
                                 retcode=1)
-        self.assertEqual(b'', err)
-        self.assertEqualDiff(b"=== modified file 'file'\n"
-                             b"--- old/file\tYYYY-MM-DD HH:MM:SS +ZZZZ\n"
-                             b"+++ new/file\tYYYY-MM-DD HH:MM:SS +ZZZZ\n"
-                             b"@@ -1,1 +1,1 @@\n"
-                             b"-new content\n"
-                             b"+contents of branch1/file\n"
-                             b"\n", subst_dates(out))
+        self.assertEqual('', err)
+        self.assertEqualDiff("=== modified file 'file'\n"
+                             "--- old/file\tYYYY-MM-DD HH:MM:SS +ZZZZ\n"
+                             "+++ new/file\tYYYY-MM-DD HH:MM:SS +ZZZZ\n"
+                             "@@ -1,1 +1,1 @@\n"
+                             "-new content\n"
+                             "+contents of branch1/file\n"
+                             "\n", subst_dates(out))
 
     def example_branch2(self):
         branch1_tree = self.make_branch_and_tree('branch1')
@@ -394,16 +394,16 @@
             retcode=None)
         if 'Diff is not installed on this machine' in err:
             raise tests.TestSkipped("No external 'diff' is available")
-        self.assertEqual(b'', err)
+        self.assertEqual('', err)
         # We have to skip the stuff in the middle, because it depends
         # on time.time()
         self.assertStartsWith(
             out,
-            b"=== added file 'goodbye'\n"
-            b"--- old/goodbye\t1970-01-01 00:00:00 +0000\n"
-            b"+++ new/goodbye\t")
-        self.assertEndsWith(out, b"\n@@ -0,0 +1 @@\n"
-                                 b"+baz\n\n")
+            "=== added file 'goodbye'\n"
+            "--- old/goodbye\t1970-01-01 00:00:00 +0000\n"
+            "+++ new/goodbye\t")
+        self.assertEndsWith(out, "\n@@ -0,0 +1 @@\n"
+                                 "+baz\n\n")
 
     def test_external_diff_options_and_using(self):
         """Test that the options are passed correctly to an external diff process"""
@@ -412,8 +412,8 @@
         self.build_tree_contents([('hello', b'Foo\n')])
         out, err = self.run_bzr('diff --diff-options -i --using diff',
                                     retcode=1)
-        self.assertEqual(b"=== modified file 'hello'\n", out)
-        self.assertEqual(b'', err)
+        self.assertEqual("=== modified file 'hello'\n", out)
+        self.assertEqual('', err)
 
 
 class TestDiffOutput(DiffBase):

=== modified file 'breezy/tests/blackbox/test_exceptions.py'
--- breezy/tests/blackbox/test_exceptions.py	2018-06-29 18:16:34 +0000
+++ breezy/tests/blackbox/test_exceptions.py	2018-07-14 19:37:12 +0000
@@ -40,8 +40,8 @@
             universal_newlines=True,
             retcode=errors.EXIT_INTERNAL_ERROR)
         self.assertEqual(4, errors.EXIT_INTERNAL_ERROR)
-        self.assertContainsRe(err, br'\nAssertionError: always fails\n')
-        self.assertContainsRe(err, br'Bazaar has encountered an internal error')
+        self.assertContainsRe(err, r'\nAssertionError: always fails\n')
+        self.assertContainsRe(err, r'Bazaar has encountered an internal error')
 
     def test_undecodable_argv(self):
         """A user error must be reported if argv is not in the locale encoding
@@ -55,7 +55,7 @@
             env_changes={"LANG": "C", "LC_ALL": "C"},
             universal_newlines=True,
             retcode=errors.EXIT_ERROR)
-        self.assertContainsRe(err, br"^brz: ERROR: .*'\\xa0'.* unsupported",
+        self.assertContainsRe(err, r"^brz: ERROR: .*'\\xa0'.* unsupported",
             flags=re.MULTILINE)
         self.assertEqual(out, "")
 

=== modified file 'breezy/tests/blackbox/test_export.py'
--- breezy/tests/blackbox/test_export.py	2018-06-19 01:27:34 +0000
+++ breezy/tests/blackbox/test_export.py	2018-07-14 19:37:12 +0000
@@ -44,31 +44,31 @@
     # On Windows, if we fail to set the binary bit, and a '\r' or '\n'
     # ends up in the data stream, we will get corruption. Add a fair amount
     # of random data, to help ensure there is at least one.
-    _file_content = ('!\r\n\t\n \r'
-        + 'r29trp9i1r8k0e24c2o7mcx2isrlaw7toh1hv2mtst3o1udkl36v9xn2z8kt\n'
-          'tvjn7e3i9cj1qs1rw9gcye9w72cbdueiufw8nky7bs08lwggir59d62knecp\n'
-          '7s0537r8sg3e8hdnidji49rswo47c3j8190nh8emef2b6j1mf5kdq45nt3f5\n'
-          '1sz9u7fuzrm4w8bebre7p62sh5os2nkj2iiyuk9n0w0pjpdulu9k2aajejah\n'
-          'ini90ny40qzs12ajuy0ua6l178n93lvy2atqngnntsmtlmqx7yhp0q9a1xr4\n'
-          '1n69kgbo6qu9osjpqq83446r00jijtcstzybfqwm1lnt9spnri2j07bt7bbh\n'
-          'rf3ejatdxta83te2s0pt9rc4hidgy3d2pc53p4wscdt2b1dfxdj9utf5m17f\n'
-          'f03oofcau950o090vyx6m72vfkywo7gp3ajzi6uk02dwqwtumq4r44xx6ho7\n'
-          'nhynborjdjep5j53f9548msb7gd3x9a1xveb4s8zfo6cbdw2kdngcrbakwu8\n'
-          'ql5a8l94gplkwr7oypw5nt1gj5i3xwadyjfr3lb61tfkz31ba7uda9knb294\n'
-          '1azhfta0q3ry9x36lxyanvhp0g5z0t5a0i4wnoc8p4htexi915y1cnw4nznn\n'
-          'aj70dvp88ifiblv2bsp98hz570teinj8g472ddxni9ydmazfzwtznbf3hrg6\n'
-          '84gigirjt6n2yagf70036m8d73cz0jpcighpjtxsmbgzbxx7nb4ewq6jbgnc\n'
-          'hux1b0qtsdi0zfhj6g1otf5jcldmtdvuon8y1ttszkqw3ograwi25yl921hy\n'
-          'izgscmfha9xdhxxabs07b40secpw22ah9iwpbmsns6qz0yr6fswto3ft2ez5\n'
-          'ngn48pdfxj1pw246drmj1y2ll5af5w7cz849rapzd9ih7qvalw358co0yzrs\n'
-          'xan9291d1ivjku4o5gjrsnmllrqwxwy86pcivinbmlnzasa9v3o22lgv4uyd\n'
-          'q8kw77bge3hr5rr5kzwjxk223bkmo3z9oju0954undsz8axr3kb3730otrcr\n'
-          '9cwhu37htnizdwxmpoc5qmobycfm7ubbykfumv6zgkl6b8zlslwl7a8b81vz\n'
-          '3weqkvv5csfza9xvwypr6lo0t03fwp0ihmci3m1muh0lf2u30ze0hjag691j\n'
-          '27fjtd3e3zbiin5n2hq21iuo09ukbs73r5rt7vaw6axvoilvdciir9ugjh2c\n'
-          'na2b8dr0ptftoyhyxv1iwg661y338e28fhz4xxwgv3hnoe98ydfa1oou45vj\n'
-          'ln74oac2keqt0agbylrqhfscin7ireae2bql7z2le823ksy47ud57z8ctomp\n'
-          '31s1vwbczdjwqp0o2jc7mkrurvzg8mj2zwcn2iily4gcl4sy4fsh4rignlyz\n')
+    _file_content = (b'!\r\n\t\n \r'
+        + b'r29trp9i1r8k0e24c2o7mcx2isrlaw7toh1hv2mtst3o1udkl36v9xn2z8kt\n'
+          b'tvjn7e3i9cj1qs1rw9gcye9w72cbdueiufw8nky7bs08lwggir59d62knecp\n'
+          b'7s0537r8sg3e8hdnidji49rswo47c3j8190nh8emef2b6j1mf5kdq45nt3f5\n'
+          b'1sz9u7fuzrm4w8bebre7p62sh5os2nkj2iiyuk9n0w0pjpdulu9k2aajejah\n'
+          b'ini90ny40qzs12ajuy0ua6l178n93lvy2atqngnntsmtlmqx7yhp0q9a1xr4\n'
+          b'1n69kgbo6qu9osjpqq83446r00jijtcstzybfqwm1lnt9spnri2j07bt7bbh\n'
+          b'rf3ejatdxta83te2s0pt9rc4hidgy3d2pc53p4wscdt2b1dfxdj9utf5m17f\n'
+          b'f03oofcau950o090vyx6m72vfkywo7gp3ajzi6uk02dwqwtumq4r44xx6ho7\n'
+          b'nhynborjdjep5j53f9548msb7gd3x9a1xveb4s8zfo6cbdw2kdngcrbakwu8\n'
+          b'ql5a8l94gplkwr7oypw5nt1gj5i3xwadyjfr3lb61tfkz31ba7uda9knb294\n'
+          b'1azhfta0q3ry9x36lxyanvhp0g5z0t5a0i4wnoc8p4htexi915y1cnw4nznn\n'
+          b'aj70dvp88ifiblv2bsp98hz570teinj8g472ddxni9ydmazfzwtznbf3hrg6\n'
+          b'84gigirjt6n2yagf70036m8d73cz0jpcighpjtxsmbgzbxx7nb4ewq6jbgnc\n'
+          b'hux1b0qtsdi0zfhj6g1otf5jcldmtdvuon8y1ttszkqw3ograwi25yl921hy\n'
+          b'izgscmfha9xdhxxabs07b40secpw22ah9iwpbmsns6qz0yr6fswto3ft2ez5\n'
+          b'ngn48pdfxj1pw246drmj1y2ll5af5w7cz849rapzd9ih7qvalw358co0yzrs\n'
+          b'xan9291d1ivjku4o5gjrsnmllrqwxwy86pcivinbmlnzasa9v3o22lgv4uyd\n'
+          b'q8kw77bge3hr5rr5kzwjxk223bkmo3z9oju0954undsz8axr3kb3730otrcr\n'
+          b'9cwhu37htnizdwxmpoc5qmobycfm7ubbykfumv6zgkl6b8zlslwl7a8b81vz\n'
+          b'3weqkvv5csfza9xvwypr6lo0t03fwp0ihmci3m1muh0lf2u30ze0hjag691j\n'
+          b'27fjtd3e3zbiin5n2hq21iuo09ukbs73r5rt7vaw6axvoilvdciir9ugjh2c\n'
+          b'na2b8dr0ptftoyhyxv1iwg661y338e28fhz4xxwgv3hnoe98ydfa1oou45vj\n'
+          b'ln74oac2keqt0agbylrqhfscin7ireae2bql7z2le823ksy47ud57z8ctomp\n'
+          b'31s1vwbczdjwqp0o2jc7mkrurvzg8mj2zwcn2iily4gcl4sy4fsh4rignlyz\n')
 
     def make_basic_tree(self):
         tree = self.make_branch_and_tree('tree')
@@ -304,7 +304,7 @@
         tf = tarfile.open('../first.tar')
         try:
             self.assertEqual(['first/hello'], sorted(tf.getnames()))
-            self.assertEqual('foo', tf.extractfile('first/hello').read())
+            self.assertEqual(b'foo', tf.extractfile('first/hello').read())
         finally:
             tf.close()
 

=== modified file 'breezy/tests/blackbox/test_export_pot.py'
--- breezy/tests/blackbox/test_export_pot.py	2018-06-29 18:16:34 +0000
+++ breezy/tests/blackbox/test_export_pot.py	2018-07-14 19:37:12 +0000
@@ -26,17 +26,17 @@
 
     def test_export_pot(self):
         out, err = self.run_bzr("export-pot")
-        self.assertContainsRe(err, b'Exporting messages from builtin command: add')
-        self.assertContainsRe(out, b"help of 'change' option\n"\
-                                   b"msgid \"Select changes introduced by the specified revision.")
+        self.assertContainsRe(err, 'Exporting messages from builtin command: add')
+        self.assertContainsRe(out, "help of 'change' option\n"\
+                                   "msgid \"Select changes introduced by the specified revision.")
 
     def test_export_pot_plugin_unknown(self):
         out, err = self.run_bzr("export-pot --plugin=lalalala", retcode=3)
         self.assertContainsRe(
-             err, b'ERROR: Plugin lalalala is not loaded')
+             err, 'ERROR: Plugin lalalala is not loaded')
 
     def test_export_pot_plugin(self):
         self.requireFeature(PluginLoadedFeature('launchpad'))
         out, err = self.run_bzr("export-pot --plugin=launchpad")
-        self.assertContainsRe(err, b'Exporting messages from plugin command: launchpad-login in launchpad')
-        self.assertContainsRe(out, b'msgid "Show or set the Launchpad user ID."')
+        self.assertContainsRe(err, 'Exporting messages from plugin command: launchpad-login in launchpad')
+        self.assertContainsRe(out, 'msgid "Show or set the Launchpad user ID."')

=== modified file 'breezy/tests/blackbox/test_filtered_view_ops.py'
--- breezy/tests/blackbox/test_filtered_view_ops.py	2018-06-29 15:36:29 +0000
+++ breezy/tests/blackbox/test_filtered_view_ops.py	2018-07-14 19:37:12 +0000
@@ -33,63 +33,63 @@
     def test_view_on_status(self):
         wt = self.make_abc_tree_with_ab_view()
         out, err = self.run_bzr('status')
-        self.assertEqual(b'Ignoring files outside view. View is a, b\n', err)
-        self.assertEqual(b'unknown:\n  a\n  b\n', out)
+        self.assertEqual('Ignoring files outside view. View is a, b\n', err)
+        self.assertEqual('unknown:\n  a\n  b\n', out)
 
     def test_view_on_status_selected(self):
         wt = self.make_abc_tree_with_ab_view()
         out, err = self.run_bzr('status a')
-        self.assertEqual(b'', err)
-        self.assertEqual(b'unknown:\n  a\n', out)
+        self.assertEqual('', err)
+        self.assertEqual('unknown:\n  a\n', out)
         out, err = self.run_bzr('status c', retcode=3)
-        self.assertEqual(b'brz: ERROR: Specified file "c" is outside the '
-                         b'current view: a, b\n', err)
-        self.assertEqual(b'', out)
+        self.assertEqual('brz: ERROR: Specified file "c" is outside the '
+                         'current view: a, b\n', err)
+        self.assertEqual('', out)
 
     def test_view_on_add(self):
         wt = self.make_abc_tree_with_ab_view()
         out, err = self.run_bzr('add')
-        self.assertEqual(b'Ignoring files outside view. View is a, b\n', err)
-        self.assertEqual(b'adding a\nadding b\n', out)
+        self.assertEqual('Ignoring files outside view. View is a, b\n', err)
+        self.assertEqual('adding a\nadding b\n', out)
 
     def test_view_on_add_selected(self):
         wt = self.make_abc_tree_with_ab_view()
         out, err = self.run_bzr('add a')
-        self.assertEqual(b'', err)
-        self.assertEqual(b'adding a\n', out)
+        self.assertEqual('', err)
+        self.assertEqual('adding a\n', out)
         out, err = self.run_bzr('add c', retcode=3)
-        self.assertEqual(b'brz: ERROR: Specified file "c" is outside the '
-                         b'current view: a, b\n', err)
-        self.assertEqual(b'', out)
+        self.assertEqual('brz: ERROR: Specified file "c" is outside the '
+                         'current view: a, b\n', err)
+        self.assertEqual('', out)
 
     def test_view_on_diff(self):
         wt = self.make_abc_tree_with_ab_view()
         self.run_bzr('add')
         out, err = self.run_bzr('diff', retcode=1)
-        self.assertEqual(b'*** Ignoring files outside view. View is a, b\n', err)
+        self.assertEqual('*** Ignoring files outside view. View is a, b\n', err)
 
     def test_view_on_diff_selected(self):
         wt = self.make_abc_tree_with_ab_view()
         self.run_bzr('add')
         out, err = self.run_bzr('diff a', retcode=1)
-        self.assertEqual(b'', err)
-        self.assertStartsWith(out, b"=== added file 'a'\n")
+        self.assertEqual('', err)
+        self.assertStartsWith(out, "=== added file 'a'\n")
         out, err = self.run_bzr('diff c', retcode=3)
-        self.assertEqual(b'brz: ERROR: Specified file "c" is outside the '
-                         b'current view: a, b\n', err)
-        self.assertEqual(b'', out)
+        self.assertEqual('brz: ERROR: Specified file "c" is outside the '
+                         'current view: a, b\n', err)
+        self.assertEqual('', out)
 
     def test_view_on_commit(self):
         wt = self.make_abc_tree_with_ab_view()
         self.run_bzr('add')
         out, err = self.run_bzr('commit -m "testing commit"')
         err_lines = err.splitlines()
-        self.assertEqual(b'Ignoring files outside view. View is a, b', err_lines[0])
-        self.assertStartsWith(err_lines[1], b'Committing to:')
-        self.assertEqual(b'added a', err_lines[2])
-        self.assertEqual(b'added b', err_lines[3])
-        self.assertEqual(b'Committed revision 1.', err_lines[4])
-        self.assertEqual(b'', out)
+        self.assertEqual('Ignoring files outside view. View is a, b', err_lines[0])
+        self.assertStartsWith(err_lines[1], 'Committing to:')
+        self.assertEqual('added a', err_lines[2])
+        self.assertEqual('added b', err_lines[3])
+        self.assertEqual('Committed revision 1.', err_lines[4])
+        self.assertEqual('', out)
 
     def test_view_on_commit_selected(self):
         wt = self.make_abc_tree_with_ab_view()
@@ -97,54 +97,54 @@
         out, err = self.run_bzr('commit -m "file in view" a')
         err_lines = err.splitlines()
         self.assertStartsWith(err_lines[0], b'Committing to:')
-        self.assertEqual(b'added a', err_lines[1])
-        self.assertEqual(b'Committed revision 1.', err_lines[2])
-        self.assertEqual(b'', out)
+        self.assertEqual('added a', err_lines[1])
+        self.assertEqual('Committed revision 1.', err_lines[2])
+        self.assertEqual('', out)
         out, err = self.run_bzr('commit -m "file out of view" c', retcode=3)
-        self.assertEqual(b'brz: ERROR: Specified file "c" is outside the '
-                          b'current view: a, b\n', err)
-        self.assertEqual(b'', out)
+        self.assertEqual('brz: ERROR: Specified file "c" is outside the '
+                         'current view: a, b\n', err)
+        self.assertEqual('', out)
 
     def test_view_on_remove_selected(self):
         wt = self.make_abc_tree_with_ab_view()
         self.run_bzr('add')
         out, err = self.run_bzr('remove --keep a')
-        self.assertEqual(b'removed a\n', err)
-        self.assertEqual(b'', out)
+        self.assertEqual('removed a\n', err)
+        self.assertEqual('', out)
         out, err = self.run_bzr('remove --keep c', retcode=3)
-        self.assertEqual(b'brz: ERROR: Specified file "c" is outside the '
-                          b'current view: a, b\n', err)
-        self.assertEqual(b'', out)
+        self.assertEqual('brz: ERROR: Specified file "c" is outside the '
+                         'current view: a, b\n', err)
+        self.assertEqual('', out)
 
     def test_view_on_revert(self):
         wt = self.make_abc_tree_with_ab_view()
         self.run_bzr('add')
         out, err = self.run_bzr('revert')
         err_lines = err.splitlines()
-        self.assertEqual(b'Ignoring files outside view. View is a, b', err_lines[0])
-        self.assertEqual(b'-   a', err_lines[1])
-        self.assertEqual(b'-   b', err_lines[2])
-        self.assertEqual(b'', out)
+        self.assertEqual('Ignoring files outside view. View is a, b', err_lines[0])
+        self.assertEqual('-   a', err_lines[1])
+        self.assertEqual('-   b', err_lines[2])
+        self.assertEqual('', out)
 
     def test_view_on_revert_selected(self):
         wt = self.make_abc_tree_with_ab_view()
         self.run_bzr('add')
         out, err = self.run_bzr('revert a')
-        self.assertEqual(b'-   a\n', err)
-        self.assertEqual(b'', out)
+        self.assertEqual('-   a\n', err)
+        self.assertEqual('', out)
         out, err = self.run_bzr('revert c', retcode=3)
-        self.assertEqual(b'brz: ERROR: Specified file "c" is outside the '
-                          b'current view: a, b\n', err)
-        self.assertEqual(b'', out)
+        self.assertEqual('brz: ERROR: Specified file "c" is outside the '
+                         'current view: a, b\n', err)
+        self.assertEqual('', out)
 
     def test_view_on_ls(self):
         wt = self.make_abc_tree_with_ab_view()
         self.run_bzr('add')
         out, err = self.run_bzr('ls')
         out_lines = out.splitlines()
-        self.assertEqual(b'Ignoring files outside view. View is a, b\n', err)
-        self.assertEqual(b'a', out_lines[0])
-        self.assertEqual(b'b', out_lines[1])
+        self.assertEqual('Ignoring files outside view. View is a, b\n', err)
+        self.assertEqual('a', out_lines[0])
+        self.assertEqual('b', out_lines[1])
 
 
 class TestViewTreeOperations(tests.TestCaseWithTransport):

=== modified file 'breezy/tests/blackbox/test_help.py'
--- breezy/tests/blackbox/test_help.py	2018-05-13 02:18:13 +0000
+++ breezy/tests/blackbox/test_help.py	2018-07-14 19:37:12 +0000
@@ -78,7 +78,7 @@
         out, err = self.run_bzr('help repositories')
         from breezy.help_topics import help_as_plain_text, _repositories
         expected = help_as_plain_text(_repositories)
-        self.assertEqual(expected, out)
+        self.assertEqual(expected.encode('utf-8'), out)
 
     def test_help_working_trees(self):
         """Smoke test for 'brz help working-trees'"""
@@ -188,16 +188,16 @@
 
     def test_help_command_utf8(self):
         out, err = self.run_bzr(["help", "push"], encoding="utf-8")
-        self.assertContainsRe(out, "zz\xc3\xa5{{:See also:")
+        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")
-        self.assertContainsRe(out, "zz\xc3\xa5{{:See also:")
+        self.assertContainsRe(out, b"zz\xc3\xa5{{:See also:")
 
     def test_help_command_ascii(self):
         out, err = self.run_bzr(["help", "push"], encoding="ascii")
-        self.assertContainsRe(out, "zz\\?{{:See also:")
+        self.assertContainsRe(out, b"zz\\?{{:See also:")
 
     def test_help_switch_ascii(self):
         out, err = self.run_bzr(["push", "--help"], encoding="ascii")
-        self.assertContainsRe(out, "zz\\?{{:See also:")
+        self.assertContainsRe(out, b"zz\\?{{:See also:")

=== modified file 'breezy/tests/blackbox/test_ignore.py'
--- breezy/tests/blackbox/test_ignore.py	2018-06-29 18:16:34 +0000
+++ breezy/tests/blackbox/test_ignore.py	2018-07-14 19:37:12 +0000
@@ -112,7 +112,7 @@
         reference_set = set(ignores.USER_DEFAULTS)
         output_set = set(out.rstrip().split('\n'))
         self.assertEqual(reference_set, output_set)
-        self.assertEqual(b'', err)
+        self.assertEqual('', err)
 
     def test_ignore_versioned_file(self):
         tree = self.make_branch_and_tree('.')
@@ -170,9 +170,9 @@
         """
         tree = self.make_branch_and_tree('.')
         out, err = self.run_bzr(['ignore', 'RE:*.cpp', 'foo', 'RE:['], 3)
-        self.assertEqual(out, b'')
+        self.assertEqual(out, '')
         self.assertContainsRe(err,
-            br'Invalid ignore pattern.*RE:\*\.cpp.*RE:\[', re.DOTALL)
-        self.assertNotContainsRe(err, b'foo', re.DOTALL)
+            r'Invalid ignore pattern.*RE:\*\.cpp.*RE:\[', re.DOTALL)
+        self.assertNotContainsRe(err, 'foo', re.DOTALL)
         self.assertFalse(os.path.isfile('.bzrignore'))
 

=== modified file 'breezy/tests/blackbox/test_ignored.py'
--- breezy/tests/blackbox/test_ignored.py	2018-06-18 20:53:01 +0000
+++ breezy/tests/blackbox/test_ignored.py	2018-07-14 19:37:12 +0000
@@ -36,8 +36,8 @@
         # now add it and check the ui does not show it.
         tree.add('foo.pyc')
         out, err = self.run_bzr('ignored')
-        self.assertEqual(b'', out)
-        self.assertEqual(b'', err)
+        self.assertEqual('', out)
+        self.assertEqual('', err)
 
     def test_ignored_directory(self):
         """Test --directory option"""
@@ -45,4 +45,4 @@
         self.build_tree_contents([('a/README', b'contents'),
                                   ('a/.bzrignore', b'README')])
         out, err = self.run_bzr(['ignored', '--directory=a'])
-        self.assertStartsWith(out, b'README')
+        self.assertStartsWith(out, 'README')

=== modified file 'breezy/tests/blackbox/test_info.py'
--- breezy/tests/blackbox/test_info.py	2018-06-29 15:36:29 +0000
+++ breezy/tests/blackbox/test_info.py	2018-07-14 19:37:12 +0000
@@ -54,23 +54,23 @@
         self.make_controldir('ctrl')
         out, err = self.run_bzr('info ctrl')
         self.assertEqual(out,
-            b'Empty control directory (format: 2a)\n'
-            b'Location:\n'
-            b'  control directory: ctrl\n')
-        self.assertEqual(err, b'')
+            'Empty control directory (format: 2a)\n'
+            'Location:\n'
+            '  control directory: ctrl\n')
+        self.assertEqual(err, '')
 
     def test_info_empty_controldir_verbose(self):
         self.make_controldir('ctrl')
         out, err = self.run_bzr('info -v ctrl')
         self.assertEqualDiff(out,
-            b'Empty control directory (format: 2a)\n'
-            b'Location:\n'
-            b'  control directory: ctrl\n\n'
-            b'Format:\n'
-            b'       control: Meta directory format 1\n\n'
-            b'Control directory:\n'
-            b'         0 branches\n')
-        self.assertEqual(err, b'')
+            'Empty control directory (format: 2a)\n'
+            'Location:\n'
+            '  control directory: ctrl\n\n'
+            'Format:\n'
+            '       control: Meta directory format 1\n\n'
+            'Control directory:\n'
+            '         0 branches\n')
+        self.assertEqual(err, '')
 
     def test_info_dangling_branch_reference(self):
         br = self.make_branch('target')
@@ -78,11 +78,11 @@
         shutil.rmtree('target')
         out, err = self.run_bzr('info from')
         self.assertEqual(out,
-            b'Dangling branch reference (format: 2a)\n'
-            b'Location:\n'
-            b'   control directory: from\n'
-            b'  checkout of branch: target\n')
-        self.assertEqual(err, b'')
+            'Dangling branch reference (format: 2a)\n'
+            'Location:\n'
+            '   control directory: from\n'
+            '  checkout of branch: target\n')
+        self.assertEqual(err, '')
 
     def test_info_standalone(self):
         transport = self.get_transport()
@@ -95,16 +95,16 @@
 
         out, err = self.run_bzr('info standalone')
         self.assertEqualDiff(
-b"""Standalone tree (format: knit)
+"""Standalone tree (format: knit)
 Location:
   branch root: standalone
 """, out)
-        self.assertEqual(b'', err)
+        self.assertEqual('', err)
 
         # Standalone branch - verbose mode
         out, err = self.run_bzr('info standalone -v')
         self.assertEqualDiff(
-b"""Standalone tree (format: knit)
+"""Standalone tree (format: knit)
 Location:
   branch root: standalone
 
@@ -133,12 +133,12 @@
 Repository:
          0 revisions
 """, out)
-        self.assertEqual(b'', err)
+        self.assertEqual('', err)
 
         # Standalone branch - really verbose mode
         out, err = self.run_bzr('info standalone -vv')
         self.assertEqualDiff(
-b"""Standalone tree (format: knit)
+"""Standalone tree (format: knit)
 Location:
   branch root: standalone
 
@@ -168,7 +168,7 @@
 Repository:
          0 revisions
 """, out)
-        self.assertEqual(b'', err)
+        self.assertEqual('', err)
         tree1.commit('commit one')
         rev = branch1.repository.get_revision(branch1.last_revision())
         datestring_first = osutils.format_date(rev.timestamp, rev.timezone)
@@ -187,11 +187,11 @@
     push branch: standalone
   parent branch: standalone
 """, out)
-        self.assertEqual(b'', err)
+        self.assertEqual('', err)
 
         out, err = self.run_bzr('info branch --verbose')
         self.assertEqualDiff(
-b"""Standalone tree (format: knit)
+"""Standalone tree (format: knit)
 Location:
   branch root: branch
 
@@ -228,7 +228,7 @@
          1 revision
 """ % (datestring_first, datestring_first,
        ), out)
-        self.assertEqual(b'', err)
+        self.assertEqual('', err)
 
         # Branch and bind to standalone, needs upgrade to metadir
         # (creates backup as unknown)
@@ -240,7 +240,7 @@
         bound_tree = branch3.controldir.open_workingtree()
         out, err = self.run_bzr('info -v bound')
         self.assertEqualDiff(
-b"""Checkout (format: knit)
+"""Checkout (format: knit)
 Location:
        checkout root: bound
   checkout of branch: standalone
@@ -280,7 +280,7 @@
        branch3.repository._format.get_format_description(),
        datestring_first, datestring_first,
        ), out)
-        self.assertEqual(b'', err)
+        self.assertEqual('', err)
 
         # Checkout standalone (same as above, but does not have parent set)
         branch4 = controldir.ControlDir.create_branch_convenience('checkout',
@@ -289,7 +289,7 @@
         branch4.controldir.open_workingtree().update()
         out, err = self.run_bzr('info checkout --verbose')
         self.assertEqualDiff(
-b"""Checkout (format: knit)
+"""Checkout (format: knit)
 Location:
        checkout root: checkout
   checkout of branch: standalone
@@ -324,7 +324,7 @@
 """ % (branch4.repository._format.get_format_description(),
        datestring_first, datestring_first,
        ), out)
-        self.assertEqual(b'', err)
+        self.assertEqual('', err)
 
         # Lightweight checkout (same as above, different branch and repository)
         tree5 = branch1.create_checkout('lightcheckout', lightweight=True)
@@ -368,7 +368,7 @@
 Repository:
          1 revision
 """ % (format_description, datestring_first, datestring_first,), out)
-        self.assertEqual(b'', err)
+        self.assertEqual('', err)
 
         # Update initial standalone branch
         self.build_tree(['standalone/b'])
@@ -380,7 +380,7 @@
         # Out of date branched standalone branch will not be detected
         out, err = self.run_bzr('info -v branch')
         self.assertEqualDiff(
-b"""Standalone tree (format: knit)
+"""Standalone tree (format: knit)
 Location:
   branch root: branch
 
@@ -417,12 +417,12 @@
          1 revision
 """ % (datestring_first, datestring_first,
        ), out)
-        self.assertEqual(b'', err)
+        self.assertEqual('', err)
 
         # Out of date bound branch
         out, err = self.run_bzr('info -v bound')
         self.assertEqualDiff(
-b"""Checkout (format: knit)
+"""Checkout (format: knit)
 Location:
        checkout root: bound
   checkout of branch: standalone
@@ -462,12 +462,12 @@
 """ % (branch3.repository._format.get_format_description(),
        datestring_first, datestring_first,
        ), out)
-        self.assertEqual(b'', err)
+        self.assertEqual('', err)
 
         # Out of date checkout
         out, err = self.run_bzr('info -v checkout')
         self.assertEqualDiff(
-b"""Checkout (format: knit)
+"""Checkout (format: knit)
 Location:
        checkout root: checkout
   checkout of branch: standalone
@@ -504,12 +504,12 @@
 """ % (branch4.repository._format.get_format_description(),
        datestring_first, datestring_first,
        ), out)
-        self.assertEqual(b'', err)
+        self.assertEqual('', err)
 
         # Out of date lightweight checkout
         out, err = self.run_bzr('info lightcheckout --verbose')
         self.assertEqualDiff(
-b"""Lightweight checkout (format: %s)
+"""Lightweight checkout (format: %s)
 Location:
   light checkout root: lightcheckout
    checkout of branch: standalone
@@ -544,7 +544,7 @@
 Repository:
          2 revisions
 """ % (format_description, datestring_first, datestring_last,), out)
-        self.assertEqual(b'', err)
+        self.assertEqual('', err)
 
     def test_info_standalone_no_tree(self):
         # create standalone branch without a working tree
@@ -553,7 +553,7 @@
         repo = branch.repository
         out, err = self.run_bzr('info branch -v')
         self.assertEqualDiff(
-b"""Standalone branch (format: %s)
+"""Standalone branch (format: %s)
 Location:
   branch root: branch
 
@@ -570,11 +570,11 @@
 
 Repository:
          0 revisions
-""" % (info.describe_format(repo.controldir, repo, branch, None).encode('ascii'),
-       format.get_branch_format().get_format_description().encode('ascii'),
-       format.repository_format.get_format_description().encode('ascii'),
+""" % (info.describe_format(repo.controldir, repo, branch, None),
+       format.get_branch_format().get_format_description(),
+       format.repository_format.get_format_description(),
        ), out)
-        self.assertEqual(b'', err)
+        self.assertEqual('', err)
 
     def test_info_shared_repository(self):
         format = controldir.format_registry.make_controldir('knit')
@@ -585,7 +585,7 @@
         repo.set_make_working_trees(False)
         out, err = self.run_bzr('info -v repo')
         self.assertEqualDiff(
-b"""Shared repository (format: dirstate or dirstate-tags or knit)
+"""Shared repository (format: dirstate or dirstate-tags or knit)
 Location:
   shared repository: %s
 
@@ -598,9 +598,9 @@
 
 Repository:
          0 revisions
-""" % (b'repo', format.repository_format.get_format_description().encode('ascii'),
+""" % ('repo', format.repository_format.get_format_description(),
        ), out)
-        self.assertEqual(b'', err)
+        self.assertEqual('', err)
 
         # Create branch inside shared repository
         repo.controldir.root_transport.mkdir('branch')
@@ -608,7 +608,7 @@
             'repo/branch', format=format)
         out, err = self.run_bzr('info -v repo/branch')
         self.assertEqualDiff(
-b"""Repository branch (format: dirstate or knit)
+"""Repository branch (format: dirstate or knit)
 Location:
   shared repository: repo
   repository branch: repo/branch
@@ -626,10 +626,10 @@
 
 Repository:
          0 revisions
-""" % (format.get_branch_format().get_format_description().encode('ascii'),
-       format.repository_format.get_format_description().encode('ascii'),
+""" % (format.get_branch_format().get_format_description(),
+       format.repository_format.get_format_description(),
        ), out)
-        self.assertEqual(b'', err)
+        self.assertEqual('', err)
 
         # Create lightweight checkout
         transport.mkdir('tree')
@@ -690,12 +690,12 @@
        format.repository_format.get_format_description(),
        datestring_first, datestring_first,
        ), out)
-        self.assertEqual(b'', err)
+        self.assertEqual('', err)
 
         # Out of date checkout
         out, err = self.run_bzr('info -v tree/checkout')
         self.assertEqualDiff(
-b"""Checkout (format: unnamed)
+"""Checkout (format: unnamed)
 Location:
        checkout root: tree/checkout
   checkout of branch: repo/branch
@@ -729,7 +729,7 @@
 """ % (format.get_branch_format().get_format_description(),
        format.repository_format.get_format_description(),
        ), out)
-        self.assertEqual(b'', err)
+        self.assertEqual('', err)
 
         # Update checkout
         tree3.update()
@@ -737,7 +737,7 @@
         tree3.add('b')
         out, err = self.run_bzr('info tree/checkout --verbose')
         self.assertEqualDiff(