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

[Jelmer Vernooij]

Fix handling of bytestrings in Python3 in more tests.

More bees!

% wc -l python3.passing
12519 python3.passing

[Martin Packman (gz)]

Thanks! Some griping inline, but no changes needed.

review: Approve

=== modified file 'breezy/branch.py'
--- breezy/branch.py	2018-05-20 13:30:41 +0000
+++ breezy/branch.py	2018-06-21 08:27:55 +0000
@@ -16,6 +16,8 @@
 
 from __future__ import absolute_import
 
+import sys
+
 from . import errors
 
 from .lazy_import import lazy_import
@@ -772,7 +774,8 @@
         # FIXUP this and get_parent in a future branch format bump:
         # read and rewrite the file. RBC 20060125
         if url is not None:
-            if isinstance(url, text_type):
+            # TODO(jelmer): Clean this up for pad.lv/1696545
+            if isinstance(url, text_type) and sys.version_info[0] == 2:
                 try:
                     url = url.encode('ascii')
                 except UnicodeEncodeError:

=== modified file 'breezy/bzr/_dirstate_helpers_py.py'
--- breezy/bzr/_dirstate_helpers_py.py	2018-05-13 02:18:13 +0000
+++ breezy/bzr/_dirstate_helpers_py.py	2018-06-21 08:27:55 +0000
@@ -270,9 +270,9 @@
             next()
         # The two blocks here are deliberate: the root block and the
         # contents-of-root block.
-        state._dirblocks = [('', []), ('', [])]
+        state._dirblocks = [(b'', []), (b'', [])]
         current_block = state._dirblocks[0][1]
-        current_dirname = ''
+        current_dirname = b''
         append_entry = current_block.append
         for count in range(state._num_entries):
             dirname = next()

=== modified file 'breezy/bzr/branch.py'
--- breezy/bzr/branch.py	2018-05-13 12:30:09 +0000
+++ breezy/bzr/branch.py	2018-06-21 08:27:55 +0000
@@ -17,6 +17,8 @@
 
 from __future__ import absolute_import
 
+import sys
+
 from ..lazy_import import lazy_import
 lazy_import(globals(), """
 from breezy import (
@@ -617,7 +619,11 @@
                                                 config=conf)
         if stacked_url is None:
             raise errors.NotStacked(self)
-        return stacked_url.encode('utf-8')
+        # TODO(jelmer): Clean this up for pad.lv/1696545
+        if sys.version_info[0] == 2:
+            return stacked_url.encode('utf-8')
+        else:
+            return stacked_url
 
     def get_rev_id(self, revno, history=None):
         """Find the revision id of the specified revno."""

=== modified file 'breezy/bzr/btree_index.py'
--- breezy/bzr/btree_index.py	2017-07-31 22:36:57 +0000
+++ breezy/bzr/btree_index.py	2018-06-21 08:27:55 +0000
@@ -698,6 +698,15 @@
             self._name == other._name and
             self._size == other._size)
 
+    def __lt__(self, other):
+        if isinstance(other, type(self)):
+            return ((self._transport, self._name, self._size) <
+                    (other._transport, other._name, other._size))
+        # Always sort existing indexes before ones that are still being built.
+        if isinstance(other, index.GraphIndexBuilder):
+            return True
+        raise TypeError
+
     def __ne__(self, other):
         return not self.__eq__(other)
 

=== modified file 'breezy/bzr/chk_map.py'
--- breezy/bzr/chk_map.py	2018-05-13 02:18:13 +0000
+++ breezy/bzr/chk_map.py	2018-06-21 08:27:55 +0000
@@ -182,7 +182,7 @@
             return _get_cache()[key]
         except KeyError:
             stream = self._store.get_record_stream([key], 'unordered', True)
-            bytes = stream.next().get_bytes_as('fulltext')
+            bytes = next(stream).get_bytes_as('fulltext')
             _get_cache()[key] = bytes
             return bytes
 

=== modified file 'breezy/bzr/dirstate.py'
--- breezy/bzr/dirstate.py	2018-02-18 19:18:40 +0000
+++ breezy/bzr/dirstate.py	2018-06-21 08:27:55 +0000
@@ -301,7 +301,7 @@
 
     def stat_and_sha1(self, abspath):
         """Return the stat and sha1 of a file given its absolute path."""
-        with file(abspath, 'rb') as file_obj:
+        with open(abspath, 'rb') as file_obj:
             statvalue = os.fstat(file_obj.fileno())
             sha1 = osutils.sha_file(file_obj)
         return statvalue, sha1
@@ -1815,17 +1815,17 @@
                     'mismatched file_id in tree 1')
             dir_block = ()
             old_kind = entry[1][1][0]
-            if active_kind in 'ar':
+            if active_kind in b'ar':
                 # The active tree doesn't have this file_id.
                 # The basis tree is changing this record. If this is a
                 # rename, then we don't want the record here at all
                 # anymore. If it is just an in-place change, we want the
                 # record here, but we'll add it if we need to. So we just
                 # delete it
-                if active_kind == 'r':
+                if active_kind == b'r':
                     active_path = entry[1][0][1]
                     active_entry = self._get_entry(0, file_id, active_path)
-                    if active_entry[1][1][0] != 'r':
+                    if active_entry[1][1][0] != b'r':
                         self._raise_invalid(old_path, file_id,
                             "Dirstate did not have matching rename entries")
                     elif active_entry[1][0][0] in 'ar':
@@ -1834,7 +1834,7 @@
                             " tree0")
                     active_entry[1][1] = null
                 del self._dirblocks[block_index][1][entry_index]
-                if old_kind == 'd':
+                if old_kind == b'd':
                     # This was a directory, and the active tree says it
                     # doesn't exist, and now the basis tree says it doesn't
                     # exist. Remove its dirblock if present
@@ -1877,7 +1877,7 @@
                 self._raise_invalid(dirname_utf8.decode('utf8'),
                     file_id, "This parent is not present.")
             # Parents of things must be directories
-            if entry[1][index][0] != 'd':
+            if entry[1][index][0] != b'd':
                 self._raise_invalid(dirname_utf8.decode('utf8'),
                     file_id, "This parent is not a directory.")
 

=== modified file 'breezy/bzr/smart/branch.py'
--- breezy/bzr/smart/branch.py	2018-05-21 01:27:32 +0000
+++ breezy/bzr/smart/branch.py	2018-06-21 08:27:55 +0000
@@ -190,7 +190,7 @@
 
     def do_with_branch(self, branch):
         stacked_on_url = branch.get_stacked_on_url()
-        return SuccessfulSmartServerResponse((b'ok', stacked_on_url))
+        return SuccessfulSmartServerResponse((b'ok', stacked_on_url.encode('ascii')))
 
 
 class SmartServerRequestRevisionHistory(SmartServerBranchRequest):
@@ -236,7 +236,7 @@
         except errors.NoSuchRevision:
             return FailedSmartServerResponse((b'NoSuchRevision', revid))
         return SuccessfulSmartServerResponse(
-            (b'ok', ) + tuple([str(x).encode('ascii') for x in dotted_revno]))
+            (b'ok', ) + tuple([b'%d' % x for x in dotted_revno]))
 
 
 class SmartServerSetTipRequest(SmartServerLockedBranchRequest):
@@ -251,7 +251,7 @@
             msg = e.msg
             if isinstance(msg, unicode):
                 msg = msg.encode('utf-8')
-            return FailedSmartServerResponse(('TipChangeRejected', msg))
+            return FailedSmartServerResponse((b'TipChangeRejected', msg))
 
 
 class SmartServerBranchRequestSetConfigOption(SmartServerLockedBranchRequest):
@@ -328,7 +328,7 @@
                 relation = branch._revision_relations(
                     last_rev, new_last_revision_id, graph)
                 if relation == 'diverged' and not allow_divergence:
-                    return FailedSmartServerResponse(('Diverged',))
+                    return FailedSmartServerResponse((b'Diverged',))
                 if relation == 'a_descends_from_b' and do_not_overwrite_descendant:
                     return SuccessfulSmartServerResponse(
                         (b'ok', last_revno, last_rev))

=== modified file 'breezy/bzr/smart/repository.py'
--- breezy/bzr/smart/repository.py	2018-05-21 01:27:32 +0000
+++ breezy/bzr/smart/repository.py	2018-06-21 08:27:55 +0000
@@ -308,12 +308,12 @@
             # Note that we return an empty body, rather than omitting the body.
             # This way the client knows that it can always expect to find a body
             # in the response for this method, even in the error case.
-            return FailedSmartServerResponse((b'nosuchrevision', revision_id), '')
+            return FailedSmartServerResponse((b'nosuchrevision', revision_id), b'')
 
         for revision, parents in revision_graph.items():
             lines.append(b' '.join((revision, ) + tuple(parents)))
 
-        return SuccessfulSmartServerResponse((b'ok', ), '\n'.join(lines))
+        return SuccessfulSmartServerResponse((b'ok', ), b'\n'.join(lines))
 
 
 class SmartServerRepositoryGetRevIdForRevno(SmartServerRepositoryReadLocked):

=== modified file 'breezy/bzr/workingtree_4.py'
--- breezy/bzr/workingtree_4.py	2018-06-04 11:35:48 +0000
+++ breezy/bzr/workingtree_4.py	2018-06-21 08:27:55 +0000
@@ -1379,7 +1379,7 @@
         """See dirstate.SHA1Provider.stat_and_sha1()."""
         filters = self.tree._content_filter_stack(
             self.tree.relpath(osutils.safe_unicode(abspath)))
-        with file(abspath, 'rb', 65000) as file_obj:
+        with open(abspath, 'rb', 65000) as file_obj:
             statvalue = os.fstat(file_obj.fileno())
             if filters:
                 file_obj = _mod_filters.filtered_input_file(file_obj, filters)
@@ -1797,7 +1797,7 @@
         parent_index = self._dirstate.get_parent_ids().index(self._revision_id) + 1
         # This is identical now to the WorkingTree _generate_inventory except
         # for the tree index use.
-        root_key, current_entry = self._dirstate._get_entry(parent_index, path_utf8='')
+        root_key, current_entry = self._dirstate._get_entry(parent_index, path_utf8=b'')
         current_id = root_key[2]
         if current_entry[parent_index][0] != b'd':
             raise AssertionError()

=== modified file 'breezy/bzr/xml_serializer.py'
--- breezy/bzr/xml_serializer.py	2018-06-12 16:49:43 +0000
+++ breezy/bzr/xml_serializer.py	2018-06-21 08:27:55 +0000
@@ -346,9 +346,8 @@
     if elt.tag != 'inventory':
         raise errors.UnexpectedInventoryFormat('Root tag is %r' % elt.tag)
     format = elt.get('format')
-    if format is not None:
-        format = format.encode()
-    if format != format_num:
+    if ((format is None and format_num is not None)
+            or format.encode() != format_num):
         raise errors.UnexpectedInventoryFormat('Invalid format version %r'
                                                % format)
     revision_id = elt.get('revision_id')

=== modified file 'breezy/conflicts.py'
--- breezy/conflicts.py	2017-11-12 20:07:32 +0000
+++ breezy/conflicts.py	2018-06-21 08:27:55 +0000
@@ -386,7 +386,9 @@
     def __cmp__(self, other):
         if getattr(other, "_cmp_list", None) is None:
             return -1
-        return cmp(self._cmp_list(), other._cmp_list())
+        x = self._cmp_list()
+        y = other._cmp_list()
+        return (x > y) - (x < y)
 
     def __hash__(self):
         return hash((type(self), self.path, self.file_id))

=== modified file 'breezy/info.py'
--- breezy/info.py	2018-06-14 10:06:05 +0000
+++ breezy/info.py	2018-06-21 08:27:55 +0000
@@ -339,7 +339,7 @@
         f.write('  %8d KiB\n' % (stats['size']/1024))
     for hook in hooks['repository']:
         hook(repository, stats, f)
-    if f.getvalue() != "":
+    if f.getvalue() != b"":
         outfile.write('\n')
         outfile.write('Repository:\n')
         outfile.write(f.getvalue())

=== modified file 'breezy/mail_client.py'
--- breezy/mail_client.py	2017-07-16 01:55:39 +0000
+++ breezy/mail_client.py	2018-06-21 08:27:55 +0000
@@ -30,7 +30,10 @@
     msgeditor,
     osutils,
     urlutils,
-    registry
+    registry,
+    )
+from .sixish import (
+    text_type,
     )
 
 mail_client_registry = registry.Registry()
@@ -232,7 +235,7 @@
         :param  u:  possible unicode string.
         :return:    encoded string if u is unicode, u itself otherwise.
         """
-        if isinstance(u, unicode):
+        if isinstance(u, text_type):
             return u.encode(osutils.get_user_encoding(), 'replace')
         return u
 
@@ -245,7 +248,7 @@
                         path itself otherwise.
         :raise:         UnableEncodePath.
         """
-        if isinstance(path, unicode):
+        if isinstance(path, text_type):
             try:
                 return path.encode(osutils.get_user_encoding())
             except UnicodeEncodeError:

=== modified file 'breezy/plugins/git/cache.py'
--- breezy/plugins/git/cache.py	2018-05-13 22:54:28 +0000
+++ breezy/plugins/git/cache.py	2018-06-21 08:27:55 +0000
@@ -414,7 +414,7 @@
         if path is None:
             self.db = sqlite3.connect(":memory:")
         else:
-            if not mapdbs().has_key(path):
+            if path not in mapdbs():
                 mapdbs()[path] = sqlite3.connect(path)
             self.db = mapdbs()[path]
         self.db.text_factory = str
@@ -616,7 +616,7 @@
         else:
             if type(path) is not str:
                 raise TypeError(path)
-            if not mapdbs().has_key(path):
+            if path not in mapdbs():
                 mapdbs()[path] = tdb.Tdb(path, self.TDB_HASH_SIZE, tdb.DEFAULT,
                                           os.O_RDWR|os.O_CREAT)
             self.db = mapdbs()[path]

=== modified file 'breezy/plugins/git/git_remote_helper.py'
--- breezy/plugins/git/git_remote_helper.py	2018-03-26 22:28:24 +0000
+++ breezy/plugins/git/git_remote_helper.py	2018-06-21 08:27:55 +0000
@@ -79,7 +79,7 @@
     else:
         lossy = True
     inter.fetch_objects(revs, lossy=lossy)
-    outf.write("\n")
+    outf.write(b"\n")
 
 
 def push(outf, wants, shortname, remote_dir, local_dir):
@@ -93,8 +93,8 @@
         except NotBranchError:
             remote_branch = remote_dir.create_branch(name=dest_branch_name)
         local_branch.push(remote_branch)
-        outf.write("ok %s\n" % dest_ref)
-    outf.write("\n")
+        outf.write(b"ok %s\n" % dest_ref)
+    outf.write(b"\n")
 
 
 class RemoteHelper(object):
@@ -108,7 +108,7 @@
         self.wants = []
 
     def cmd_capabilities(self, outf, argv):
-        outf.write("\n".join(CAPABILITIES)+"\n\n")
+        outf.write(b"\n".join([c.encode() for c in CAPABILITIES])+b"\n\n")
 
     def cmd_list(self, outf, argv):
         try:
@@ -120,11 +120,11 @@
             refs = get_refs_container(self.remote_dir, object_store)
             for ref, git_sha1 in refs.as_dict().iteritems():
                 ref = ref.replace("~", "_")
-                outf.write("%s %s\n" % (git_sha1, ref))
-            outf.write("\n")
+                outf.write(b"%s %s\n" % (git_sha1, ref))
+            outf.write(b"\n")
 
     def cmd_option(self, outf, argv):
-        outf.write("unsupported\n")
+        outf.write(b"unsupported\n")
 
     def cmd_fetch(self, outf, argv):
         if self.batchcmd not in (None, "fetch"):

=== modified file 'breezy/plugins/git/tests/test_branch.py'
--- breezy/plugins/git/tests/test_branch.py	2018-05-14 20:02:30 +0000
+++ breezy/plugins/git/tests/test_branch.py	2018-06-21 08:27:55 +0000
@@ -100,7 +100,7 @@
         r = GitRepo.init('.')
         self.build_tree(['a'])
         r.stage(["a"])
-        return r.do_commit("a", committer="Somebody <[e-mail]>")
+        return r.do_commit("a", committer=b"Somebody <[e-mail]>")
 
     def test_last_revision_is_valid(self):
         head = self.simple_commit_a()
@@ -113,7 +113,7 @@
         self.build_tree(['b'])
         r = GitRepo(".")
         r.stage("b")
-        revb = r.do_commit("b", committer="Somebody <[e-mail]>")
+        revb = r.do_commit("b", committer=b"Somebody <[e-mail]>")
 
         thebranch = Branch.open('.')
         self.assertEqual((2, default_mapping.revision_id_foreign_to_bzr(revb)), thebranch.last_revision_info())

=== modified file 'breezy/plugins/git/tests/test_memorytree.py'
--- breezy/plugins/git/tests/test_memorytree.py	2018-05-13 22:54:28 +0000
+++ breezy/plugins/git/tests/test_memorytree.py	2018-06-21 08:27:55 +0000
@@ -170,18 +170,18 @@
         self.addCleanup(tree.unlock)
         tree.add(['', 'foo'], ['root-id', 'foo-id'], ['directory', 'file'])
         tree.put_file_bytes_non_atomic('foo', 'content\n')
-        tree.commit('one', rev_id='rev-one')
+        tree.commit('one', rev_id=b'rev-one')
         tree.rename_one('foo', 'bar')
         self.assertEqual('bar', tree.id2path('foo-id'))
         self.assertEqual('content\n', tree._file_transport.get_bytes('bar'))
         self.assertRaises(errors.NoSuchFile,
                           tree._file_transport.get_bytes, 'foo')
-        tree.commit('two', rev_id='rev-two')
+        tree.commit('two', rev_id=b'rev-two')
         self.assertEqual('content\n', tree._file_transport.get_bytes('bar'))
         self.assertRaises(errors.NoSuchFile,
                           tree._file_transport.get_bytes, 'foo')
 
-        rev_tree2 = tree.branch.repository.revision_tree('rev-two')
+        rev_tree2 = tree.branch.repository.revision_tree(b'rev-two')
         self.assertEqual('bar', rev_tree2.id2path('foo-id'))
         self.assertEqual('content\n', rev_tree2.get_file_text('bar'))
 

=== modified file 'breezy/plugins/git/tests/test_object_store.py'
--- breezy/plugins/git/tests/test_object_store.py	2018-05-14 20:02:30 +0000
+++ breezy/plugins/git/tests/test_object_store.py	2018-06-21 08:27:55 +0000
@@ -148,7 +148,7 @@
 
     def test_get_blob(self):
         b = Blob()
-        b.data = 'a\nb\nc\nd\ne\n'
+        b.data = b'a\nb\nc\nd\ne\n'
         self.store.lock_read()
         self.addCleanup(self.store.unlock)
         self.assertRaises(KeyError, self.store.__getitem__, b.id)
@@ -167,7 +167,7 @@
 
     def test_get_raw(self):
         b = Blob()
-        b.data = 'a\nb\nc\nd\ne\n'
+        b.data = b'a\nb\nc\nd\ne\n'
         self.store.lock_read()
         self.addCleanup(self.store.unlock)
         self.assertRaises(KeyError, self.store.get_raw, b.id)

=== modified file 'breezy/plugins/repodebug/file_refs.py'
--- breezy/plugins/repodebug/file_refs.py	2018-03-24 23:36:29 +0000
+++ breezy/plugins/repodebug/file_refs.py	2018-06-21 08:27:55 +0000
@@ -32,8 +32,8 @@
     takes_options = ['directory']
 
     def run(self, file_id, rev_id, directory=u'.'):
-        file_id = file_id.decode('ascii')
-        rev_id = rev_id.decode('ascii')
+        file_id = file_id.encode()
+        rev_id = rev_id.encode()
         bd, relpath = controldir.ControlDir.open_containing(directory)
         repo = bd.find_repository()
         self.add_cleanup(repo.lock_read().unlock)
@@ -47,4 +47,4 @@
                 # This file doesn't even appear in this inv.
                 continue
             if entry.revision == rev_id:
-                self.outf.write(inv.revision_id + '\n')
+                self.outf.write(inv.revision_id + b'\n')

=== modified file 'breezy/plugins/repodebug/missing_keys_for_stacking_fixer.py'
--- breezy/plugins/repodebug/missing_keys_for_stacking_fixer.py	2017-09-07 08:21:29 +0000
+++ breezy/plugins/repodebug/missing_keys_for_stacking_fixer.py	2018-06-21 08:27:55 +0000
@@ -19,6 +19,7 @@
 from ...controldir import ControlDir
 from ...commands import Command, Option
 from ... import errors
+from ...sixish import viewvalues
 from ...bzr.vf_search import PendingAncestryResult
 from ...revision import NULL_REVISION
 
@@ -63,7 +64,7 @@
             revs = raw_r.all_revision_ids()
             rev_parents = raw_r.get_graph().get_parent_map(revs)
             needed = set()
-            map(needed.update, rev_parents.itervalues())
+            map(needed.update, viewvalues(rev_parents))
             needed.discard(NULL_REVISION)
             needed = set((rev,) for rev in needed)
             needed = needed - raw_r.inventories.keys()

=== modified file 'breezy/plugins/repodebug/tests/__init__.py'
--- breezy/plugins/repodebug/tests/__init__.py	2017-09-07 08:21:29 +0000
+++ breezy/plugins/repodebug/tests/__init__.py	2018-06-21 08:27:55 +0000
@@ -24,21 +24,21 @@
 
     def test_check_chk(self):
         out, err = self.run_bzr('check-chk')
-        self.assertEqual(out, '')
-        self.assertEqual(err, '')
+        self.assertEqual(out, b'')
+        self.assertEqual(err, b'')
 
     def test_chk_used_by(self):
         self.make_branch_and_tree('.')
         out, err = self.run_bzr('chk-used-by chk')
-        self.assertEqual(out, '')
-        self.assertEqual(err, '')
+        self.assertEqual(out, b'')
+        self.assertEqual(err, b'')
 
     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, 'Done.\n')
-        self.assertEqual(err, '')
+        self.assertEqual(out, b'Done.\n')
+        self.assertEqual(err, b'')
 
     def test_file_refs(self):
         tree = self.make_branch_and_tree('.')
@@ -46,35 +46,35 @@
         tree.add('foo')
         revid = tree.commit('a commit')
         out, err = self.run_bzr(
-                'file-refs ' + tree.path2id('foo') + ' ' + revid)
-        self.assertEqual(out, revid + '\n')
-        self.assertEqual(err, '')
+                'file-refs ' + tree.path2id('foo').decode() + ' ' + revid.decode())
+        self.assertEqual(out, revid + b'\n')
+        self.assertEqual(err, b'')
 
     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, '')
-        self.assertEqual(err, '')
+        self.assertEqual(out, b'')
+        self.assertEqual(err, b'')
 
     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, '')
-        self.assertEqual(err, '')
+        self.assertEqual(out, b'')
+        self.assertEqual(err, b'')
 
     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, 'False\n')
-        self.assertEqual(err, '')
+        self.assertEqual(out, b'False\n')
+        self.assertEqual(err, b'')
 
     def test_repo_keys(self):
         self.make_branch_and_tree('a')
         out, err = self.run_bzr('repo-keys a texts')
-        self.assertEqual(out, '')
-        self.assertEqual(err, '')
+        self.assertEqual(out, b'')
+        self.assertEqual(err, b'')
 
 
 def test_suite():

=== modified file 'breezy/plugins/upload/tests/test_upload.py'
--- breezy/plugins/upload/tests/test_upload.py	2018-05-11 10:17:28 +0000
+++ breezy/plugins/upload/tests/test_upload.py	2018-06-21 08:27:55 +0000
@@ -220,7 +220,7 @@
     def _test_create_file(self, file_name):
         self.make_branch_and_working_tree()
         self.do_full_upload()
-        self.add_file(file_name, 'foo')
+        self.add_file(file_name, b'foo')
 
         self.do_upload()
 
@@ -238,7 +238,7 @@
         self.do_full_upload()
         self.add_dir(dir_name)
         fpath = '%s/%s' % (dir_name, file_name)
-        self.add_file(fpath, 'baz')
+        self.add_file(fpath, b'baz')
 
         self.assertUpPathDoesNotExist(fpath)
 
@@ -256,7 +256,7 @@
 
     def test_modify_file(self):
         self.make_branch_and_working_tree()
-        self.add_file('hello', 'foo')
+        self.add_file('hello', b'foo')
         self.do_full_upload()
         self.modify_file('hello', 'bar')
 
@@ -268,7 +268,7 @@
 
     def _test_rename_one_file(self, old_name, new_name):
         self.make_branch_and_working_tree()
-        self.add_file(old_name, 'foo')
+        self.add_file(old_name, b'foo')
         self.do_full_upload()
         self.rename_any(old_name, new_name)
 
@@ -287,7 +287,7 @@
 
     def test_rename_and_change_file(self):
         self.make_branch_and_working_tree()
-        self.add_file('hello', 'foo')
+        self.add_file('hello', b'foo')
         self.do_full_upload()
         self.rename_any('hello', 'goodbye')
         self.modify_file('goodbye', 'bar')
@@ -300,8 +300,8 @@
 
     def test_rename_two_files(self):
         self.make_branch_and_working_tree()
-        self.add_file('a', 'foo')
-        self.add_file('b', 'qux')
+        self.add_file('a', b'foo')
+        self.add_file('b', b'qux')
         self.do_full_upload()
         # We rely on the assumption that bzr will topologically sort the
         # renames which will cause a -> b to appear *before* b -> c
@@ -319,8 +319,8 @@
     def test_upload_revision(self):
         self.make_branch_and_working_tree() # rev1
         self.do_full_upload()
-        self.add_file('hello', 'foo') # rev2
-        self.modify_file('hello', 'bar') # rev3
+        self.add_file('hello', b'foo') # rev2
+        self.modify_file('hello', b'bar') # rev3
 
         self.assertUpPathDoesNotExist('hello')
 
@@ -331,18 +331,18 @@
 
     def test_no_upload_when_changes(self):
         self.make_branch_and_working_tree()
-        self.add_file('a', 'foo')
-        self.set_file_content('a', 'bar')
+        self.add_file('a', b'foo')
+        self.set_file_content('a', b'bar')
 
         self.assertRaises(errors.UncommittedChanges, self.do_upload)
 
     def test_no_upload_when_conflicts(self):
         self.make_branch_and_working_tree()
-        self.add_file('a', 'foo')
+        self.add_file('a', b'foo')
         self.run_bzr('branch branch other')
-        self.modify_file('a', 'bar')
+        self.modify_file('a', b'bar')
         other_tree = workingtree.WorkingTree.open('other')
-        self.set_file_content('a', 'baz', 'other/')
+        self.set_file_content('a', 'baz', b'other/')
         other_tree.commit('modify file a')
 
         self.run_bzr('merge -d branch other', retcode=1)
@@ -351,11 +351,11 @@
 
     def _test_change_file_into_dir(self, file_name):
         self.make_branch_and_working_tree()
-        self.add_file(file_name, 'foo')
+        self.add_file(file_name, b'foo')
         self.do_full_upload()
         self.transform_file_into_dir(file_name)
         fpath = '%s/%s' % (file_name, 'file')
-        self.add_file(fpath, 'bar')
+        self.add_file(fpath, b'bar')
 
         self.assertUpFileEqual('foo', file_name)
 
@@ -373,7 +373,7 @@
     def test_change_dir_into_file(self):
         self.make_branch_and_working_tree()
         self.add_dir('hello')
-        self.add_file('hello/file', 'foo')
+        self.add_file('hello/file', b'foo')
         self.do_full_upload()
         self.delete_any('hello/file')
         self.transform_dir_into_file('hello', 'bar')
@@ -386,7 +386,7 @@
 
     def _test_make_file_executable(self, file_name):
         self.make_branch_and_working_tree()
-        self.add_file(file_name, 'foo')
+        self.add_file(file_name, b'foo')
         self.chmod_file(file_name, 0o664)
         self.do_full_upload()
         self.chmod_file(file_name, 0o755)
@@ -434,14 +434,14 @@
         """Test that upload --auto sets the upload_auto option"""
         self.make_branch_and_working_tree()
 
-        self.add_file('hello', 'foo')
+        self.add_file('hello', b'foo')
         self.assertFalse(self.get_upload_auto())
         self.do_full_upload(auto=True)
         self.assertUpFileEqual('foo', 'hello')
         self.assertTrue(self.get_upload_auto())
 
         # and check that it stays set until it is unset
-        self.add_file('bye', 'bar')
+        self.add_file('bye', b'bar')
         self.do_full_upload()
         self.assertUpFileEqual('bar', 'bye')
         self.assertTrue(self.get_upload_auto())
@@ -450,18 +450,18 @@
         """Test that upload --no-auto unsets the upload_auto option"""
         self.make_branch_and_working_tree()
 
-        self.add_file('hello', 'foo')
+        self.add_file('hello', b'foo')
         self.do_full_upload(auto=True)
         self.assertUpFileEqual('foo', 'hello')
         self.assertTrue(self.get_upload_auto())
 
-        self.add_file('bye', 'bar')
+        self.add_file('bye', b'bar')
         self.do_full_upload(auto=False)
         self.assertUpFileEqual('bar', 'bye')
         self.assertFalse(self.get_upload_auto())
 
         # and check that it stays unset until it is set
-        self.add_file('again', 'baz')
+        self.add_file('again', b'baz')
         self.do_full_upload()
         self.assertUpFileEqual('baz', 'again')
         self.assertFalse(self.get_upload_auto())
@@ -476,7 +476,7 @@
     def test_upload_revid_path_in_dir(self):
         self.make_branch_and_working_tree()
         self.add_dir('dir')
-        self.add_file('dir/goodbye', 'baz')
+        self.add_file('dir/goodbye', b'baz')
 
         revid_path = 'dir/revid-path'
         self.tree.branch.get_config_stack(
@@ -485,7 +485,7 @@
 
         self.do_full_upload()
 
-        self.add_file('dir/hello', 'foo')
+        self.add_file('dir/hello', b'foo')
 
         self.do_upload()
 
@@ -496,8 +496,8 @@
     def test_ignore_file(self):
         self.make_branch_and_working_tree()
         self.do_full_upload()
-        self.add_file('.bzrignore-upload', 'foo')
-        self.add_file('foo', 'bar')
+        self.add_file('.bzrignore-upload', b'foo')
+        self.add_file('foo', b'bar')
 
         self.do_upload()
 
@@ -506,8 +506,8 @@
     def test_ignore_regexp(self):
         self.make_branch_and_working_tree()
         self.do_full_upload()
-        self.add_file('.bzrignore-upload', 'f*')
-        self.add_file('foo', 'bar')
+        self.add_file('.bzrignore-upload', b'f*')
+        self.add_file('foo', b'bar')
 
         self.do_upload()
 
@@ -516,7 +516,7 @@
     def test_ignore_directory(self):
         self.make_branch_and_working_tree()
         self.do_full_upload()
-        self.add_file('.bzrignore-upload', 'dir')
+        self.add_file('.bzrignore-upload', b'dir')
         self.add_dir('dir')
 
         self.do_upload()
@@ -526,10 +526,10 @@
     def test_ignore_nested_directory(self):
         self.make_branch_and_working_tree()
         self.do_full_upload()
-        self.add_file('.bzrignore-upload', 'dir')
+        self.add_file('.bzrignore-upload', b'dir')
         self.add_dir('dir')
         self.add_dir('dir/foo')
-        self.add_file('dir/foo/bar', 'bar contents')
+        self.add_file('dir/foo/bar', b'bar contents')
 
         self.do_upload()
 
@@ -538,11 +538,11 @@
 
     def test_ignore_change_file_into_dir(self):
         self.make_branch_and_working_tree()
-        self.add_file('hello', 'foo')
+        self.add_file('hello', b'foo')
         self.do_full_upload()
-        self.add_file('.bzrignore-upload', 'hello')
+        self.add_file('.bzrignore-upload', b'hello')
         self.transform_file_into_dir('hello')
-        self.add_file('hello/file', 'bar')
+        self.add_file('hello/file', b'bar')
 
         self.assertUpFileEqual('foo', 'hello')
 
@@ -553,10 +553,10 @@
     def test_ignore_change_dir_into_file(self):
         self.make_branch_and_working_tree()
         self.add_dir('hello')
-        self.add_file('hello/file', 'foo')
+        self.add_file('hello/file', b'foo')
         self.do_full_upload()
 
-        self.add_file('.bzrignore-upload', 'hello')
+        self.add_file('.bzrignore-upload', b'hello')
         self.delete_any('hello/file')
         self.transform_dir_into_file('hello', 'bar')
 
@@ -570,9 +570,9 @@
         self.make_branch_and_working_tree()
         self.add_dir('dir')
         self.add_dir('dir/subdir')
-        self.add_file('dir/subdir/a', 'foo')
+        self.add_file('dir/subdir/a', b'foo')
         self.do_full_upload()
-        self.add_file('.bzrignore-upload', 'dir/subdir')
+        self.add_file('.bzrignore-upload', b'dir/subdir')
         self.rename_any('dir/subdir/a', 'dir/a')
         self.delete_any('dir/subdir')
 
@@ -611,7 +611,7 @@
         self.make_branch_and_working_tree()
         self.add_dir('dir')
         self.do_full_upload()
-        self.add_file('dir/goodbye', 'baz')
+        self.add_file('dir/goodbye', b'baz')
 
         self.assertUpPathDoesNotExist('dir/goodbye')
 
@@ -629,7 +629,7 @@
 
     def test_delete_one_file(self):
         self.make_branch_and_working_tree()
-        self.add_file('hello', 'foo')
+        self.add_file('hello', b'foo')
         self.do_full_upload()
         self.delete_any('hello')
 
@@ -643,7 +643,7 @@
         self.make_branch_and_working_tree()
         self.add_dir('dir')
         self.add_dir('dir/subdir')
-        self.add_file('dir/subdir/a', 'foo')
+        self.add_file('dir/subdir/a', b'foo')
         self.do_full_upload()
         self.rename_any('dir/subdir/a', 'a')
         self.delete_any('dir/subdir')
@@ -660,8 +660,8 @@
 
     def test_delete_one_file_rename_to_deleted(self):
         self.make_branch_and_working_tree()
-        self.add_file('a', 'foo')
-        self.add_file('b', 'bar')
+        self.add_file('a', b'foo')
+        self.add_file('b', b'bar')
         self.do_full_upload()
         self.delete_any('a')
         self.rename_any('b', 'a')
@@ -676,7 +676,7 @@
     def test_rename_outside_dir_delete_dir(self):
         self.make_branch_and_working_tree()
         self.add_dir('dir')
-        self.add_file('dir/a', 'foo')
+        self.add_file('dir/a', b'foo')
         self.do_full_upload()
         self.rename_any('dir/a', 'a')
         self.delete_any('dir')
@@ -701,7 +701,7 @@
 
     def test_upload_for_the_first_time_do_a_full_upload(self):
         self.make_branch_and_working_tree()
-        self.add_file('hello', 'bar')
+        self.add_file('hello', b'bar')
 
         revid_path = self.tree.branch.get_config_stack(
             ).get('upload_revid_location')
@@ -713,9 +713,9 @@
 
     def test_ignore_delete_one_file(self):
         self.make_branch_and_working_tree()
-        self.add_file('hello', 'foo')
+        self.add_file('hello', b'foo')
         self.do_full_upload()
-        self.add_file('.bzrignore-upload', 'hello')
+        self.add_file('.bzrignore-upload', b'hello')
         self.delete_any('hello')
 
         self.assertUpFileEqual('foo', 'hello')
@@ -773,7 +773,7 @@
         working tree.
         """
         self.make_branch_and_working_tree()
-        self.add_file('hello', 'foo')
+        self.add_file('hello', b'foo')
 
         remote_branch_url = self.get_url(self.remote_branch_dir)
         self.run_bzr(['push', remote_branch_url,
@@ -836,6 +836,6 @@
         t = self.get_transport(self.upload_dir)
         t.put_bytes('.bzr-upload.revid', 'fake')
         # Make a change
-        self.add_file('foo', 'bar\n')
+        self.add_file('foo', b'bar\n')
         self.assertRaises(cmds.DivergedUploadedTree, self.do_full_upload)
 

=== modified file 'breezy/tests/__init__.py'
--- breezy/tests/__init__.py	2018-05-11 00:02:31 +0000
+++ breezy/tests/__init__.py	2018-06-21 08:27:55 +0000
@@ -1538,7 +1538,8 @@
 
     def assertPathExists(self, path):
         """Fail unless path or paths, which may be abs or relative, exist."""
-        if not isinstance(path, (str, text_type)):
+        # TODO(jelmer): Clean this up for pad.lv/1696545
+        if not isinstance(path, (bytes, str, text_type)):
             for p in path:
                 self.assertPathExists(p)
         else:

=== modified file 'breezy/tests/blackbox/test_branch.py'
--- breezy/tests/blackbox/test_branch.py	2018-03-25 00:39:16 +0000
+++ breezy/tests/blackbox/test_branch.py	2018-06-21 08:27:55 +0000
@@ -227,18 +227,18 @@
         tree_b.add('file')
         tree_b.commit('commit b-1', rev_id=b'b-1')
 
-        self.assertTrue(shared_repo.has_revision('a-1'))
-        self.assertTrue(shared_repo.has_revision('a-2'))
-        self.assertTrue(shared_repo.has_revision('b-1'))
+        self.assertTrue(shared_repo.has_revision(b'a-1'))
+        self.assertTrue(shared_repo.has_revision(b'a-2'))
+        self.assertTrue(shared_repo.has_revision(b'b-1'))
 
         # Now that we have a repository with shared files, make sure
         # that things aren't copied out by a 'branch'
         self.run_bzr('branch repo/b branch-b')
         pushed_tree = WorkingTree.open('branch-b')
         pushed_repo = pushed_tree.branch.repository
-        self.assertFalse(pushed_repo.has_revision('a-1'))
-        self.assertFalse(pushed_repo.has_revision('a-2'))
-        self.assertTrue(pushed_repo.has_revision('b-1'))
+        self.assertFalse(pushed_repo.has_revision(b'a-1'))
+        self.assertFalse(pushed_repo.has_revision(b'a-2'))
+        self.assertTrue(pushed_repo.has_revision(b'b-1'))
 
     def test_branch_hardlink(self):
         self.requireFeature(HardlinkFeature)

=== modified file 'breezy/tests/blackbox/test_merge.py'
--- breezy/tests/blackbox/test_merge.py	2018-05-13 02:18:13 +0000
+++ breezy/tests/blackbox/test_merge.py	2018-06-21 08:27:55 +0000
@@ -688,16 +688,16 @@
         target_bzrdir = source.controldir.sprout('target')
         # Add a non-ancestry tag to source
         builder.build_commit(message="Rev 2a", rev_id=b'rev-2a')
-        source.tags.set_tag('tag-a', 'rev-2a')
-        source.set_last_revision_info(1, 'rev-1')
+        source.tags.set_tag('tag-a', b'rev-2a')
+        source.set_last_revision_info(1, b'rev-1')
         source.get_config_stack().set('branch.fetch_tags', True)
         builder.build_commit(message="Rev 2b", rev_id=b'rev-2b')
         # Merge from source
         self.run_bzr('merge -d target source')
         target = target_bzrdir.open_branch()
         # The tag is present, and so is its revision.
-        self.assertEqual('rev-2a', target.tags.lookup_tag('tag-a'))
-        target.repository.get_revision('rev-2a')
+        self.assertEqual(b'rev-2a', target.tags.lookup_tag('tag-a'))
+        target.repository.get_revision(b'rev-2a')
 
 
 class TestMergeRevisionRange(tests.TestCaseWithTransport):

=== modified file 'breezy/tests/blackbox/test_push.py'
--- breezy/tests/blackbox/test_push.py	2018-03-26 00:54:10 +0000
+++ breezy/tests/blackbox/test_push.py	2018-06-21 08:27:55 +0000
@@ -210,7 +210,7 @@
         tree_a.add('file')
         tree_a.commit('commit a-1', rev_id=b'a-1')
         f = open('repo/a/file', 'ab')
-        f.write('more stuff\n')
+        f.write(b'more stuff\n')
         f.close()
         tree_a.commit('commit a-2', rev_id=b'a-2')
 
@@ -219,18 +219,18 @@
         tree_b.add('file')
         tree_b.commit('commit b-1', rev_id=b'b-1')
 
-        self.assertTrue(shared_repo.has_revision('a-1'))
-        self.assertTrue(shared_repo.has_revision('a-2'))
-        self.assertTrue(shared_repo.has_revision('b-1'))
+        self.assertTrue(shared_repo.has_revision(b'a-1'))
+        self.assertTrue(shared_repo.has_revision(b'a-2'))
+        self.assertTrue(shared_repo.has_revision(b'b-1'))
 
         # Now that we have a repository with shared files, make sure
         # that things aren't copied out by a 'push'
         self.run_bzr('push ../../push-b', working_dir='repo/b')
         pushed_tree = workingtree.WorkingTree.open('push-b')
         pushed_repo = pushed_tree.branch.repository
-        self.assertFalse(pushed_repo.has_revision('a-1'))
-        self.assertFalse(pushed_repo.has_revision('a-2'))
-        self.assertTrue(pushed_repo.has_revision('b-1'))
+        self.assertFalse(pushed_repo.has_revision(b'a-1'))
+        self.assertFalse(pushed_repo.has_revision(b'a-2'))
+        self.assertTrue(pushed_repo.has_revision(b'b-1'))
 
     def test_push_funky_id(self):
         t = self.make_branch_and_tree('tree')
@@ -445,16 +445,16 @@
     def test_push_with_revisionspec(self):
         """We should be able to push a revision older than the tip."""
         tree_from = self.make_branch_and_tree('from')
-        tree_from.commit("One.", rev_id="from-1")
-        tree_from.commit("Two.", rev_id="from-2")
+        tree_from.commit("One.", rev_id=b"from-1")
+        tree_from.commit("Two.", rev_id=b"from-2")
 
         self.run_bzr('push -r1 ../to', working_dir='from')
 
         tree_to = workingtree.WorkingTree.open('to')
         repo_to = tree_to.branch.repository
-        self.assertTrue(repo_to.has_revision('from-1'))
-        self.assertFalse(repo_to.has_revision('from-2'))
-        self.assertEqual(tree_to.branch.last_revision_info()[1], 'from-1')
+        self.assertTrue(repo_to.has_revision(b'from-1'))
+        self.assertFalse(repo_to.has_revision(b'from-2'))
+        self.assertEqual(tree_to.branch.last_revision_info()[1], b'from-1')
         self.assertFalse(
             tree_to.changes_from(tree_to.basis_tree()).has_changed())
 

=== modified file 'breezy/tests/blackbox/test_tags.py'
--- breezy/tests/blackbox/test_tags.py	2018-02-18 15:21:06 +0000
+++ breezy/tests/blackbox/test_tags.py	2018-06-21 08:27:55 +0000
@@ -181,8 +181,8 @@
         self.assertEqual(expected_tag_dict, child.branch.tags.get_tag_dict())
         self.assertEqual(expected_tag_dict, master.tags.get_tag_dict())
         # Revisions not in ancestry but named in tags are present
-        child.branch.repository.get_revision('fork-0')
-        master.repository.get_revision('fork-0')
+        child.branch.repository.get_revision(b'fork-0')
+        master.repository.get_revision(b'fork-0')
 
     def test_commit_in_heavyweight_checkout_reports_tag_conflict(self):
         master, child = self.make_master_and_checkout()

=== modified file 'breezy/tests/per_bzrdir/test_bzrdir.py'
--- breezy/tests/per_bzrdir/test_bzrdir.py	2018-02-18 15:21:06 +0000
+++ breezy/tests/per_bzrdir/test_bzrdir.py	2018-06-21 08:27:55 +0000
@@ -236,7 +236,7 @@
         dir = self.make_controldir('source')
         repo = dir.create_repository()
         repo.fetch(tree.branch.repository)
-        self.assertTrue(repo.has_revision('1'))
+        self.assertTrue(repo.has_revision(b'1'))
         try:
             self.make_repository('target', shared=True)
         except errors.IncompatibleFormat:
@@ -302,7 +302,7 @@
         dir = self.make_controldir('source')
         repo = dir.create_repository()
         repo.fetch(tree.branch.repository)
-        self.assertTrue(repo.has_revision('1'))
+        self.assertTrue(repo.has_revision(b'1'))
         target = dir.clone(self.get_url('target'))
         self.assertNotEqual(dir.transport.base, target.transport.base)
         self.assertDirectoriesEqual(dir.root_transport, target.root_transport,
@@ -430,7 +430,7 @@
         dir = self.make_controldir('source')
         repo = dir.create_repository()
         repo.fetch(tree.branch.repository)
-        self.assertTrue(repo.has_revision('1'))
+        self.assertTrue(repo.has_revision(b'1'))
         try:
             self.assertTrue(
                 _mod_revision.is_null(_mod_revision.ensure_null(
@@ -458,7 +458,7 @@
             inventory_f = file(local_inventory, 'rb')
             self.addCleanup(inventory_f.close)
             self.assertContainsRe(inventory_f.read(),
-                                  '<inventory format="5">\n</inventory>\n')
+                                  b'<inventory format="5">\n</inventory>\n')
         except IOError as e:
             if e.errno != errno.ENOENT:
                 raise

=== modified file 'breezy/tests/per_controldir/test_controldir.py'
--- breezy/tests/per_controldir/test_controldir.py	2018-03-24 14:47:01 +0000
+++ breezy/tests/per_controldir/test_controldir.py	2018-06-21 08:27:55 +0000
@@ -870,7 +870,7 @@
         self.assertEqual('missing-rev', new_branch.tags.lookup_tag('tag-a'))
 
     def test_sprout_bzrdir_passing_rev_not_source_branch_copies_tags(self):
-        # dir.sprout(..., revision_id='rev1') copies rev1, and all the tags of
+        # dir.sprout(..., revision_id=b'rev1') copies rev1, and all the tags of
         # the branch at that bzrdir, the ancestry of all of those, but no other
         # revs (not even the tip of the source branch).
         builder = self.make_branch_builder('source')
@@ -1293,7 +1293,7 @@
         made_control = self.bzrdir_format.initialize(t.base)
         made_repo = made_control.create_repository()
         # Check that we have a repository object.
-        made_repo.has_revision('foo')
+        made_repo.has_revision(b'foo')
         self.assertEqual(made_control, made_repo.controldir)
 
     def test_create_repository_shared(self):

=== modified file 'breezy/tests/per_interrepository/test_fetch.py'
--- breezy/tests/per_interrepository/test_fetch.py	2018-05-13 02:45:58 +0000
+++ breezy/tests/per_interrepository/test_fetch.py	2018-06-21 08:27:55 +0000
@@ -64,17 +64,17 @@
         tree_a.commit('rev1', rev_id=b'rev1')
         def check_push_rev1(repo):
             # ensure the revision is missing.
-            self.assertRaises(NoSuchRevision, repo.get_revision, 'rev1')
+            self.assertRaises(NoSuchRevision, repo.get_revision, b'rev1')
             # fetch with a limit of NULL_REVISION
             repo.fetch(tree_a.branch.repository,
                        revision_id=NULL_REVISION)
             # nothing should have been pushed
-            self.assertFalse(repo.has_revision('rev1'))
+            self.assertFalse(repo.has_revision(b'rev1'))
             # fetch with a default limit (grab everything)
             repo.fetch(tree_a.branch.repository)
             # check that b now has all the data from a's first commit.
-            rev = repo.get_revision('rev1')
-            tree = repo.revision_tree('rev1')
+            rev = repo.get_revision(b'rev1')
+            tree = repo.revision_tree(b'rev1')
             tree.lock_read()
             self.addCleanup(tree.unlock)
             tree.get_file_text('foo')
@@ -207,7 +207,7 @@
         builder.start_series()
         builder.build_snapshot(None, [
             ('add', ('', b'root-id', 'directory', '')),
-            ('add', ('file', b'file-id', 'file', 'content\n'))],
+            ('add', ('file', b'file-id', 'file', b'content\n'))],
             revision_id=b'base')
         builder.build_snapshot([b'base'], [
             ('modify', ('file', b'left content\n'))],
@@ -222,30 +222,30 @@
         branch = builder.get_branch()
         repo = self.make_to_repository('trunk')
         trunk = repo.controldir.create_branch()
-        trunk.repository.fetch(branch.repository, 'left')
-        trunk.repository.fetch(branch.repository, 'right')
+        trunk.repository.fetch(branch.repository, b'left')
+        trunk.repository.fetch(branch.repository, b'right')
         repo = self.make_to_repository('stacked')
         stacked_branch = repo.controldir.create_branch()
         stacked_branch.set_stacked_on_url(trunk.base)
-        stacked_branch.repository.fetch(branch.repository, 'merge')
+        stacked_branch.repository.fetch(branch.repository, b'merge')
         unstacked_repo = stacked_branch.controldir.open_repository()
         unstacked_repo.lock_read()
         self.addCleanup(unstacked_repo.unlock)
-        self.assertFalse(unstacked_repo.has_revision('left'))
-        self.assertFalse(unstacked_repo.has_revision('right'))
+        self.assertFalse(unstacked_repo.has_revision(b'left'))
+        self.assertFalse(unstacked_repo.has_revision(b'right'))
         self.assertEqual(
-            {('left',), ('right',), ('merge',)},
+            {(b'left',), (b'right',), (b'merge',)},
             unstacked_repo.inventories.keys())
         # And the basis inventories have been copied correctly
         trunk.lock_read()
         self.addCleanup(trunk.unlock)
         left_tree, right_tree = trunk.repository.revision_trees(
-            ['left', 'right'])
+            [b'left', b'right'])
         stacked_branch.lock_read()
         self.addCleanup(stacked_branch.unlock)
         (stacked_left_tree,
          stacked_right_tree) = stacked_branch.repository.revision_trees(
-            ['left', 'right'])
+            [b'left', b'right'])
         self.assertEqual(
             left_tree.root_inventory, stacked_left_tree.root_inventory)
         self.assertEqual(
@@ -255,15 +255,15 @@
         # present.  The texts introduced in merge (and only those) should be
         # present, and also generating a stream should succeed without blowing
         # up.
-        self.assertTrue(unstacked_repo.has_revision('merge'))
-        expected_texts = {('file-id', 'merge')}
-        if stacked_branch.repository.texts.get_parent_map([('root-id',
-            'merge')]):
+        self.assertTrue(unstacked_repo.has_revision(b'merge'))
+        expected_texts = {(b'file-id', b'merge')}
+        if stacked_branch.repository.texts.get_parent_map([(b'root-id',
+            b'merge')]):
             # If a (root-id,merge) text exists, it should be in the stacked
             # repo.
-            expected_texts.add(('root-id', 'merge'))
+            expected_texts.add((b'root-id', b'merge'))
         self.assertEqual(expected_texts, unstacked_repo.texts.keys())
-        self.assertCanStreamRevision(unstacked_repo, 'merge')
+        self.assertCanStreamRevision(unstacked_repo, b'merge')
 
     def assertCanStreamRevision(self, repo, revision_id):
         exclude_keys = set(repo.all_revision_ids()) - {revision_id}
@@ -293,40 +293,40 @@
         branch = builder.get_branch()
         repo = self.make_to_repository('trunk')
         trunk = repo.controldir.create_branch()
-        trunk.repository.fetch(branch.repository, 'second')
+        trunk.repository.fetch(branch.repository, b'second')
         repo = self.make_to_repository('stacked')
         stacked_branch = repo.controldir.create_branch()
         stacked_branch.set_stacked_on_url(trunk.base)
-        stacked_branch.repository.fetch(branch.repository, 'third')
+        stacked_branch.repository.fetch(branch.repository, b'third')
         unstacked_repo = stacked_branch.controldir.open_repository()
         unstacked_repo.lock_read()
         self.addCleanup(unstacked_repo.unlock)
-        self.assertFalse(unstacked_repo.has_revision('second'))
-        self.assertFalse(unstacked_repo.has_revision('ghost'))
+        self.assertFalse(unstacked_repo.has_revision(b'second'))
+        self.assertFalse(unstacked_repo.has_revision(b'ghost'))
         self.assertEqual(
-            {('second',), ('third',)},
+            {(b'second',), (b'third',)},
             unstacked_repo.inventories.keys())
         # And the basis inventories have been copied correctly
         trunk.lock_read()
         self.addCleanup(trunk.unlock)
-        second_tree = trunk.repository.revision_tree('second')
+        second_tree = trunk.repository.revision_tree(b'second')
         stacked_branch.lock_read()
         self.addCleanup(stacked_branch.unlock)
-        stacked_second_tree = stacked_branch.repository.revision_tree('second')
+        stacked_second_tree = stacked_branch.repository.revision_tree(b'second')
         self.assertEqual(second_tree, stacked_second_tree)
         # Finally, it's not enough to see that the basis inventories are
         # present.  The texts introduced in merge (and only those) should be
         # present, and also generating a stream should succeed without blowing
         # up.
-        self.assertTrue(unstacked_repo.has_revision('third'))
+        self.assertTrue(unstacked_repo.has_revision(b'third'))
         expected_texts = {('file-id', 'third')}
-        if stacked_branch.repository.texts.get_parent_map([('root-id',
-            'third')]):
+        if stacked_branch.repository.texts.get_parent_map([(b'root-id',
+            b'third')]):
             # If a (root-id,third) text exists, it should be in the stacked
             # repo.
-            expected_texts.add(('root-id', 'third'))
+            expected_texts.add((b'root-id', b'third'))
         self.assertEqual(expected_texts, unstacked_repo.texts.keys())
-        self.assertCanStreamRevision(unstacked_repo, 'third')
+        self.assertCanStreamRevision(unstacked_repo, b'third')
 
     def test_fetch_from_stacked_to_stacked_copies_parent_inventories(self):
         """Fetch from a stacked branch copies inventories for parents of
@@ -344,8 +344,8 @@
         builder = self.make_branch_builder('branch')
         builder.start_series()
         builder.build_snapshot(None, [
-            ('add', ('', 'root-id', 'directory', '')),
-            ('add', ('file', 'file-id', 'file', 'content\n'))],
+            ('add', ('', b'root-id', 'directory', '')),
+            ('add', ('file', b'file-id', 'file', b'content\n'))],
             revision_id=b'base')
         builder.build_snapshot([b'base'], [
             ('modify', ('file', b'left content\n'))],
@@ -361,18 +361,18 @@
         repo = self.make_repository('old-trunk')
         # Make a pair of equivalent trunk repos in the from and to formats.
         old_trunk = repo.controldir.create_branch()
-        old_trunk.repository.fetch(branch.repository, 'left')
-        old_trunk.repository.fetch(branch.repository, 'right')
+        old_trunk.repository.fetch(branch.repository, b'left')
+        old_trunk.repository.fetch(branch.repository, b'right')
         repo = self.make_to_repository('new-trunk')
         new_trunk = repo.controldir.create_branch()
-        new_trunk.repository.fetch(branch.repository, 'left')
-        new_trunk.repository.fetch(branch.repository, 'right')
+        new_trunk.repository.fetch(branch.repository, b'left')
+        new_trunk.repository.fetch(branch.repository, b'right')
         # Make the source; a repo stacked on old_trunk contained just the data
         # for 'merge'.
         repo = self.make_repository('old-stacked')
         old_stacked_branch = repo.controldir.create_branch()
         old_stacked_branch.set_stacked_on_url(old_trunk.base)
-        old_stacked_branch.repository.fetch(branch.repository, 'merge')
+        old_stacked_branch.repository.fetch(branch.repository, b'merge')
         # Make the target, a repo stacked on new_trunk.
         repo = self.make_to_repository('new-stacked')
         new_stacked_branch = repo.controldir.create_branch()
@@ -381,41 +381,41 @@
         new_unstacked_repo = new_stacked_branch.controldir.open_repository()
         # Reopen the source and target repos without any fallbacks, and fetch
         # 'merge'.
-        new_unstacked_repo.fetch(old_unstacked_repo, 'merge')
+        new_unstacked_repo.fetch(old_unstacked_repo, b'merge')
         # Now check the results.  new_unstacked_repo should contain all the
         # data necessary to stream 'merge' (i.e. the parent inventories).
         new_unstacked_repo.lock_read()
         self.addCleanup(new_unstacked_repo.unlock)
-        self.assertFalse(new_unstacked_repo.has_revision('left'))
-        self.assertFalse(new_unstacked_repo.has_revision('right'))
+        self.assertFalse(new_unstacked_repo.has_revision(b'left'))
+        self.assertFalse(new_unstacked_repo.has_revision(b'right'))
         self.assertEqual(
-            {('left',), ('right',), ('merge',)},
+            {(b'left',), (b'right',), (b'merge',)},
             new_unstacked_repo.inventories.keys())
         # And the basis inventories have been copied correctly
         new_trunk.lock_read()
         self.addCleanup(new_trunk.unlock)
         left_tree, right_tree = new_trunk.repository.revision_trees(
-            ['left', 'right'])
+            [b'left', b'right'])
         new_stacked_branch.lock_read()
         self.addCleanup(new_stacked_branch.unlock)
         (stacked_left_tree,
          stacked_right_tree) = new_stacked_branch.repository.revision_trees(
-            ['left', 'right'])
+            [b'left', b'right'])
         self.assertEqual(left_tree, stacked_left_tree)
         self.assertEqual(right_tree, stacked_right_tree)
         # Finally, it's not enough to see that the basis inventories are
         # present.  The texts introduced in merge (and only those) should be
         # present, and also generating a stream should succeed without blowing
         # up.
-        self.assertTrue(new_unstacked_repo.has_revision('merge'))
-        expected_texts = {('file-id', 'merge')}
-        if new_stacked_branch.repository.texts.get_parent_map([('root-id',
-            'merge')]):
+        self.assertTrue(new_unstacked_repo.has_revision(b'merge'))
+        expected_texts = {(b'file-id', b'merge')}
+        if new_stacked_branch.repository.texts.get_parent_map([(b'root-id',
+            b'merge')]):
             # If a (root-id,merge) text exists, it should be in the stacked
             # repo.
-            expected_texts.add(('root-id', 'merge'))
+            expected_texts.add((b'root-id', b'merge'))
         self.assertEqual(expected_texts, new_unstacked_repo.texts.keys())
-        self.assertCanStreamRevision(new_unstacked_repo, 'merge')
+        self.assertCanStreamRevision(new_unstacked_repo, b'merge')
 
     def test_fetch_missing_basis_text(self):
         """If fetching a delta, we should die if a basis is not present."""
@@ -429,27 +429,24 @@
         to_repo = self.make_to_repository('to_repo')
         # We build a broken revision so that we can test the fetch code dies
         # properly. So copy the inventory and revision, but not the text.
-        to_repo.lock_write()
-        try:
+        with to_repo.lock_write():
             to_repo.start_write_group()
             try:
-                inv = tree.branch.repository.get_inventory('rev-one')
-                to_repo.add_inventory('rev-one', inv, [])
-                rev = tree.branch.repository.get_revision('rev-one')
-                to_repo.add_revision('rev-one', rev, inv=inv)
+                inv = tree.branch.repository.get_inventory(b'rev-one')
+                to_repo.add_inventory(b'rev-one', inv, [])
+                rev = tree.branch.repository.get_revision(b'rev-one')
+                to_repo.add_revision(b'rev-one', rev, inv=inv)
                 self.disable_commit_write_group_paranoia(to_repo)
                 to_repo.commit_write_group()
             except:
                 to_repo.abort_write_group(suppress_errors=True)
                 raise
-        finally:
-            to_repo.unlock()
 
         # Implementations can either ensure that the target of the delta is
         # reconstructable, or raise an exception (which stream based copies
         # generally do).
         try:
-            to_repo.fetch(tree.branch.repository, 'rev-two')
+            to_repo.fetch(tree.branch.repository, b'rev-two')
         except (errors.BzrCheckError, errors.RevisionNotPresent) as e:
             # If an exception is raised, the revision should not be in the
             # target.
@@ -457,14 +454,14 @@
             # Can also just raise a generic check errors; stream insertion
             # does this to include all the missing data
             self.assertRaises((errors.NoSuchRevision, errors.RevisionNotPresent),
-                              to_repo.revision_tree, 'rev-two')
+                              to_repo.revision_tree, b'rev-two')
         else:
             # If not exception is raised, then the text should be
             # available.
             to_repo.lock_read()
             try:
-                rt = to_repo.revision_tree('rev-two')
-                self.assertEqual('new contents\n',
+                rt = to_repo.revision_tree(b'rev-two')
+                self.assertEqual(b'new contents\n',
                                  rt.get_file_text('a'))
             finally:
                 to_repo.unlock()
@@ -488,31 +485,31 @@
         # start by adding a file so the data knit for the file exists in
         # repositories that have specific files for each fileid.
         self.build_tree(['source/id'])
-        source_tree.add(['id'], ['id'])
+        source_tree.add(['id'], [b'id'])
         source_tree.commit('a', rev_id=b'a')
         # now we manually insert a revision with an inventory referencing
         # file 'id' at revision 'b', but we do not insert revision b.
         # this should ensure that the new versions of files are being checked
         # for during pull operations
-        inv = source.get_inventory('a')
+        inv = source.get_inventory(b'a')
         source.lock_write()
         self.addCleanup(source.unlock)
         source.start_write_group()
-        inv.get_entry('id').revision = 'b'
-        inv.revision_id = 'b'
-        sha1 = source.add_inventory('b', inv, ['a'])
+        inv.get_entry(b'id').revision = b'b'
+        inv.revision_id = b'b'
+        sha1 = source.add_inventory(b'b', inv, [b'a'])
         rev = Revision(timestamp=0,
                        timezone=None,
                        committer="Foo Bar <[e-mail]>",
                        message="Message",
                        inventory_sha1=sha1,
                        revision_id=b'b')
-        rev.parent_ids = ['a']
-        source.add_revision('b', rev)
+        rev.parent_ids = [b'a']
+        source.add_revision(b'b', rev)
         self.disable_commit_write_group_paranoia(source)
         source.commit_write_group()
         self.assertRaises(errors.RevisionNotPresent, target.fetch, source)
-        self.assertFalse(target.has_revision('b'))
+        self.assertFalse(target.has_revision(b'b'))
 
     def test_fetch_funky_file_id(self):
         from_tree = self.make_branch_and_tree('tree')
@@ -531,10 +528,10 @@
         from_tree.commit('foo', rev_id=b'foo-id')
         to_repo = self.make_to_repository('to')
         to_repo.fetch(from_tree.branch.repository)
-        recorded_inv_sha1 = to_repo.get_revision('foo-id').inventory_sha1
+        recorded_inv_sha1 = to_repo.get_revision(b'foo-id').inventory_sha1
         to_repo.lock_read()
         self.addCleanup(to_repo.unlock)
-        stream = to_repo.inventories.get_record_stream([('foo-id',)],
+        stream = to_repo.inventories.get_record_stream([(b'foo-id',)],
                                                        'unordered', True)
         bytes = stream.next().get_bytes_as('fulltext')
         computed_inv_sha1 = osutils.sha_string(bytes)

=== modified file 'breezy/tests/per_interrepository/test_interrepository.py'
--- breezy/tests/per_interrepository/test_interrepository.py	2018-02-18 15:21:06 +0000
+++ breezy/tests/per_interrepository/test_interrepository.py	2018-06-21 08:27:55 +0000
@@ -89,12 +89,12 @@
         # make a repository to compare against that claims to have rev1
         repo_b = self.make_to_repository('rev1_only')
         repo_a = self.controldir.open_repository()
-        repo_b.fetch(repo_a, 'rev1')
+        repo_b.fetch(repo_a, b'rev1')
         # check the test will be valid
-        self.assertFalse(repo_b.has_revision('rev2'))
+        self.assertFalse(repo_b.has_revision(b'rev2'))
         result = repo_b.search_missing_revision_ids(repo_a)
-        self.assertEqual({'rev2'}, result.get_keys())
-        self.assertEqual(('search', {'rev2'}, {'rev1'}, 1),
+        self.assertEqual({b'rev2'}, result.get_keys())
+        self.assertEqual(('search', {b'rev2'}, {b'rev1'}, 1),
             result.get_recipe())
 
     def test_absent_requested_raises(self):
@@ -103,14 +103,14 @@
         repo_b = self.make_to_repository('target')
         repo_a = self.controldir.open_repository()
         # No pizza revisions anywhere
-        self.assertFalse(repo_a.has_revision('pizza'))
-        self.assertFalse(repo_b.has_revision('pizza'))
+        self.assertFalse(repo_a.has_revision(b'pizza'))
+        self.assertFalse(repo_b.has_revision(b'pizza'))
         # Asking specifically for an absent revision errors.
         self.assertRaises(errors.NoSuchRevision,
-            repo_b.search_missing_revision_ids, repo_a, revision_ids=['pizza'],
+            repo_b.search_missing_revision_ids, repo_a, revision_ids=[b'pizza'],
             find_ghosts=True)
         self.assertRaises(errors.NoSuchRevision,
-            repo_b.search_missing_revision_ids, repo_a, revision_ids=['pizza'],
+            repo_b.search_missing_revision_ids, repo_a, revision_ids=[b'pizza'],
             find_ghosts=False)
 
     def test_search_missing_rev_limited(self):
@@ -131,9 +131,9 @@
         repo_b = self.make_to_repository('rev1_only')
         repo_a = self.controldir.open_repository()
         # check the test will be valid
-        self.assertFalse(repo_b.has_revision('rev2'))
+        self.assertFalse(repo_b.has_revision(b'rev2'))
         result = repo_b.search_missing_revision_ids(repo_a, limit=1)
-        self.assertEqual(('search', {'rev1'}, {'null:'}, 1),
+        self.assertEqual(('search', {b'rev1'}, {b'null:'}, 1),
             result.get_recipe())
 
     def test_fetch_fetches_signatures_too(self):
@@ -184,16 +184,16 @@
             repo.add_revision(revision_id, rev)
             repo.commit_write_group()
             repo.unlock()
-        add_commit(has_ghost, 'ghost', [])
-        add_commit(has_ghost, 'references', ['ghost'])
-        add_commit(missing_ghost, 'references', ['ghost'])
-        add_commit(has_ghost, 'tip', ['references'])
-        missing_ghost.fetch(has_ghost, 'tip', find_ghosts=True)
+        add_commit(has_ghost, b'ghost', [])
+        add_commit(has_ghost, b'references', [b'ghost'])
+        add_commit(missing_ghost, b'references', [b'ghost'])
+        add_commit(has_ghost, b'tip', [b'references'])
+        missing_ghost.fetch(has_ghost, b'tip', find_ghosts=True)
         # missing ghost now has tip and ghost.
-        rev = missing_ghost.get_revision('tip')
-        inv = missing_ghost.get_inventory('tip')
-        rev = missing_ghost.get_revision('ghost')
-        inv = missing_ghost.get_inventory('ghost')
+        rev = missing_ghost.get_revision(b'tip')
+        inv = missing_ghost.get_inventory(b'tip')
+        rev = missing_ghost.get_revision(b'ghost')
+        inv = missing_ghost.get_inventory(b'ghost')
         # rev must not be corrupt now
-        self.assertThat(['ghost', 'references', 'tip'],
-            MatchesAncestry(missing_ghost, 'tip'))
+        self.assertThat([b'ghost', b'references', b'tip'],
+            MatchesAncestry(missing_ghost, b'tip'))

=== modified file 'breezy/tests/per_pack_repository.py'
--- breezy/tests/per_pack_repository.py	2018-03-26 00:54:10 +0000
+++ breezy/tests/per_pack_repository.py	2018-06-21 08:27:55 +0000
@@ -318,10 +318,10 @@
         builder = self.make_branch_builder('source', format=format)
         builder.start_series()
         builder.build_snapshot(None, [
-            ('add', ('', 'root-id', 'directory', None))],
+            ('add', ('', b'root-id', 'directory', None))],
             revision_id=b'A-id')
         builder.build_snapshot(None, [
-            ('add', ('file', 'file-id', 'file', 'B content\n'))],
+            ('add', ('file', b'file-id', 'file', b'B content\n'))],
             revision_id=b'B-id')
         builder.build_snapshot(None, [
             ('modify', ('file', b'C content\n'))],
@@ -334,17 +334,17 @@
         repo.lock_write()
         self.addCleanup(repo.unlock)
         repo.fetch(b.repository, revision_id=b'B-id')
-        inv = next(b.repository.iter_inventories(['C-id']))
+        inv = next(b.repository.iter_inventories([b'C-id']))
         repo.start_write_group()
-        repo.add_inventory('C-id', inv, ['B-id'])
+        repo.add_inventory(b'C-id', inv, [b'B-id'])
         repo.commit_write_group()
-        self.assertEqual([('A-id',), ('B-id',), ('C-id',)],
+        self.assertEqual([(b'A-id',), (b'B-id',), (b'C-id',)],
                          sorted(repo.inventories.keys()))
         repo.pack()
-        self.assertEqual([('A-id',), ('B-id',), ('C-id',)],
+        self.assertEqual([(b'A-id',), (b'B-id',), (b'C-id',)],
                          sorted(repo.inventories.keys()))
         # Content should be preserved as well
-        self.assertEqual(inv, next(repo.iter_inventories(['C-id'])))
+        self.assertEqual(inv, next(repo.iter_inventories([b'C-id'])))
 
     def test_pack_layout(self):
         # Test that the ordering of revisions in pack repositories is
@@ -657,18 +657,18 @@
             repo.add_revision(revision_id, rev)
             repo.commit_write_group()
             repo.unlock()
-        add_commit(has_ghost, 'ghost', [])
-        add_commit(has_ghost, 'references', ['ghost'])
-        add_commit(missing_ghost, 'references', ['ghost'])
-        add_commit(has_ghost, 'tip', ['references'])
-        missing_ghost.fetch(has_ghost, 'tip')
+        add_commit(has_ghost, b'ghost', [])
+        add_commit(has_ghost, b'references', [b'ghost'])
+        add_commit(missing_ghost, b'references', [b'ghost'])
+        add_commit(has_ghost, b'tip', [b'references'])
+        missing_ghost.fetch(has_ghost, b'tip')
         # missing ghost now has tip and not ghost.
-        rev = missing_ghost.get_revision('tip')
-        inv = missing_ghost.get_inventory('tip')
-        self.assertRaises(errors.NoSuchRevision,
-            missing_ghost.get_revision, 'ghost')
-        self.assertRaises(errors.NoSuchRevision,
-            missing_ghost.get_inventory, 'ghost')
+        rev = missing_ghost.get_revision(b'tip')
+        inv = missing_ghost.get_inventory(b'tip')
+        self.assertRaises(errors.NoSuchRevision,
+            missing_ghost.get_revision, b'ghost')
+        self.assertRaises(errors.NoSuchRevision,
+            missing_ghost.get_inventory, b'ghost')
 
     def make_write_ready_repo(self):
         format = self.get_format()
@@ -1012,10 +1012,10 @@
         builder = self.make_branch_builder('source', format=self.get_format())
         builder.start_series()
         builder.build_snapshot(None, [
-            ('add', ('', 'root-id', 'directory', None))],
+            ('add', ('', b'root-id', 'directory', None))],
             revision_id=b'A-id')
         builder.build_snapshot(
-                ['A-id', 'ghost-id'], [],
+                [b'A-id', b'ghost-id'], [],
                 revision_id=b'B-id', )
         builder.finish_series()
         repo = self.make_repository('target', format=self.get_format())

=== modified file 'breezy/tests/per_repository/test_repository.py'
--- breezy/tests/per_repository/test_repository.py	2018-06-14 10:06:05 +0000
+++ breezy/tests/per_repository/test_repository.py	2018-06-21 08:27:55 +0000
@@ -277,7 +277,7 @@
             # may only be shared in some circumstances.
             return
         # Check that we have a repository object.
-        made_repo.has_revision('foo')
+        made_repo.has_revision(b'foo')
         self.assertEqual(made_control, made_repo.controldir)
         self.assertTrue(made_repo.is_shared())
 
@@ -350,7 +350,7 @@
             return
         result = made_control.clone(self.get_url('target'))
         # Check that we have a repository object.
-        made_repo.has_revision('foo')
+        made_repo.has_revision(b'foo')
 
         self.assertEqual(made_control, made_repo.controldir)
         self.assertTrue(result.open_repository().is_shared())

=== modified file 'breezy/tests/per_repository_chk/test_supported.py'
--- breezy/tests/per_repository_chk/test_supported.py	2018-03-07 20:29:23 +0000
+++ breezy/tests/per_repository_chk/test_supported.py	2018-06-21 08:27:55 +0000
@@ -171,7 +171,7 @@
         builder.build_snapshot(None, [
             ('add', ('', 'root-id', 'directory', None)),
             ('add', ('file', 'file-id', 'file', 'content\n'))],
-            revision_id='A-id')
+            revision_id=b'A-id')
         b = builder.get_branch()
         b.lock_read()
         self.addCleanup(b.unlock)
@@ -216,17 +216,17 @@
         # inventories.
         builder = self.make_branch_builder('simple-branch')
         builder.build_snapshot(None, [
-            ('add', ('', 'root-id', 'directory', None)),
-            ('add', ('file', 'file-id', 'file', 'content\n'))],
-            revision_id='A-id')
-        builder.build_snapshot(None, [], revision_id='B-id')
-        builder.build_snapshot(None, [], revision_id='C-id')
+            ('add', ('', b'root-id', 'directory', None)),
+            ('add', ('file', b'file-id', 'file', b'content\n'))],
+            revision_id=b'A-id')
+        builder.build_snapshot(None, [], revision_id=b'B-id')
+        builder.build_snapshot(None, [], revision_id=b'C-id')
         b = builder.get_branch()
         b.lock_read()
         self.addCleanup(b.unlock)
         # check our setup: B-id and C-id should have identical chk root keys.
-        inv_b = b.repository.get_inventory('B-id')
-        inv_c = b.repository.get_inventory('C-id')
+        inv_b = b.repository.get_inventory(b'B-id')
+        inv_c = b.repository.get_inventory(b'C-id')
         if not isinstance(repo, RemoteRepository):
             # Remote repositories always return plain inventories
             self.assertEqual(inv_b.id_to_entry.key(), inv_c.id_to_entry.key())
@@ -240,10 +240,10 @@
         src_repo = b.repository
         repo.inventories.insert_record_stream(
             src_repo.inventories.get_record_stream(
-                [('B-id',), ('C-id',)], 'unordered', True))
+                [(b'B-id',), (b'C-id',)], 'unordered', True))
         repo.revisions.insert_record_stream(
             src_repo.revisions.get_record_stream(
-                [('C-id',)], 'unordered', True))
+                [(b'C-id',)], 'unordered', True))
         # Make sure the presence of the missing data in a fallback does not
         # avoid the error.
         repo.add_fallback_repository(b.repository)
@@ -267,8 +267,8 @@
         self.addCleanup(src_repo.unlock)
         # Now, manually insert objects for a stacked repo with only revision
         # C-id, *except* drop the non-root chk records.
-        inv_b = src_repo.get_inventory('B-id')
-        inv_c = src_repo.get_inventory('C-id')
+        inv_b = src_repo.get_inventory(b'B-id')
+        inv_c = src_repo.get_inventory(b'C-id')
         chk_root_keys_only = [
             inv_b.id_to_entry.key(), inv_b.parent_id_basename_to_file_id.key(),
             inv_c.id_to_entry.key(), inv_c.parent_id_basename_to_file_id.key()]
@@ -286,10 +286,10 @@
                 src_repo.texts.keys(), 'unordered', True))
         repo.inventories.insert_record_stream(
             src_repo.inventories.get_record_stream(
-                [('B-id',), ('C-id',)], 'unordered', True))
+                [(b'B-id',), (b'C-id',)], 'unordered', True))
         repo.revisions.insert_record_stream(
             src_repo.revisions.get_record_stream(
-                [('C-id',)], 'unordered', True))
+                [(b'C-id',)], 'unordered', True))
         # Make sure the presence of the missing data in a fallback does not
         # avoid the error.
         repo.add_fallback_repository(b.repository)
@@ -315,7 +315,7 @@
         # We need ('revisions', 'C-id'), ('inventories', 'C-id'),
         # ('inventories', 'B-id'), and the corresponding chk roots for those
         # inventories.
-        inv_c = b.repository.get_inventory('C-id')
+        inv_c = b.repository.get_inventory(b'C-id')
         chk_keys_for_c_only = [
             inv_c.id_to_entry.key(), inv_c.parent_id_basename_to_file_id.key()]
         repo.lock_write()
@@ -326,10 +326,10 @@
                 chk_keys_for_c_only, 'unordered', True))
         repo.inventories.insert_record_stream(
             src_repo.inventories.get_record_stream(
-                [('B-id',), ('C-id',)], 'unordered', True))
+                [(b'B-id',), (b'C-id',)], 'unordered', True))
         repo.revisions.insert_record_stream(
             src_repo.revisions.get_record_stream(
-                [('C-id',)], 'unordered', True))
+                [(b'C-id',)], 'unordered', True))
         # Make sure the presence of the missing data in a fallback does not
         # avoid the error.
         repo.add_fallback_repository(b.repository)
@@ -348,16 +348,17 @@
         for char in 'abc':
             name = char * 10000
             file_adds.append(
-                ('add', ('file-' + name, 'file-%s-id' % name, 'file',
-                         'content %s\n' % name)))
+                ('add', ('file-' + name, ('file-%s-id' % name).encode(), 'file',
+                         ('content %s\n' % name).encode())))
             file_modifies.append(
-                ('modify', ('file-' + name, 'new content %s\n' % name)))
+                ('modify', (('file-' + name).encode(),
+                    ('new content %s\n' % name).encode())))
         builder.build_snapshot(None, [
-            ('add', ('', 'root-id', 'directory', None))] +
+            ('add', ('', b'root-id', 'directory', None))] +
             file_adds,
-            revision_id='A-id')
-        builder.build_snapshot(None, [], revision_id='B-id')
-        builder.build_snapshot(None, file_modifies, revision_id='C-id')
+            revision_id=b'A-id')
+        builder.build_snapshot(None, [], revision_id=b'B-id')
+        builder.build_snapshot(None, file_modifies, revision_id=b'C-id')
         return builder.get_branch()
 
     def test_missing_text_record(self):

=== modified file 'breezy/tests/per_repository_reference/test_commit_with_stacking.py'
--- breezy/tests/per_repository_reference/test_commit_with_stacking.py	2018-02-18 15:21:06 +0000
+++ breezy/tests/per_repository_reference/test_commit_with_stacking.py	2018-06-21 08:27:55 +0000
@@ -95,7 +95,7 @@
         stacked2_branch = base_tree.controldir.sprout('stacked2',
                                                   stacked=True).open_branch()
         stacked2_branch.repository.fetch(stacked_only_repo,
-                                         revision_id='new-rev-id')
+                                         revision_id=b'new-rev-id')
 
     def test_merge_commit(self):
         base_tree, stacked_tree = self.make_stacked_target()

=== modified file 'breezy/tests/per_repository_reference/test_fetch.py'
--- breezy/tests/per_repository_reference/test_fetch.py	2018-03-26 00:54:10 +0000
+++ breezy/tests/per_repository_reference/test_fetch.py	2018-06-21 08:27:55 +0000
@@ -87,7 +87,7 @@
         transport = self.make_smart_server('server')
         transport.ensure_base()
         url = transport.abspath('')
-        stack_b = source_b.controldir.sprout(url + '/stack-on', revision_id='B-id')
+        stack_b = source_b.controldir.sprout(url + '/stack-on', revision_id=b'B-id')
         # self.make_branch only takes relative paths, so we do it the 'hard'
         # way
         target_transport = transport.clone('target')
@@ -107,7 +107,7 @@
         # revision_id versus not. If you supply revision_id, then you get a
         # PendingAncestryResult for the search, versus a SearchResult...
         final2_b = target_b.controldir.sprout('final2',
-                                          revision_id='C-id').open_branch()
+                                          revision_id=b'C-id').open_branch()
         self.assertEqual('C-id', final_b.last_revision())
 
     def make_source_with_ghost_and_stacked_target(self):
@@ -116,8 +116,8 @@
         builder.build_snapshot(None, [
             ('add', ('', 'root-id', 'directory', None)),
             ('add', ('file', 'file-id', 'file', 'content\n'))],
-            revision_id='A-id')
-        builder.build_snapshot(['A-id', 'ghost-id'], [], revision_id='B-id')
+            revision_id=b'A-id')
+        builder.build_snapshot(['A-id', 'ghost-id'], [], revision_id=b'B-id')
         builder.finish_series()
         source_b = builder.get_branch()
         source_b.lock_read()

=== modified file 'breezy/tests/per_repository_reference/test_get_record_stream.py'
--- breezy/tests/per_repository_reference/test_get_record_stream.py	2018-03-07 20:29:23 +0000
+++ breezy/tests/per_repository_reference/test_get_record_stream.py	2018-06-21 08:27:55 +0000
@@ -46,39 +46,39 @@
         #
 
         builder.build_snapshot(None, [
-            ('add', ('', 'root-id', 'directory', None)),
-            ('add', ('file', 'f-id', 'file', 'initial content\n')),
-            ], revision_id='A')
-        builder.build_snapshot(['A'], [
-            ('modify', ('file', 'initial content\n'
-                                'and B content\n')),
-            ], revision_id='B')
-        builder.build_snapshot(['A'], [
-            ('modify', ('file', 'initial content\n'
-                                'and C content\n')),
-            ], revision_id='C')
+            ('add', ('', b'root-id', 'directory', None)),
+            ('add', ('file', b'f-id', 'file', b'initial content\n')),
+            ], revision_id=b'A')
+        builder.build_snapshot([b'A'], [
+            ('modify', ('file', b'initial content\n'
+                                b'and B content\n')),
+            ], revision_id=b'B')
+        builder.build_snapshot([b'A'], [
+            ('modify', ('file', b'initial content\n'
+                                b'and C content\n')),
+            ], revision_id=b'C')
         builder.build_snapshot(['B', 'C'], [
-            ('modify', ('file', 'initial content\n'
-                                'and B content\n'
-                                'and C content\n')),
-            ], revision_id='D')
-        builder.build_snapshot(['C'], [
-            ('modify', ('file', 'initial content\n'
-                                'and C content\n'
-                                'and E content\n')),
-            ], revision_id='E')
-        builder.build_snapshot(['D'], [
-            ('modify', ('file', 'initial content\n'
-                                'and B content\n'
-                                'and C content\n'
-                                'and F content\n')),
-            ], revision_id='F')
-        builder.build_snapshot(['E', 'D'], [
-            ('modify', ('file', 'initial content\n'
-                                'and B content\n'
-                                'and C content\n'
-                                'and E content\n')),
-            ], revision_id='G')
+            ('modify', ('file', b'initial content\n'
+                                b'and B content\n'
+                                b'and C content\n')),
+            ], revision_id=b'D')
+        builder.build_snapshot([b'C'], [
+            ('modify', ('file', b'initial content\n'
+                                b'and C content\n'
+                                b'and E content\n')),
+            ], revision_id=b'E')
+        builder.build_snapshot([b'D'], [
+            ('modify', ('file', b'initial content\n'
+                                b'and B content\n'
+                                b'and C content\n'
+                                b'and F content\n')),
+            ], revision_id=b'F')
+        builder.build_snapshot([b'E', b'D'], [
+            ('modify', ('file', b'initial content\n'
+                                b'and B content\n'
+                                b'and C content\n'
+                                b'and E content\n')),
+            ], revision_id=b'G')
         builder.finish_series()
         self.all_repo = builder.get_branch().repository
         self.all_repo.lock_read()
@@ -88,8 +88,8 @@
 
     def make_simple_split(self):
         """Set up the repositories so that everything is in base except F"""
-        self.base_repo.fetch(self.all_repo, revision_id='G')
-        self.stacked_repo.fetch(self.all_repo, revision_id='F')
+        self.base_repo.fetch(self.all_repo, revision_id=b'G')
+        self.stacked_repo.fetch(self.all_repo, revision_id=b'F')
 
     def make_complex_split(self):
         """intermix the revisions so that base holds left stacked holds right.
@@ -99,14 +99,14 @@
         referring will hold
             C E G (only)
         """
-        self.base_repo.fetch(self.all_repo, revision_id='B')
-        self.stacked_repo.fetch(self.all_repo, revision_id='C')
-        self.base_repo.fetch(self.all_repo, revision_id='F')
-        self.stacked_repo.fetch(self.all_repo, revision_id='G')
+        self.base_repo.fetch(self.all_repo, revision_id=b'B')
+        self.stacked_repo.fetch(self.all_repo, revision_id=b'C')
+        self.base_repo.fetch(self.all_repo, revision_id=b'F')
+        self.stacked_repo.fetch(self.all_repo, revision_id=b'G')
 
     def test_unordered_fetch_simple_split(self):
         self.make_simple_split()
-        keys = [('f-id', r) for r in 'ABCDF']
+        keys = [(b'f-id', r) for r in 'ABCDF']
         self.stacked_repo.lock_read()
         self.addCleanup(self.stacked_repo.unlock)
         stream = self.stacked_repo.texts.get_record_stream(
@@ -121,7 +121,7 @@
 
     def test_unordered_fetch_complex_split(self):
         self.make_complex_split()
-        keys = [('f-id', r) for r in 'ABCDEG']
+        keys = [(b'f-id', r) for r in 'ABCDEG']
         self.stacked_repo.lock_read()
         self.addCleanup(self.stacked_repo.unlock)
         stream = self.stacked_repo.texts.get_record_stream(
@@ -139,10 +139,10 @@
         # Topological ordering allows B & C and D & E to be returned with
         # either one first, so the required ordering is:
         # [A (B C) (D E) G]
-        keys = [('f-id', r) for r in 'ABCDEG']
-        alt_1 = [('f-id', r) for r in 'ACBDEG']
-        alt_2 = [('f-id', r) for r in 'ABCEDG']
-        alt_3 = [('f-id', r) for r in 'ACBEDG']
+        keys = [(b'f-id', r) for r in 'ABCDEG']
+        alt_1 = [(b'f-id', r) for r in 'ACBDEG']
+        alt_2 = [(b'f-id', r) for r in 'ABCEDG']
+        alt_3 = [(b'f-id', r) for r in 'ACBEDG']
         self.stacked_repo.lock_read()
         self.addCleanup(self.stacked_repo.unlock)
         stream = self.stacked_repo.texts.get_record_stream(
@@ -162,8 +162,8 @@
         # Topological ordering allows B & C and D & E to be returned with
         # either one first, so the required ordering is:
         # [A (B C) D F]
-        keys = [('f-id', r) for r in 'ABCDF']
-        alt_1 = [('f-id', r) for r in 'ACBDF']
+        keys = [(b'f-id', r) for r in 'ABCDF']
+        alt_1 = [(b'f-id', r) for r in 'ACBDF']
         self.stacked_repo.lock_read()
         self.addCleanup(self.stacked_repo.unlock)
         stream = self.stacked_repo.texts.get_record_stream(
@@ -180,10 +180,10 @@
         # Topological ordering allows B & C and D & E to be returned with
         # either one first, so the required ordering is:
         # [A (B C) (D E) G]
-        keys = [('f-id', r) for r in 'ABCDEG']
-        alt_1 = [('f-id', r) for r in 'ACBDEG']
-        alt_2 = [('f-id', r) for r in 'ABCEDG']
-        alt_3 = [('f-id', r) for r in 'ACBEDG']
+        keys = [(b'f-id', r) for r in 'ABCDEG']
+        alt_1 = [(b'f-id', r) for r in 'ACBDEG']
+        alt_2 = [(b'f-id', r) for r in 'ABCEDG']
+        alt_3 = [(b'f-id', r) for r in 'ACBEDG']
         self.stacked_repo.lock_read()
         self.addCleanup(self.stacked_repo.unlock)
         stream = self.stacked_repo.texts.get_record_stream(

=== modified file 'breezy/tests/per_repository_reference/test_graph.py'
--- breezy/tests/per_repository_reference/test_graph.py	2017-11-16 00:39:04 +0000
+++ breezy/tests/per_repository_reference/test_graph.py	2018-06-21 08:27:55 +0000
@@ -58,12 +58,12 @@
         builder.start_series()
         builder.build_snapshot(None, [
             ('add', ('', 'directory', 'root-id', None))],
-            revision_id='A')
-        builder.build_snapshot(['A'], [], revision_id='B')
-        builder.build_snapshot(['B'], [], revision_id='C')
-        builder.build_snapshot(['C'], [], revision_id='D')
-        builder.build_snapshot(['D'], [], revision_id='E')
-        builder.build_snapshot(['E'], [], revision_id='F')
+            revision_id=b'A')
+        builder.build_snapshot(['A'], [], revision_id=b'B')
+        builder.build_snapshot(['B'], [], revision_id=b'C')
+        builder.build_snapshot(['C'], [], revision_id=b'D')
+        builder.build_snapshot(['D'], [], revision_id=b'E')
+        builder.build_snapshot(['E'], [], revision_id=b'F')
         source_b = builder.get_branch()
         master_b = self.make_branch('master')
         master_b.pull(source_b, stop_revision='E')

=== modified file 'breezy/tests/per_repository_reference/test_unlock.py'
--- breezy/tests/per_repository_reference/test_unlock.py	2018-03-07 20:29:23 +0000
+++ breezy/tests/per_repository_reference/test_unlock.py	2018-06-21 08:27:55 +0000
@@ -37,13 +37,13 @@
         builder.build_snapshot(None, [
             ('add', ('', 'root-id', 'directory', None)),
             ('add', ('file', 'file-id', 'file', 'contents\n'))],
-            revision_id='A-id')
+            revision_id=b'A-id')
         builder.build_snapshot(['A-id'], [
             ('modify', ('file', 'new-content\n'))],
-            revision_id='B-id')
+            revision_id=b'B-id')
         builder.build_snapshot(['B-id'], [
             ('modify', ('file', 'yet more content\n'))],
-            revision_id='C-id')
+            revision_id=b'C-id')
         builder.finish_series()
         source_b = builder.get_branch()
         source_b.lock_read()

=== modified file 'breezy/tests/per_repository_vf/helpers.py'
--- breezy/tests/per_repository_vf/helpers.py	2017-06-10 02:09:46 +0000
+++ breezy/tests/per_repository_vf/helpers.py	2018-06-21 08:27:55 +0000
@@ -53,7 +53,7 @@
         repo.lock_write()
         repo.start_write_group()
         try:
-            inv = inventory.Inventory(revision_id='revision-id')
+            inv = inventory.Inventory(revision_id=b'revision-id')
             inv.root.revision = 'revision-id'
             inv_sha1 = repo.add_inventory('revision-id', inv, [])
             if repo.supports_rich_root():

=== modified file 'breezy/tests/per_repository_vf/test_fetch.py'
--- breezy/tests/per_repository_vf/test_fetch.py	2017-11-16 00:39:04 +0000
+++ breezy/tests/per_repository_vf/test_fetch.py	2018-06-21 08:27:55 +0000
@@ -42,7 +42,7 @@
         builder.start_series()
         builder.build_snapshot(['ghost'],
             [('add', ('', 'ROOT_ID', 'directory', ''))],
-            allow_leftmost_as_ghost=True, revision_id='tip')
+            allow_leftmost_as_ghost=True, revision_id=b'tip')
         builder.finish_series()
         b = builder.get_branch()
         b.lock_read()

=== modified file 'breezy/tests/per_repository_vf/test_fileid_involved.py'
--- breezy/tests/per_repository_vf/test_fileid_involved.py	2018-05-13 02:18:13 +0000
+++ breezy/tests/per_repository_vf/test_fileid_involved.py	2018-06-21 08:27:55 +0000
@@ -46,9 +46,9 @@
         builder.build_snapshot(None, [
             ('add', ('', 'root-id', 'directory', None)),
             ('add', ('a', 'a-file-id', 'file', 'some content\n'))],
-            revision_id='A-id')
+            revision_id=b'A-id')
         b = builder.get_branch()
-        old_rt = b.repository.revision_tree('A-id')
+        old_rt = b.repository.revision_tree(b'A-id')
         new_inv = inventory.mutable_inventory_from_tree(old_rt)
         new_inv.revision_id = 'B-id'
         new_inv.get_entry('a-file-id').revision = 'ghost-id'
@@ -98,13 +98,13 @@
         builder.build_snapshot(None, [
             ('add', ('', 'root-id', 'directory', None)),
             ('add', ('file', 'file-id', 'file', 'contents\n'))],
-            revision_id='A-id')
+            revision_id=b'A-id')
         builder.build_snapshot(['A-id'], [
             ('modify', ('file', 'new-content\n'))],
-            revision_id='B-id')
+            revision_id=b'B-id')
         builder.build_snapshot(['B-id'], [
             ('modify', ('file', 'yet more content\n'))],
-            revision_id='C-id')
+            revision_id=b'C-id')
         builder.finish_series()
         source_b = builder.get_branch()
         source_b.lock_read()

=== modified file 'breezy/tests/per_repository_vf/test_merge_directive.py'
--- breezy/tests/per_repository_vf/test_merge_directive.py	2018-05-13 02:18:13 +0000
+++ breezy/tests/per_repository_vf/test_merge_directive.py	2018-06-21 08:27:55 +0000
@@ -75,7 +75,7 @@
                                                 target_branch.base)
         chk_map.clear_cache()
         directive.install_revisions(target_branch.repository)
-        rt = target_branch.repository.revision_tree('B')
+        rt = target_branch.repository.revision_tree(b'B')
         rt.lock_read()
         self.assertEqualDiff(b'new content\n', rt.get_file_text('f', b'f-id'))
         rt.unlock()

=== modified file 'breezy/tests/per_repository_vf/test_reconcile.py'
--- breezy/tests/per_repository_vf/test_reconcile.py	2018-02-18 15:21:06 +0000
+++ breezy/tests/per_repository_vf/test_reconcile.py	2018-06-21 08:27:55 +0000
@@ -94,7 +94,7 @@
         repo = self.make_repository('inventory_without_revision')
         repo.lock_write()
         repo.start_write_group()
-        inv = Inventory(revision_id='missing')
+        inv = Inventory(revision_id=b'missing')
         inv.root.revision = 'missing'
         repo.add_inventory('missing', inv, [])
         repo.commit_write_group()
@@ -198,7 +198,7 @@
             **kwargs):
         # actual low level test.
         repo = aBzrDir.open_repository()
-        if not repo.has_revision('missing'):
+        if not repo.has_revision(b'missing'):
             # the repo handles ghosts without corruption, so reconcile has
             # nothing to do here. Specifically, this test has the inventory
             # 'missing' present and the revision 'missing' missing, so clearly
@@ -218,7 +218,7 @@
         self.check_missing_was_removed(repo)
         # and the parent list for 'references_missing' should have that
         # revision a ghost now.
-        self.assertFalse(repo.has_revision('missing'))
+        self.assertFalse(repo.has_revision(b'missing'))
 
     def check_missing_was_removed(self, repo):
         if repo._reconcile_backsup_inventory:
@@ -266,18 +266,18 @@
         self.assertEqual(0, reconciler.garbage_inventories)
         # now the current inventory should still have 'ghost'
         repo = d.open_repository()
-        repo.get_inventory('ghost')
-        self.assertThat(['ghost', 'the_ghost'], MatchesAncestry(repo, 'ghost'))
+        repo.get_inventory(b'ghost')
+        self.assertThat([b'ghost', b'the_ghost'], MatchesAncestry(repo, b'ghost'))
 
     def test_reweave_inventory_fixes_ancestryfor_a_present_ghost(self):
         d = BzrDir.open(self.get_url('inventory_ghost_present'))
         repo = d.open_repository()
-        m = MatchesAncestry(repo, 'ghost')
-        if m.match(['the_ghost', 'ghost']) is None:
+        m = MatchesAncestry(repo, b'ghost')
+        if m.match([b'the_ghost', b'ghost']) is None:
             # the repo handles ghosts without corruption, so reconcile has
             # nothing to do
             return
-        self.assertThat(['ghost'], m)
+        self.assertThat([b'ghost'], m)
         reconciler = repo.reconcile()
         # this is a data corrupting error, so a normal reconcile should fix it.
         # one inconsistent parents should have been found : the
@@ -287,35 +287,35 @@
         self.assertEqual(0, reconciler.garbage_inventories)
         # now the current inventory should still have 'ghost'
         repo = d.open_repository()
-        repo.get_inventory('ghost')
-        repo.get_inventory('the_ghost')
-        self.assertThat(['the_ghost', 'ghost'],
-            MatchesAncestry(repo, 'ghost'))
-        self.assertThat(['the_ghost'],
-            MatchesAncestry(repo, 'the_ghost'))
+        repo.get_inventory(b'ghost')
+        repo.get_inventory(b'the_ghost')
+        self.assertThat([b'the_ghost', b'ghost'],
+            MatchesAncestry(repo, b'ghost'))
+        self.assertThat([b'the_ghost'],
+            MatchesAncestry(repo, b'the_ghost'))
 
     def test_text_from_ghost_revision(self):
         repo = self.make_repository('text-from-ghost')
-        inv = Inventory(revision_id='final-revid')
-        inv.root.revision = 'root-revid'
-        ie = inv.add_path('bla', 'file', 'myfileid')
-        ie.revision = 'ghostrevid'
+        inv = Inventory(revision_id=b'final-revid')
+        inv.root.revision = b'root-revid'
+        ie = inv.add_path('bla', 'file', b'myfileid')
+        ie.revision = b'ghostrevid'
         ie.text_size = 42
-        ie.text_sha1 = "bee68c8acd989f5f1765b4660695275948bf5c00"
+        ie.text_sha1 = b"bee68c8acd989f5f1765b4660695275948bf5c00"
         rev = breezy.revision.Revision(timestamp=0,
                                        timezone=None,
                                        committer="Foo Bar <[e-mail]>",
                                        message="Message",
-                                       revision_id='final-revid')
+                                       revision_id=b'final-revid')
         repo.lock_write()
         try:
             repo.start_write_group()
             try:
-                repo.add_revision('final-revid', rev, inv)
+                repo.add_revision(b'final-revid', rev, inv)
                 try:
-                    repo.texts.add_lines(('myfileid', 'ghostrevid'),
-                        (('myfileid', 'ghost-text-parent'),),
-                        ["line1\n", "line2\n"])
+                    repo.texts.add_lines((b'myfileid', b'ghostrevid'),
+                        ((b'myfileid', b'ghost-text-parent'),),
+                        [b"line1\n", b"line2\n"])
                 except errors.RevisionNotPresent:
                     raise TestSkipped("text ghost parents not supported")
                 if repo.supports_rich_root():
@@ -370,7 +370,7 @@
         repo = self.first_tree.branch.repository
         repo.lock_write()
         repo.start_write_group()
-        inv = Inventory(revision_id='wrong-first-parent')
+        inv = Inventory(revision_id=b'wrong-first-parent')
         inv.root.revision = 'wrong-first-parent'
         if repo.supports_rich_root():
             root_id = inv.root.file_id
@@ -381,7 +381,7 @@
                        committer="Foo Bar <[e-mail]>",
                        message="Message",
                        inventory_sha1=sha1,
-                       revision_id='wrong-first-parent')
+                       revision_id=b'wrong-first-parent')
         rev.parent_ids = ['1', '2']
         repo.add_revision('wrong-first-parent', rev)
         repo.commit_write_group()
@@ -391,7 +391,7 @@
         repo = repo_secondary
         repo.lock_write()
         repo.start_write_group()
-        inv = Inventory(revision_id='wrong-secondary-parent')
+        inv = Inventory(revision_id=b'wrong-secondary-parent')
         inv.root.revision = 'wrong-secondary-parent'
         if repo.supports_rich_root():
             root_id = inv.root.file_id
@@ -402,7 +402,7 @@
                        committer="Foo Bar <[e-mail]>",
                        message="Message",
                        inventory_sha1=sha1,
-                       revision_id='wrong-secondary-parent')
+                       revision_id=b'wrong-secondary-parent')
         rev.parent_ids = ['1', '2', '3']
         repo.add_revision('wrong-secondary-parent', rev)
         repo.commit_write_group()

=== modified file 'breezy/tests/per_repository_vf/test_repository.py'
--- breezy/tests/per_repository_vf/test_repository.py	2018-02-18 15:21:06 +0000
+++ breezy/tests/per_repository_vf/test_repository.py	2018-06-21 08:27:55 +0000
@@ -144,7 +144,7 @@
         self.assertEqual(repo._serializer.format_num, format)
 
     def test_add_revision_inventory_sha1(self):
-        inv = inventory.Inventory(revision_id='A')
+        inv = inventory.Inventory(revision_id=b'A')
         inv.root.revision = 'A'
         inv.root.file_id = 'fixed-root'
         # Insert the inventory on its own to an identical repository, to get
@@ -152,7 +152,7 @@
         reference_repo = self.make_repository('reference_repo')
         reference_repo.lock_write()
         reference_repo.start_write_group()
-        inv_sha1 = reference_repo.add_inventory('A', inv, [])
+        inv_sha1 = reference_repo.add_inventory(b'A', inv, [])
         reference_repo.abort_write_group()
         reference_repo.unlock()
         # Now insert a revision with this inventory, and it should get the same
@@ -162,13 +162,13 @@
         repo.start_write_group()
         root_id = inv.root.file_id
         repo.texts.add_lines(('fixed-root', 'A'), [], [])
-        repo.add_revision('A', _mod_revision.Revision(
-                'A', committer='B', timestamp=0,
+        repo.add_revision(b'A', _mod_revision.Revision(
+                b'A', committer='B', timestamp=0,
                 timezone=0, message='C'), inv=inv)
         repo.commit_write_group()
         repo.unlock()
         repo.lock_read()
-        self.assertEqual(inv_sha1, repo.get_revision('A').inventory_sha1)
+        self.assertEqual(inv_sha1, repo.get_revision(b'A').inventory_sha1)
         repo.unlock()
 
     def test_install_revisions(self):
@@ -183,14 +183,14 @@
         repo.lock_read()
         self.addCleanup(repo.unlock)
         repo2 = self.make_repository('repo2')
-        revision = repo.get_revision('A')
-        tree = repo.revision_tree('A')
-        signature = repo.get_signature_text('A')
+        revision = repo.get_revision(b'A')
+        tree = repo.revision_tree(b'A')
+        signature = repo.get_signature_text(b'A')
         repo2.lock_write()
         self.addCleanup(repo2.unlock)
         vf_repository.install_revisions(repo2, [(revision, tree, signature)])
-        self.assertEqual(revision, repo2.get_revision('A'))
-        self.assertEqual(signature, repo2.get_signature_text('A'))
+        self.assertEqual(revision, repo2.get_revision(b'A'))
+        self.assertEqual(signature, repo2.get_signature_text(b'A'))
 
     def test_attribute_text_store(self):
         """Test the existence of the texts attribute."""
@@ -216,17 +216,17 @@
         # Make a repo with one revision and one versioned file.
         tree = self.make_branch_and_tree('t')
         self.build_tree(['t/foo'])
-        tree.add('foo', 'file1')
+        tree.add('foo', b'file1')
         tree.commit('message', rev_id=b'rev_id')
         repo = tree.branch.repository
         repo.lock_write()
         repo.start_write_group()
         try:
-            repo.sign_revision('rev_id', gpg.LoopbackGPGStrategy(None))
+            repo.sign_revision(b'rev_id', gpg.LoopbackGPGStrategy(None))
         except errors.UnsupportedOperation:
             signature_texts = []
         else:
-            signature_texts = ['rev_id']
+            signature_texts = [b'rev_id']
         repo.commit_write_group()
         repo.unlock()
         repo.lock_read()
@@ -239,11 +239,11 @@
         #   * signatures
         #   * revisions
         expected_item_keys = [
-            ('file', 'file1', ['rev_id']),
-            ('inventory', None, ['rev_id']),
-            ('signatures', None, signature_texts),
-            ('revisions', None, ['rev_id'])]
-        item_keys = list(repo.item_keys_introduced_by(['rev_id']))
+            (b'file', b'file1', [b'rev_id']),
+            (b'inventory', None, [b'rev_id']),
+            (b'signatures', None, signature_texts),
+            (b'revisions', None, [b'rev_id'])]
+        item_keys = list(repo.item_keys_introduced_by([b'rev_id']))
         item_keys = [
             (kind, file_id, list(versions))
             for (kind, file_id, versions) in item_keys]
@@ -254,8 +254,8 @@
             # expected_record_names.
             # Note that the file keys can be in any order, so this test is
             # written to allow that.
-            inv = repo.get_inventory('rev_id')
-            root_item_key = ('file', inv.root.file_id, ['rev_id'])
+            inv = repo.get_inventory(b'rev_id')
+            root_item_key = (b'file', inv.root.file_id, [b'rev_id'])
             self.assertTrue(root_item_key in item_keys)
             item_keys.remove(root_item_key)
 
@@ -419,7 +419,7 @@
         sha1 = repo.add_inventory('ghost', inv, [])
         rev = _mod_revision.Revision(
             timestamp=0, timezone=None, committer="Foo Bar <[e-mail]>",
-            message="Message", inventory_sha1=sha1, revision_id='ghost')
+            message="Message", inventory_sha1=sha1, revision_id=b'ghost')
         rev.parent_ids = ['the_ghost']
         try:
             repo.add_revision('ghost', rev)
@@ -435,7 +435,7 @@
         sha1 = repo.add_inventory('the_ghost', inv, [])
         rev = _mod_revision.Revision(
             timestamp=0, timezone=None, committer="Foo Bar <[e-mail]>",
-            message="Message", inventory_sha1=sha1, revision_id='the_ghost')
+            message="Message", inventory_sha1=sha1, revision_id=b'the_ghost')
         rev.parent_ids = []
         repo.add_revision('the_ghost', rev)
         # check its setup usefully

=== modified file 'breezy/tests/per_repository_vf/test_write_group.py'
--- breezy/tests/per_repository_vf/test_write_group.py	2018-06-14 10:06:05 +0000
+++ breezy/tests/per_repository_vf/test_write_group.py	2018-06-21 08:27:55 +0000
@@ -59,7 +59,7 @@
         tree = self.make_branch_and_memory_tree('branch')
         trunk_repo.lock_read()
         self.addCleanup(trunk_repo.unlock)
-        tree.branch.repository.fetch(trunk_repo, revision_id='rev-1')
+        tree.branch.repository.fetch(trunk_repo, revision_id=b'rev-1')
         tree.set_parent_ids(['rev-1'])
         return tree 
 
@@ -193,13 +193,13 @@
         self.assertEqual(set(),
                 repo.inventories.get_missing_compression_parent_keys())
         self.assertEqual(
-            {('inventories', b'rev-1')},
+            {(b'inventories', b'rev-1')},
             repo.get_missing_parent_inventories())
         # Resuming the write group does not affect
         # get_missing_parent_inventories.
         reopened_repo = self.reopen_repo_and_resume_write_group(repo)
         self.assertEqual(
-            {('inventories', b'rev-1')},
+            {(b'inventories', b'rev-1')},
             reopened_repo.get_missing_parent_inventories())
         # Adding the parent inventory satisfies get_missing_parent_inventories.
         reopened_repo.inventories.insert_record_stream(
@@ -211,10 +211,10 @@
 
     def test_get_missing_parent_inventories_check(self):
         builder = self.make_branch_builder('test')
-        builder.build_snapshot(['ghost-parent-id'], [
-            ('add', ('', 'root-id', 'directory', None)),
-            ('add', ('file', 'file-id', 'file', 'content\n'))],
-            allow_leftmost_as_ghost=True, revision_id='A-id')
+        builder.build_snapshot([b'ghost-parent-id'], [
+            ('add', ('', b'root-id', 'directory', None)),
+            ('add', ('file', b'file-id', 'file', b'content\n'))],
+            allow_leftmost_as_ghost=True, revision_id=b'A-id')
         b = builder.get_branch()
         b.lock_read()
         self.addCleanup(b.unlock)
@@ -224,17 +224,17 @@
         repo.start_write_group()
         self.addCleanup(repo.abort_write_group)
         # Now, add the objects manually
-        text_keys = [('file-id', 'A-id')]
+        text_keys = [(b'file-id', b'A-id')]
         if repo.supports_rich_root():
-            text_keys.append(('root-id', 'A-id'))
+            text_keys.append((b'root-id', b'A-id'))
         # Directly add the texts, inventory, and revision object for 'A-id'
         repo.texts.insert_record_stream(b.repository.texts.get_record_stream(
             text_keys, 'unordered', True))
-        repo.add_revision('A-id', b.repository.get_revision('A-id'),
-                          b.repository.get_inventory('A-id'))
+        repo.add_revision(b'A-id', b.repository.get_revision(b'A-id'),
+                          b.repository.get_inventory(b'A-id'))
         get_missing = repo.get_missing_parent_inventories
         if repo._format.supports_external_lookups:
-            self.assertEqual({('inventories', 'ghost-parent-id')},
+            self.assertEqual({('inventories', b'ghost-parent-id')},
                 get_missing(check_for_missing_texts=False))
             self.assertEqual(set(), get_missing(check_for_missing_texts=True))
             self.assertEqual(set(), get_missing())

=== modified file 'breezy/tests/per_workingtree/test_pull.py'
--- breezy/tests/per_workingtree/test_pull.py	2018-03-26 00:54:10 +0000
+++ breezy/tests/per_workingtree/test_pull.py	2018-06-21 08:27:55 +0000
@@ -84,14 +84,14 @@
         # Create an empty trunk
         builder.build_snapshot(None, [
                 ('add', ('', 'root-id', 'directory', ''))],
-                revision_id='1')
+                revision_id=b'1')
         builder.build_snapshot(['1'], [
                 ('add', ('dir', 'dir-id', 'directory', '')),
                 ('add', ('file', 'file-id', 'file', 'trunk content\n')),],
-                revision_id='2')
+                revision_id=b'2')
         builder.build_snapshot(['2'], [
                 ('unversion', 'dir'),],
-                revision_id='3')
+                revision_id=b'3')
         builder.finish_series()
         return builder.get_branch()
 
@@ -101,7 +101,7 @@
                 '%r does not support missing parent conflicts' %
                     self.workingtree_format)
         trunk = self.make_branch_deleting_dir('trunk')
-        work = trunk.controldir.sprout('work', revision_id='2').open_workingtree()
+        work = trunk.controldir.sprout('work', revision_id=b'2').open_workingtree()
         work.branch.get_config_stack().set(
             'transform.orphan_policy', 'move')
         # Add some unversioned files in dir

=== modified file 'breezy/tests/test_annotate.py'
--- breezy/tests/test_annotate.py	2018-03-26 00:54:10 +0000
+++ breezy/tests/test_annotate.py	2018-06-21 08:27:55 +0000
@@ -183,19 +183,19 @@
             ('add', ('', 'root-id', 'directory', None)),
             ('add', ('a', 'a-id', 'file', 'first\n')),
             ], timestamp=1166046000.00, timezone=0, committer="[e-mail]",
-            revision_id='rev-1')
+            revision_id=b'rev-1')
         builder.build_snapshot(['rev-1'], [
             ('modify', ('a', 'first\nsecond\n')),
             ], timestamp=1166046001.00, timezone=0, committer="[e-mail]",
-            revision_id='rev-2')
+            revision_id=b'rev-2')
         builder.build_snapshot(['rev-1'], [
             ('modify', ('a', 'first\nthird\n')),
             ], timestamp=1166046002.00, timezone=0, committer="[e-mail]",
-            revision_id='rev-1_1_1')
+            revision_id=b'rev-1_1_1')
         builder.build_snapshot(['rev-2', 'rev-1_1_1'], [
             ('modify', ('a', 'first\nsecond\nthird\n')),
             ], timestamp=1166046003.00, timezone=0, committer="[e-mail]",
-            revision_id='rev-3')
+            revision_id=b'rev-3')
         return builder
 
     def create_deeply_merged_trees(self):
@@ -222,27 +222,27 @@
         rev-6
         """
         builder = self.create_merged_trees()
-        builder.build_snapshot(['rev-1_1_1'], [], revision_id='rev-1_1_2')
-        builder.build_snapshot(['rev-3', 'rev-1_1_2'], [], revision_id='rev-4')
+        builder.build_snapshot(['rev-1_1_1'], [], revision_id=b'rev-1_1_2')
+        builder.build_snapshot(['rev-3', 'rev-1_1_2'], [], revision_id=b'rev-4')
         builder.build_snapshot(['rev-1_1_1'], [
             ('modify', ('a', 'first\nthird\nfourth\n')),
             ], timestamp=1166046003.00, timezone=0, committer="[e-mail]",
-            revision_id='rev-1_2_1')
+            revision_id=b'rev-1_2_1')
         builder.build_snapshot(['rev-1_2_1'], [],
             timestamp=1166046004.00, timezone=0, committer="[e-mail]",
-            revision_id='rev-1_2_2')
+            revision_id=b'rev-1_2_2')
         builder.build_snapshot(['rev-4', 'rev-1_2_2'], [
             ('modify', ('a', 'first\nsecond\nthird\nfourth\n')),
             ], timestamp=1166046004.00, timezone=0, committer="[e-mail]",
-            revision_id='rev-5')
+            revision_id=b'rev-5')
         builder.build_snapshot(['rev-1_2_1'], [
             ('modify', ('a', 'first\nthird\nfourth\nfifth\nsixth\n')),
             ], timestamp=1166046005.00, timezone=0, committer="[e-mail]",
-            revision_id='rev-1_3_1')
+            revision_id=b'rev-1_3_1')
         builder.build_snapshot(['rev-5', 'rev-1_3_1'], [
             ('modify', ('a',
                         'first\nsecond\nthird\nfourth\nfifth\nsixth\n')),
-            ], revision_id='rev-6')
+            ], revision_id=b'rev-6')
         return builder
 
     def create_duplicate_lines_tree(self):
@@ -258,22 +258,22 @@
         builder.build_snapshot(None, [
             ('add', ('', 'root-id', 'directory', None)),
             ('add', ('file', 'file-id', 'file', base_text)),
-            ], revision_id='rev-base')
+            ], revision_id=b'rev-base')
         builder.build_snapshot(['rev-base'], [
             ('modify', ('file', a_text))],
-            revision_id='rev-A')
+            revision_id=b'rev-A')
         builder.build_snapshot(['rev-base'], [
             ('modify', ('file', b_text))],
-            revision_id='rev-B')
+            revision_id=b'rev-B')
         builder.build_snapshot(['rev-A'], [
             ('modify', ('file', c_text))],
-            revision_id='rev-C')
+            revision_id=b'rev-C')
         builder.build_snapshot(['rev-B', 'rev-A'], [
             ('modify', ('file', d_text))],
-            revision_id='rev-D')
+            revision_id=b'rev-D')
         builder.build_snapshot(['rev-C', 'rev-D'], [
             ('modify', ('file', e_text))],
-            revision_id='rev-E')
+            revision_id=b'rev-E')
         return builder
 
     def assertAnnotateEqualDiff(self, actual, expected):
@@ -414,8 +414,8 @@
         tree1.lock_read()
         self.addCleanup(tree1.unlock)
 
-        revtree_1 = tree1.branch.repository.revision_tree('rev-1')
-        revtree_2 = tree1.branch.repository.revision_tree('rev-2')
+        revtree_1 = tree1.branch.repository.revision_tree(b'rev-1')
+        revtree_2 = tree1.branch.repository.revision_tree(b'rev-2')
 
         # this passes if no exception is raised
         to_file = BytesIO()

=== modified file 'breezy/tests/test_branchbuilder.py'
--- breezy/tests/test_branchbuilder.py	2018-03-26 00:54:10 +0000
+++ breezy/tests/test_branchbuilder.py	2018-06-21 08:27:55 +0000
@@ -119,7 +119,7 @@
         rev_id1 = builder.build_snapshot(None,
             [('add', ('', 'a-root-id', 'directory', None)),
              ('add', ('a', 'a-id', 'file', 'contents'))],
-            revision_id='A-id')
+            revision_id=b'A-id')
         self.assertEqual('A-id', rev_id1)
         return builder
 
@@ -127,7 +127,7 @@
         builder = self.build_a_rev()
         branch = builder.get_branch()
         self.assertEqual((1, 'A-id'), branch.last_revision_info())
-        rev_tree = branch.repository.revision_tree('A-id')
+        rev_tree = branch.repository.revision_tree(b'A-id')
         rev_tree.lock_read()
         self.addCleanup(rev_tree.unlock)
         self.assertTreeShape([(u'', 'a-root-id', 'directory'),
@@ -138,7 +138,7 @@
         builder = self.build_a_rev()
         rev_id2 = builder.build_snapshot(None,
             [('add', ('b', 'b-id', 'file', 'content_b'))],
-            revision_id='B-id')
+            revision_id=b'B-id')
         self.assertEqual('B-id', rev_id2)
         branch = builder.get_branch()
         self.assertEqual((2, rev_id2), branch.last_revision_info())
@@ -154,8 +154,8 @@
         builder = self.build_a_rev()
         rev_id2 = builder.build_snapshot(None,
             [('add', ('b', 'b-id', 'directory', None))],
-            revision_id='B-id')
-        rev_tree = builder.get_branch().repository.revision_tree('B-id')
+            revision_id=b'B-id')
+        rev_tree = builder.get_branch().repository.revision_tree(b'B-id')
         self.assertTreeShape([(u'', 'a-root-id', 'directory'),
                               (u'a', 'a-id', 'file'),
                               (u'b', 'b-id', 'directory'),
@@ -201,7 +201,7 @@
         builder = self.build_a_rev()
         rev_id2 = builder.build_snapshot(None,
             [('modify', ('a', 'new\ncontent\n'))],
-            revision_id='B-id')
+            revision_id=b'B-id')
         self.assertEqual('B-id', rev_id2)
         branch = builder.get_branch()
         rev_tree = branch.repository.revision_tree(rev_id2)
@@ -213,7 +213,7 @@
     def test_delete_file(self):
         builder = self.build_a_rev()
         rev_id2 = builder.build_snapshot(None,
-            [('unversion', 'a')], revision_id='B-id')
+            [('unversion', 'a')], revision_id=b'B-id')
         self.assertEqual('B-id', rev_id2)
         branch = builder.get_branch()
         rev_tree = branch.repository.revision_tree(rev_id2)
@@ -228,8 +228,8 @@
              ('add', ('b/c', 'c-id', 'file', 'foo\n')),
              ('add', ('b/d', 'd-id', 'directory', None)),
              ('add', ('b/d/e', 'e-id', 'file', 'eff\n')),
-            ], revision_id='B-id')
-        rev_tree = builder.get_branch().repository.revision_tree('B-id')
+            ], revision_id=b'B-id')
+        rev_tree = builder.get_branch().repository.revision_tree(b'B-id')
         self.assertTreeShape([(u'', 'a-root-id', 'directory'),
                               (u'a', 'a-id', 'file'),
                               (u'b', 'b-id', 'directory'),
@@ -239,8 +239,8 @@
         # Removing a directory removes all child dirs
         builder.build_snapshot(
                 None, [('unversion', 'b')],
-                revision_id='C-id')
-        rev_tree = builder.get_branch().repository.revision_tree('C-id')
+                revision_id=b'C-id')
+        rev_tree = builder.get_branch().repository.revision_tree(b'C-id')
         self.assertTreeShape([(u'', 'a-root-id', 'directory'),
                               (u'a', 'a-id', 'file'),
                              ], rev_tree)
@@ -249,14 +249,14 @@
         builder = self.build_a_rev()
         e = self.assertRaises(ValueError,
             builder.build_snapshot, None, [('weirdo', ('foo',))],
-            revision_id='B-id')
+            revision_id=b'B-id')
         self.assertEqual('Unknown build action: "weirdo"', str(e))
 
     def test_rename(self):
         builder = self.build_a_rev()
         builder.build_snapshot(None,
-            [('rename', ('a', 'b'))], revision_id='B-id')
-        rev_tree = builder.get_branch().repository.revision_tree('B-id')
+            [('rename', ('a', 'b'))], revision_id=b'B-id')
+        rev_tree = builder.get_branch().repository.revision_tree(b'B-id')
         self.assertTreeShape([(u'', 'a-root-id', 'directory'),
                               (u'b', 'a-id', 'file')], rev_tree)
 
@@ -264,8 +264,8 @@
         builder = self.build_a_rev()
         builder.build_snapshot(None,
             [('add', ('dir', 'dir-id', 'directory', None)),
-             ('rename', ('a', 'dir/a'))], revision_id='B-id')
-        rev_tree = builder.get_branch().repository.revision_tree('B-id')
+             ('rename', ('a', 'dir/a'))], revision_id=b'B-id')
+        rev_tree = builder.get_branch().repository.revision_tree(b'B-id')
         self.assertTreeShape([(u'', 'a-root-id', 'directory'),
                               (u'dir', 'dir-id', 'directory'),
                               (u'dir/a', 'a-id', 'file')], rev_tree)
@@ -275,11 +275,11 @@
         builder.build_snapshot(None,
             [('add', ('dir', 'dir-id', 'directory', None)),
              ('rename', ('a', 'dir/a'))],
-            revision_id='B-id')
+            revision_id=b'B-id')
         builder.build_snapshot(None,
             [('rename', ('dir/a', 'a')),
-             ('unversion', 'dir')], revision_id='C-id')
-        rev_tree = builder.get_branch().repository.revision_tree('C-id')
+             ('unversion', 'dir')], revision_id=b'C-id')
+        rev_tree = builder.get_branch().repository.revision_tree(b'C-id')
         self.assertTreeShape([(u'', 'a-root-id', 'directory'),
                               (u'a', 'a-id', 'file')], rev_tree)
 
@@ -289,10 +289,10 @@
         self.addCleanup(builder.finish_series)
         builder.build_snapshot(['A-id'],
             [('modify', ('a', 'new\ncontent\n'))],
-            revision_id='B-id')
+            revision_id=b'B-id')
         builder.build_snapshot(['A-id'],
             [('add', ('c', 'c-id', 'file', 'alt\ncontent\n'))],
-            revision_id='C-id')
+            revision_id=b'C-id')
         # We should now have a graph:
         #   A
         #   |\
@@ -301,14 +301,14 @@
         repo = builder.get_branch().repository
         self.assertEqual({'B-id': ('A-id',), 'C-id': ('A-id',)},
                          repo.get_parent_map(['B-id', 'C-id']))
-        b_tree = repo.revision_tree('B-id')
+        b_tree = repo.revision_tree(b'B-id')
         self.assertTreeShape([(u'', 'a-root-id', 'directory'),
                               (u'a', 'a-id', 'file'),
                              ], b_tree)
         self.assertEqual('new\ncontent\n', b_tree.get_file_text('a'))
 
         # We should still be using the content from A in C, not from B
-        c_tree = repo.revision_tree('C-id')
+        c_tree = repo.revision_tree(b'C-id')
         self.assertTreeShape([(u'', 'a-root-id', 'directory'),
                               (u'a', 'a-id', 'file'),
                               (u'c', 'c-id', 'file'),
@@ -322,16 +322,16 @@
         self.addCleanup(builder.finish_series)
         builder.build_snapshot(['A-id'],
             [('add', ('b', 'b-id', 'file', 'b\ncontent\n'))],
-            revision_id='B-id')
+            revision_id=b'B-id')
         builder.build_snapshot(['A-id'],
             [('add', ('c', 'c-id', 'file', 'alt\ncontent\n'))],
-            revision_id='C-id')
-        builder.build_snapshot(['B-id', 'C-id'], [], revision_id='D-id')
+            revision_id=b'C-id')
+        builder.build_snapshot(['B-id', 'C-id'], [], revision_id=b'D-id')
         repo = builder.get_branch().repository
         self.assertEqual({'B-id': ('A-id',), 'C-id': ('A-id',),
                           'D-id': ('B-id', 'C-id')},
                          repo.get_parent_map(['B-id', 'C-id', 'D-id']))
-        d_tree = repo.revision_tree('D-id')
+        d_tree = repo.revision_tree(b'D-id')
         # Note: by default a merge node does *not* pull in the changes from the
         #       merged tree, you have to supply it yourself.
         self.assertTreeShape([(u'', 'a-root-id', 'directory'),
@@ -345,18 +345,18 @@
         self.addCleanup(builder.finish_series)
         builder.build_snapshot(['A-id'],
             [('add', ('b', 'b-id', 'file', 'b\ncontent\n'))],
-            revision_id='B-id')
+            revision_id=b'B-id')
         builder.build_snapshot(['A-id'],
             [('add', ('c', 'c-id', 'file', 'alt\ncontent\n'))],
-            revision_id='C-id')
+            revision_id=b'C-id')
         builder.build_snapshot(['B-id', 'C-id'],
             [('add', ('c', 'c-id', 'file', 'alt\ncontent\n'))],
-            revision_id='D-id')
+            revision_id=b'D-id')
         repo = builder.get_branch().repository
         self.assertEqual({'B-id': ('A-id',), 'C-id': ('A-id',),
                           'D-id': ('B-id', 'C-id')},
                          repo.get_parent_map(['B-id', 'C-id', 'D-id']))
-        d_tree = repo.revision_tree('D-id')
+        d_tree = repo.revision_tree(b'D-id')
         self.assertTreeShape([(u'', 'a-root-id', 'directory'),
                               (u'a', 'a-id', 'file'),
                               (u'b', 'b-id', 'file'),
@@ -372,7 +372,7 @@
         self.addCleanup(builder.finish_series)
         builder.build_snapshot([],
             [('add', ('', None, 'directory', None))],
-            revision_id='B-id')
+            revision_id=b'B-id')
         # We should now have a graph:
         #   A B
         # And not A => B
@@ -400,7 +400,7 @@
         try:
             builder.build_snapshot(['ghost'],
                 [('add', ('', 'ROOT_ID', 'directory', ''))],
-                allow_leftmost_as_ghost=True, revision_id='tip')
+                allow_leftmost_as_ghost=True, revision_id=b'tip')
         finally:
             builder.finish_series()
         b = builder.get_branch()
@@ -414,13 +414,13 @@
         builder.start_series()
         builder.build_snapshot(None,
             [('add', ('', 'TREE_ROOT', 'directory', ''))],
-            revision_id='rev-1')
+            revision_id=b'rev-1')
         builder.build_snapshot(None,
             [('unversion', ''),
              ('add', ('', 'my-root', 'directory', ''))],
-            revision_id='rev-2')
+            revision_id=b'rev-2')
         builder.finish_series()
-        rev_tree = builder.get_branch().repository.revision_tree('rev-2')
+        rev_tree = builder.get_branch().repository.revision_tree(b'rev-2')
         self.assertTreeShape([(u'', 'my-root', 'directory')], rev_tree)
 
     def test_empty_flush(self):
@@ -429,10 +429,10 @@
         builder.start_series()
         builder.build_snapshot(None,
             [('add', ('', 'TREE_ROOT', 'directory', ''))],
-            revision_id='rev-1')
-        builder.build_snapshot(None, [('flush', None)], revision_id='rev-2')
+            revision_id=b'rev-1')
+        builder.build_snapshot(None, [('flush', None)], revision_id=b'rev-2')
         builder.finish_series()
-        rev_tree = builder.get_branch().repository.revision_tree('rev-2')
+        rev_tree = builder.get_branch().repository.revision_tree(b'rev-2')
         self.assertTreeShape([(u'', 'TREE_ROOT', 'directory')], rev_tree)
 
     def test_kind_change(self):
@@ -444,14 +444,14 @@
         builder.build_snapshot(None,
             [('add', (u'', 'a-root-id', 'directory', None)),
              ('add', (u'a', 'a-id', 'file', 'content\n'))],
-            revision_id='A-id')
+            revision_id=b'A-id')
         builder.build_snapshot(None,
             [('unversion', 'a'),
              ('flush', None),
              ('add', (u'a', 'a-id', 'directory', None))],
-            revision_id='B-id')
+            revision_id=b'B-id')
         builder.finish_series()
-        rev_tree = builder.get_branch().repository.revision_tree('B-id')
+        rev_tree = builder.get_branch().repository.revision_tree(b'B-id')
         self.assertTreeShape(
             [(u'', 'a-root-id', 'directory'), (u'a', 'a-id', 'directory')],
             rev_tree)
@@ -465,13 +465,13 @@
         builder.build_snapshot(None,
             [('add', (u'', 'orig-root', 'directory', None)),
              ('add', (u'dir', 'dir-id', 'directory', None))],
-            revision_id='A-id')
+            revision_id=b'A-id')
         builder.build_snapshot(None,
             [('unversion', ''),  # implicitly unversions all children
              ('flush', None),
              ('add', (u'', 'dir-id', 'directory', None))],
-            revision_id='B-id')
+            revision_id=b'B-id')
         builder.finish_series()
-        rev_tree = builder.get_branch().repository.revision_tree('B-id')
+        rev_tree = builder.get_branch().repository.revision_tree(b'B-id')
         self.assertTreeShape([(u'', 'dir-id', 'directory')], rev_tree)
 

=== modified file 'breezy/tests/test_bundle.py'
--- breezy/tests/test_bundle.py	2018-05-27 16:53:07 +0000
+++ breezy/tests/test_bundle.py	2018-06-21 08:27:55 +0000
@@ -988,12 +988,12 @@
         self.tree1 = self.make_branch_and_tree('b1')
         self.b1 = self.tree1.branch
         self.tree1.commit('message', rev_id=b'rev2a')
-        bundle = self.get_valid_bundle('null:', 'rev2a')
+        bundle = self.get_valid_bundle(b'null:', b'rev2a')
         branch2 = self.make_branch('b2')
-        self.assertFalse(branch2.repository.has_revision('rev2a'))
+        self.assertFalse(branch2.repository.has_revision(b'rev2a'))
         target_revision = bundle.install_revisions(branch2.repository)
-        self.assertTrue(branch2.repository.has_revision('rev2a'))
-        self.assertEqual('rev2a', target_revision)
+        self.assertTrue(branch2.repository.has_revision(b'rev2a'))
+        self.assertEqual(b'rev2a', target_revision)
 
     def test_bundle_empty_property(self):
         """Test serializing revision properties with an empty value."""
@@ -1003,10 +1003,10 @@
         tree.add([''], [b'TREE_ROOT'])
         tree.commit('One', revprops={'one':'two', 'empty':''}, rev_id=b'rev1')
         self.b1 = tree.branch
-        bundle_sio, revision_ids = self.create_bundle_text('null:', 'rev1')
+        bundle_sio, revision_ids = self.create_bundle_text(b'null:', b'rev1')
         bundle = read_bundle(bundle_sio)
         revision_info = bundle.revisions[0]
-        self.assertEqual('rev1', revision_info.revision_id)
+        self.assertEqual(b'rev1', revision_info.revision_id)
         rev = revision_info.as_revision()
         self.assertEqual({'branch-nick':'tree', 'empty':'', 'one':'two'},
                          rev.properties)
@@ -1085,26 +1085,26 @@
         tree = self.make_simple_tree('knit')
         tree.commit('hello', rev_id=b'rev1')
         tree.commit('hello', rev_id=b'rev2')
-        bundle = read_bundle(self.create_bundle_text('null:', 'rev2')[0])
+        bundle = read_bundle(self.create_bundle_text(b'null:', b'rev2')[0])
         repo = self.make_repository('repo', format='dirstate-with-subtree')
         bundle.install_revisions(repo)
         return repo
 
     def test_across_models(self):
         repo = self.make_repo_with_installed_revisions()
-        inv = repo.get_inventory('rev2')
-        self.assertEqual('rev2', inv.root.revision)
+        inv = repo.get_inventory(b'rev2')
+        self.assertEqual(b'rev2', inv.root.revision)
         root_id = inv.root.file_id
         repo.lock_read()
         self.addCleanup(repo.unlock)
-        self.assertEqual({(root_id, 'rev1'):(),
-            (root_id, 'rev2'):((root_id, 'rev1'),)},
-            repo.texts.get_parent_map([(root_id, 'rev1'), (root_id, 'rev2')]))
+        self.assertEqual({(root_id, b'rev1'):(),
+            (root_id, b'rev2'):((root_id, b'rev1'),)},
+            repo.texts.get_parent_map([(root_id, b'rev1'), (root_id, b'rev2')]))
 
     def test_inv_hash_across_serializers(self):
         repo = self.make_repo_with_installed_revisions()
-        recorded_inv_sha1 = repo.get_revision('rev2').inventory_sha1
-        xml = repo._get_inventory_xml('rev2')
+        recorded_inv_sha1 = repo.get_revision(b'rev2').inventory_sha1
+        xml = repo._get_inventory_xml(b'rev2')
         self.assertEqual(osutils.sha_string(xml), recorded_inv_sha1)
 
     def test_across_models_incompatible(self):
@@ -1410,7 +1410,7 @@
         tree.commit('changed file', rev_id=b'rev2')
         s = BytesIO()
         serializer = BundleSerializerV4('1.0')
-        serializer.write(tree.branch.repository, ['rev1', 'rev2'], {}, s)
+        serializer.write(tree.branch.repository, [b'rev1', b'rev2'], {}, s)
         s.seek(0)
         tree2 = self.make_branch_and_tree('target')
         target_repo = tree2.branch.repository
@@ -1420,19 +1420,19 @@
         # Turn the 'iterators_of_bytes' back into simple strings for comparison
         repo_texts = dict((i, ''.join(content)) for i, content
                           in target_repo.iter_files_bytes(
-                                [('fileid-2', 'rev1', '1'),
-                                 ('fileid-2', 'rev2', '2')]))
-        self.assertEqual({'1':'contents1\nstatic\n',
-                          '2':'contents2\nstatic\n'},
+                                [(b'fileid-2', b'rev1', '1'),
+                                 (b'fileid-2', b'rev2', '2')]))
+        self.assertEqual({'1':b'contents1\nstatic\n',
+                          '2':b'contents2\nstatic\n'},
                          repo_texts)
-        rtree = target_repo.revision_tree('rev2')
+        rtree = target_repo.revision_tree(b'rev2')
         inventory_vf = target_repo.inventories
         # If the inventory store has a graph, it must match the revision graph.
         self.assertSubset(
-            [inventory_vf.get_parent_map([('rev2',)])[('rev2',)]],
-            [None, (('rev1',),)])
+            [inventory_vf.get_parent_map([(b'rev2',)])[(b'rev2',)]],
+            [None, ((b'rev1',),)])
         self.assertEqual('changed file',
-                         target_repo.get_revision('rev2').message)
+                         target_repo.get_revision(b'rev2').message)
 
     @staticmethod
     def get_raw(bundle_file):
@@ -1515,16 +1515,16 @@
         builder.build_snapshot(None, [
             ('add', ('', 'root-id', 'directory', None)),
             ('add', ('file', 'file-id', 'file', 'original content\n')),
-            ], revision_id='a@cset-0-1')
+            ], revision_id=b'a@cset-0-1')
         builder.build_snapshot(['a@cset-0-1'], [
             ('modify', ('file', 'new-content\n')),
-            ], revision_id='a@cset-0-2a')
+            ], revision_id=b'a@cset-0-2a')
         builder.build_snapshot(['a@cset-0-1'], [
             ('add', ('other-file', 'file2-id', 'file', 'file2-content\n')),
-            ], revision_id='a@cset-0-2b')
+            ], revision_id=b'a@cset-0-2b')
         builder.build_snapshot(['a@cset-0-2a', 'a@cset-0-2b'], [
             ('add', ('other-file', 'file2-id', 'file', 'file2-content\n')),
-            ], revision_id='a@cset-0-3')
+            ], revision_id=b'a@cset-0-3')
         builder.finish_series()
         self.b1 = builder.get_branch()
         self.b1.lock_read()
@@ -1657,7 +1657,7 @@
     def test_creating_bundle_preserves_chk_pages(self):
         self.make_merged_branch()
         target = self.b1.controldir.sprout('target',
-                                       revision_id='a@cset-0-2a').open_branch()
+                                       revision_id=b'a@cset-0-2a').open_branch()
         bundle_txt, rev_ids = self.create_bundle_text('a@cset-0-2a',
                                                       'a@cset-0-3')
         self.assertEqual(['a@cset-0-2b', 'a@cset-0-3'], rev_ids)

=== modified file 'breezy/tests/test_commit.py'
--- breezy/tests/test_commit.py	2018-03-25 11:39:36 +0000
+++ breezy/tests/test_commit.py	2018-06-21 08:27:55 +0000
@@ -163,7 +163,7 @@
             [('missing', u'hello'), ('deleted', u'hello')],
             reporter.calls)
 
-        tree = b.repository.revision_tree('rev2')
+        tree = b.repository.revision_tree(b'rev2')
         self.assertFalse(tree.has_id(b'hello-id'))
 
     def test_partial_commit_move(self):
@@ -238,14 +238,14 @@
         eq = self.assertEqual
         eq(b.revno(), 3)
 
-        tree2 = b.repository.revision_tree('test@rev-2')
+        tree2 = b.repository.revision_tree(b'test@rev-2')
         tree2.lock_read()
         self.addCleanup(tree2.unlock)
         self.assertTrue(tree2.has_filename('hello'))
         self.assertEqual(tree2.get_file_text('hello'), 'hello')
         self.assertEqual(tree2.get_file_text('buongia'), 'new text')
 
-        tree3 = b.repository.revision_tree('test@rev-3')
+        tree3 = b.repository.revision_tree(b'test@rev-3')
         tree3.lock_read()
         self.addCleanup(tree3.unlock)
         self.assertFalse(tree3.has_filename('hello'))
@@ -345,8 +345,8 @@
         wt.remove('hello')
         wt.commit('removed hello', rev_id=b'rev2')
 
-        tree = b.repository.revision_tree('rev2')
-        self.assertFalse(tree.has_id('hello-id'))
+        tree = b.repository.revision_tree(b'rev2')
+        self.assertFalse(tree.has_id(b'hello-id'))
 
     def test_committed_ancestry(self):
         """Test commit appends revisions to ancestry."""
@@ -370,13 +370,13 @@
         b = wt.branch
         self.build_tree(['dir/', 'dir/file1', 'dir/file2'])
         wt.add(['dir', 'dir/file1', 'dir/file2'],
-              ['dirid', 'file1id', 'file2id'])
+              [b'dirid', b'file1id', b'file2id'])
         wt.commit('dir/file1', specific_files=['dir/file1'], rev_id=b'1')
-        inv = b.repository.get_inventory('1')
-        self.assertEqual('1', inv.get_entry('dirid').revision)
-        self.assertEqual('1', inv.get_entry('file1id').revision)
+        inv = b.repository.get_inventory(b'1')
+        self.assertEqual(b'1', inv.get_entry(b'dirid').revision)
+        self.assertEqual(b'1', inv.get_entry(b'file1id').revision)
         # FIXME: This should raise a KeyError I think, rbc20051006
-        self.assertRaises(BzrError, inv.get_entry, 'file2id')
+        self.assertRaises(BzrError, inv.get_entry, b'file2id')
 
     def test_strict_commit(self):
         """Try and commit with unknown files and strict = True, should fail."""
@@ -450,7 +450,7 @@
         wt = self.make_branch_and_tree('.')
         branch = wt.branch
         wt.commit("base", allow_pointless=True, rev_id=b'A')
-        self.assertFalse(branch.repository.has_signature_for_revision_id('A'))
+        self.assertFalse(branch.repository.has_signature_for_revision_id(b'A'))
         try:
             # monkey patch gpg signing mechanism
             breezy.gpg.GPGStrategy = breezy.gpg.DisabledGPGStrategy
@@ -464,8 +464,8 @@
                               rev_id=b'B',
                               working_tree=wt)
             branch = Branch.open(self.get_url('.'))
-            self.assertEqual(branch.last_revision(), 'A')
-            self.assertFalse(branch.repository.has_revision('B'))
+            self.assertEqual(branch.last_revision(), b'A')
+            self.assertFalse(branch.repository.has_revision(b'B'))
         finally:
             breezy.gpg.GPGStrategy = oldstrategy
 
@@ -628,7 +628,7 @@
         tree.commit('added a', timestamp=1153248633.4186721, timezone=0,
                     rev_id=b'a1')
 
-        rev = tree.branch.repository.get_revision('a1')
+        rev = tree.branch.repository.get_revision(b'a1')
         self.assertEqual(1153248633.419, rev.timestamp)
 
     def test_commit_has_1ms_resolution(self):
@@ -638,7 +638,7 @@
         tree.add('a')
         tree.commit('added a', rev_id=b'a1')
 
-        rev = tree.branch.repository.get_revision('a1')
+        rev = tree.branch.repository.get_revision(b'a1')
         timestamp = rev.timestamp
         timestamp_1ms = round(timestamp, 3)
         self.assertEqual(timestamp_1ms, timestamp)
@@ -830,7 +830,7 @@
         branch = controldir.ControlDir.create_branch_convenience('repo/branch')
         tree2 = branch.create_checkout('repo/tree2')
         tree2.commit('message', rev_id=b'rev1')
-        self.assertTrue(tree2.branch.repository.has_revision('rev1'))
+        self.assertTrue(tree2.branch.repository.has_revision(b'rev1'))
 
 
 class FilterExcludedTests(TestCase):

=== modified file 'breezy/tests/test_commit_merge.py'
--- breezy/tests/test_commit_merge.py	2018-02-18 15:21:06 +0000
+++ breezy/tests/test_commit_merge.py	2018-06-21 08:27:55 +0000
@@ -62,11 +62,11 @@
         graph = wty.branch.repository.get_graph()
         self.addCleanup(wty.lock_read().unlock)
         self.assertThat(by,
-            RevisionHistoryMatches([base_rev, 'y@u-0-1', 'y@u-0-2'])
+            RevisionHistoryMatches([base_rev, b'y@u-0-1', b'y@u-0-2'])
             )
-        rev = by.repository.get_revision('y@u-0-2')
+        rev = by.repository.get_revision(b'y@u-0-2')
         self.assertEqual(rev.parent_ids,
-                          ['y@u-0-1', 'x@u-0-1'])
+                          [b'y@u-0-1', b'x@u-0-1'])
 
     def test_merge_new_file(self):
         """Commit merge of two trees with no overlapping files."""

=== modified file 'breezy/tests/test_conflicts.py'
--- breezy/tests/test_conflicts.py	2018-03-27 00:23:34 +0000
+++ breezy/tests/test_conflicts.py	2018-06-21 08:27:55 +0000
@@ -304,16 +304,16 @@
         # Create an empty trunk
         builder.build_snapshot(None, [
                 ('add', ('', 'root-id', 'directory', ''))],
-                revision_id='start')
+                revision_id=b'start')
         # Add a minimal base content
         base_actions = self._get_actions(self._base_actions)()
-        builder.build_snapshot(['start'], base_actions, revision_id='base')
+        builder.build_snapshot(['start'], base_actions, revision_id=b'base')
         # Modify the base content in branch
         actions_other = self._get_actions(self._other['actions'])()
-        builder.build_snapshot(['base'], actions_other, revision_id='other')
+        builder.build_snapshot(['base'], actions_other, revision_id=b'other')
         # Modify the base content in trunk
         actions_this = self._get_actions(self._this['actions'])()
-        builder.build_snapshot(['base'], actions_this, revision_id='this')
+        builder.build_snapshot(['base'], actions_this, revision_id=b'this')
         # builder.get_branch() tip is now 'this'
 
         builder.finish_series()

=== modified file 'breezy/tests/test_diff.py'
--- breezy/tests/test_diff.py	2018-02-18 15:21:06 +0000
+++ breezy/tests/test_diff.py	2018-06-21 08:27:55 +0000
@@ -403,8 +403,8 @@
 ''')
 
     def test_diff_rev_tree_rev_tree(self):
-        tree1 = self.b.repository.revision_tree('rev-2')
-        tree2 = self.b.repository.revision_tree('rev-3')
+        tree1 = self.b.repository.revision_tree(b'rev-2')
+        tree2 = self.b.repository.revision_tree(b'rev-3')
         output = get_diff_as_string(tree1, tree2)
         self.assertEqualDiff(output, '''\
 === modified file 'file2'
@@ -418,7 +418,7 @@
 
     def test_diff_add_files(self):
         tree1 = self.b.repository.revision_tree(_mod_revision.NULL_REVISION)
-        tree2 = self.b.repository.revision_tree('rev-1')
+        tree2 = self.b.repository.revision_tree(b'rev-1')
         output = get_diff_as_string(tree1, tree2)
         # the files have the epoch time stamp for the tree in which
         # they don't exist.
@@ -438,8 +438,8 @@
 ''')
 
     def test_diff_remove_files(self):
-        tree1 = self.b.repository.revision_tree('rev-3')
-        tree2 = self.b.repository.revision_tree('rev-4')
+        tree1 = self.b.repository.revision_tree(b'rev-3')
+        tree2 = self.b.repository.revision_tree(b'rev-4')
         output = get_diff_as_string(tree1, tree2)
         # the file has the epoch time stamp for the tree in which
         # it doesn't exist.
@@ -455,8 +455,8 @@
     def test_show_diff_specified(self):
         """A working tree filename can be used to identify a file"""
         self.wt.rename_one('file1', 'file1b')
-        old_tree = self.b.repository.revision_tree('rev-1')
-        new_tree = self.b.repository.revision_tree('rev-4')
+        old_tree = self.b.repository.revision_tree(b'rev-1')
+        new_tree = self.b.repository.revision_tree(b'rev-4')
         out = get_diff_as_string(old_tree, new_tree, specific_files=['file1b'],
                             working_tree=self.wt)
         self.assertContainsRe(out, 'file1\t')
@@ -467,8 +467,8 @@
         os.mkdir('dir2')
         self.wt.add(['dir1', 'dir2'])
         self.wt.rename_one('file1', 'dir1/file1')
-        old_tree = self.b.repository.revision_tree('rev-1')
-        new_tree = self.b.repository.revision_tree('rev-4')
+        old_tree = self.b.repository.revision_tree(b'rev-1')
+        new_tree = self.b.repository.revision_tree(b'rev-4')
         out = get_diff_as_string(old_tree, new_tree, specific_files=['dir1'],
                             working_tree=self.wt)
         self.assertContainsRe(out, 'file1\t')

=== modified file 'breezy/tests/test_dirstate.py'
--- breezy/tests/test_dirstate.py	2018-03-25 11:39:36 +0000
+++ breezy/tests/test_dirstate.py	2018-06-21 08:27:55 +0000
@@ -974,7 +974,7 @@
         # in case the default tree format uses a different root id
         mt.set_root_id(b'TREE_ROOT')
         mt.commit('foo', rev_id=b'parent-revid')
-        rt = mt.branch.repository.revision_tree('parent-revid')
+        rt = mt.branch.repository.revision_tree(b'parent-revid')
         state = dirstate.DirState.initialize('dirstate')
         state._validate()
         try:

=== modified file 'breezy/tests/test_fetch.py'
--- breezy/tests/test_fetch.py	2018-02-18 15:21:06 +0000
+++ breezy/tests/test_fetch.py	2018-06-21 08:27:55 +0000
@@ -289,7 +289,7 @@
                         source.inventories)
         # precondition
         self.assertTrue(target._format._fetch_uses_deltas)
-        target.fetch(source, revision_id='rev-one')
+        target.fetch(source, revision_id=b'rev-one')
         self.assertEqual(('get_record_stream', [('file-id', 'rev-one')],
                           target._format._fetch_order, False),
                          self.find_get_record_stream(source.texts.calls))
@@ -329,7 +329,7 @@
                         source.inventories)
         # XXX: This won't work in general, but for the dirstate format it does.
         self.overrideAttr(target._format, '_fetch_uses_deltas', False)
-        target.fetch(source, revision_id='rev-one')
+        target.fetch(source, revision_id=b'rev-one')
         self.assertEqual(('get_record_stream', [('file-id', 'rev-one')],
                           target._format._fetch_order, True),
                          self.find_get_record_stream(source.texts.calls))
@@ -373,7 +373,7 @@
         record = next(source.revisions.get_record_stream([('rev-two',)],
             'unordered', False))
         self.assertEqual('knit-delta-gz', record.storage_kind)
-        target.fetch(tree.branch.repository, revision_id='rev-two')
+        target.fetch(tree.branch.repository, revision_id=b'rev-two')
         # The record should get expanded back to a fulltext
         target.lock_read()
         self.addCleanup(target.unlock)
@@ -407,15 +407,15 @@
             fname = 'file%03d' % (i,)
             fileid = '%s-%s' % (fname, osutils.rand_chars(64))
             to_add.append(('add', (fname, fileid, 'file', 'content\n')))
-        builder.build_snapshot(None, to_add, revision_id='A')
-        builder.build_snapshot(['A'], [], revision_id='B')
-        builder.build_snapshot(['A'], [], revision_id='C')
-        builder.build_snapshot(['C'], [], revision_id='D')
-        builder.build_snapshot(['D'], [], revision_id='E')
-        builder.build_snapshot(['E', 'B'], [], revision_id='F')
+        builder.build_snapshot(None, to_add, revision_id=b'A')
+        builder.build_snapshot(['A'], [], revision_id=b'B')
+        builder.build_snapshot(['A'], [], revision_id=b'C')
+        builder.build_snapshot(['C'], [], revision_id=b'D')
+        builder.build_snapshot(['D'], [], revision_id=b'E')
+        builder.build_snapshot(['E', 'B'], [], revision_id=b'F')
         builder.finish_series()
         source_branch = builder.get_branch()
-        source_branch.controldir.sprout('base', revision_id='B')
+        source_branch.controldir.sprout('base', revision_id=b'B')
         target_branch = self.make_branch('target', format='1.6')
         target_branch.set_stacked_on_url('../base')
         source = source_branch.repository
@@ -437,7 +437,7 @@
         target_branch.lock_write()
         self.addCleanup(target_branch.unlock)
         target = target_branch.repository
-        target.fetch(source, revision_id='F')
+        target.fetch(source, revision_id=b'F')
         # 'C' should be expanded to a fulltext, but D and E should still be
         # deltas
         stream = target.inventories.get_record_stream(

=== modified file 'breezy/tests/test_fetch_ghosts.py'
--- breezy/tests/test_fetch_ghosts.py	2018-02-18 15:21:06 +0000
+++ breezy/tests/test_fetch_ghosts.py	2018-06-21 08:27:55 +0000
@@ -25,7 +25,7 @@
     def prepare_with_ghosts(self):
         tree = self.make_branch_and_tree('.')
         tree.commit('rev1', rev_id=b'rev1-id')
-        tree.set_parent_ids(['rev1-id', 'ghost-id'])
+        tree.set_parent_ids([b'rev1-id', b'ghost-id'])
         tree.commit('rev2')
         return tree
 
@@ -33,11 +33,11 @@
         tree = self.prepare_with_ghosts()
         branch = self.make_branch('branch')
         GhostFetcher(tree.branch, branch).run()
-        self.assertFalse(tree.branch.repository.has_revision('ghost-id'))
+        self.assertFalse(tree.branch.repository.has_revision(b'ghost-id'))
 
     def test_fetch_ghosts_success(self):
         tree = self.prepare_with_ghosts()
         ghost_tree = self.make_branch_and_tree('ghost_tree')
         ghost_tree.commit('ghost', rev_id=b'ghost-id')
         GhostFetcher(tree.branch, ghost_tree.branch).run()
-        self.assertTrue(tree.branch.repository.has_revision('ghost-id'))
+        self.assertTrue(tree.branch.repository.has_revision(b'ghost-id'))

=== modified file 'breezy/tests/test_inv.py'
--- breezy/tests/test_inv.py	2018-05-13 02:18:13 +0000
+++ breezy/tests/test_inv.py	2018-06-21 08:27:55 +0000
@@ -251,11 +251,11 @@
     try:
         repo.start_write_group()
         try:
-            rev = revision.Revision('basis', timestamp=0, timezone=None,
+            rev = revision.Revision(b'basis', timestamp=0, timezone=None,
                 message="", committer="[e-mail]")
-            basis.revision_id = 'basis'
+            basis.revision_id = b'basis'
             create_texts_for_inv(repo, basis)
-            repo.add_revision('basis', rev, basis)
+            repo.add_revision(b'basis', rev, basis)
             repo.commit_write_group()
         except:
             repo.abort_write_group()
@@ -266,8 +266,8 @@
     try:
         repo.start_write_group()
         try:
-            inv_sha1 = repo.add_inventory_by_delta('basis', delta,
-                'result', ['basis'])
+            inv_sha1 = repo.add_inventory_by_delta(b'basis', delta,
+                b'result', [b'basis'])
         except:
             repo.abort_write_group()
             raise
@@ -279,7 +279,7 @@
     repo = repo.controldir.open_repository()
     repo.lock_read()
     self.addCleanup(repo.unlock)
-    return repo.get_inventory('result')
+    return repo.get_inventory(b'result')
 
 
 class TestInventoryUpdates(TestCase):

=== modified file 'breezy/tests/test_knit.py'
--- breezy/tests/test_knit.py	2018-06-14 10:06:05 +0000
+++ breezy/tests/test_knit.py	2018-06-21 08:27:55 +0000
@@ -419,7 +419,7 @@
             ], revision_id=b'rev-1')
         builder.build_snapshot([b'rev-1'], [
             ('modify', ('file', b'content\nrev 2\n')),
-            ], revision_id='rev-2')
+            ], revision_id=b'rev-2')
         builder.build_snapshot([b'rev-2'], [
             ('modify', ('file', b'content\nrev 3\n')),
             ], revision_id=b'rev-3')

=== modified file 'breezy/tests/test_log.py'
--- breezy/tests/test_log.py	2018-05-15 00:26:31 +0000
+++ breezy/tests/test_log.py	2018-06-21 08:27:55 +0000
@@ -1613,12 +1613,12 @@
         builder.start_series()
         builder.build_snapshot(None, [
             ('add', ('', 'TREE_ROOT', 'directory', '')),],
-            revision_id='1')
-        builder.build_snapshot(['1'], [], revision_id='1.1.1')
-        builder.build_snapshot(['1'], [], revision_id='2')
-        builder.build_snapshot(['1.1.1'], [], revision_id='1.2.1')
-        builder.build_snapshot(['1.1.1', '1.2.1'], [], revision_id='1.1.2')
-        builder.build_snapshot(['2', '1.1.2'], [], revision_id='3')
+            revision_id=b'1')
+        builder.build_snapshot(['1'], [], revision_id=b'1.1.1')
+        builder.build_snapshot(['1'], [], revision_id=b'2')
+        builder.build_snapshot(['1.1.1'], [], revision_id=b'1.2.1')
+        builder.build_snapshot(['1.1.1', '1.2.1'], [], revision_id=b'1.1.2')
+        builder.build_snapshot(['2', '1.1.2'], [], revision_id=b'3')
         builder.finish_series()
         br = builder.get_branch()
         br.lock_read()

=== modified file 'breezy/tests/test_matchers.py'
--- breezy/tests/test_matchers.py	2018-03-25 00:39:16 +0000
+++ breezy/tests/test_matchers.py	2018-06-21 08:27:55 +0000
@@ -72,10 +72,10 @@
 class TestMatchesAncestry(TestCaseWithTransport):
 
     def test__str__(self):
-        matcher = MatchesAncestry("A repository", "arevid")
+        matcher = MatchesAncestry("A repository", b"arevid")
         self.assertEqual(
             "MatchesAncestry(repository='A repository', "
-            "revision_id='arevid')",
+            "revision_id=%r)" % (b'arevid', ),
             str(matcher))
 
     def test_match(self):
@@ -90,8 +90,8 @@
         self.assertThat([revid1, revid2], m)
         m = MatchesAncestry(branch.repository, revid1)
         self.assertThat([revid1], m)
-        m = MatchesAncestry(branch.repository, "unknown")
-        self.assertThat(["unknown"], m)
+        m = MatchesAncestry(branch.repository, b"unknown")
+        self.assertThat([b"unknown"], m)
 
     def test_mismatch(self):
         b = self.make_branch_builder('.')
@@ -104,7 +104,7 @@
         mismatch = m.match([])
         self.assertIsNot(None, mismatch)
         self.assertEqual(
-            "mismatched ancestry for revision '%s' was ['%s'], expected []" % (
+            "mismatched ancestry for revision %r was [%r], expected []" % (
                 revid1, revid1),
             mismatch.describe())
 
@@ -112,8 +112,8 @@
 class TestHasLayout(TestCaseWithTransport):
 
     def test__str__(self):
-        matcher = HasLayout([("a", "a-id")])
-        self.assertEqual("HasLayout([('a', 'a-id')])", str(matcher))
+        matcher = HasLayout([(b"a", b"a-id")])
+        self.assertEqual("HasLayout(%r)" % ([(b'a', b'a-id')], ), str(matcher))
 
     def test_match(self):
         t = self.make_branch_and_tree('.')
@@ -156,7 +156,7 @@
     def test__str__(self):
         t = self.make_branch_and_tree('.')
         matcher = HasPathRelations(t, [("a", "b")])
-        self.assertEqual("HasPathRelations(%r, [('a', 'b')])" % t, str(matcher))
+        self.assertEqual("HasPathRelations(%r, %r)" % (t, [('a', 'b')]), str(matcher))
 
     def test_match(self):
         t = self.make_branch_and_tree('.')

=== modified file 'breezy/tests/test_merge.py'
--- breezy/tests/test_merge.py	2018-04-01 18:29:45 +0000
+++ breezy/tests/test_merge.py	2018-06-21 08:27:55 +0000
@@ -308,7 +308,7 @@
         tree_a.flush()
         tree_a.rename_one('a', 'b')
         tree_a.commit('2')
-        bzrdir_b = tree_a.controldir.sprout('B', revision_id='rev-1')
+        bzrdir_b = tree_a.controldir.sprout('B', revision_id=b'rev-1')
         tree_b = bzrdir_b.open_workingtree()
         tree_b.lock_write()
         self.addCleanup(tree_b.unlock)
@@ -1245,9 +1245,9 @@
         builder = self.get_builder()
         builder.build_snapshot(None,
             [('add', ('', None, 'directory', None))],
-            revision_id='A-id' )
-        builder.build_snapshot(['A-id'], [], revision_id='C-id')
-        builder.build_snapshot(['A-id'], [], revision_id='B-id')
+            revision_id=b'A-id' )
+        builder.build_snapshot(['A-id'], [], revision_id=b'C-id')
+        builder.build_snapshot(['A-id'], [], revision_id=b'B-id')
         return builder
 
     def setup_criss_cross_graph(self):
@@ -1261,8 +1261,8 @@
         # |X|
         # D E
         builder = self.setup_simple_graph()
-        builder.build_snapshot(['C-id', 'B-id'], [], revision_id='E-id')
-        builder.build_snapshot(['B-id', 'C-id'], [], revision_id='D-id')
+        builder.build_snapshot(['C-id', 'B-id'], [], revision_id=b'E-id')
+        builder.build_snapshot(['B-id', 'C-id'], [], revision_id=b'D-id')
         return builder
 
     def make_Merger(self, builder, other_revision_id, interesting_files=None):
@@ -1295,7 +1295,7 @@
     def test_cache_trees_with_revision_ids_having_revision_id(self):
         merger = self.make_Merger(self.setup_simple_graph(), 'C-id')
         original_cache = dict(merger._cached_trees)
-        tree = merger.this_branch.repository.revision_tree('B-id')
+        tree = merger.this_branch.repository.revision_tree(b'B-id')
         original_cache['B-id'] = tree
         merger.cache_trees_with_revision_ids([tree])
         self.assertEqual(original_cache, merger._cached_trees)
@@ -1314,7 +1314,7 @@
         self.assertEqual(['B-id', 'C-id'], [t.get_revision_id()
                                             for t in merger._lca_trees])
         # If we swap the order, we should get a different lca order
-        builder.build_snapshot(['E-id'], [], revision_id='F-id')
+        builder.build_snapshot(['E-id'], [], revision_id=b'F-id')
         merger = self.make_Merger(builder, 'D-id')
         self.assertEqual(['C-id', 'B-id'], [t.get_revision_id()
                                             for t in merger._lca_trees])
@@ -1330,9 +1330,9 @@
         #    \|   |/
         #     G   H
         builder = self.setup_criss_cross_graph()
-        builder.build_snapshot(['A-id'], [], revision_id='F-id')
-        builder.build_snapshot(['E-id', 'F-id'], [], revision_id='H-id')
-        builder.build_snapshot(['D-id', 'F-id'], [], revision_id='G-id')
+        builder.build_snapshot(['A-id'], [], revision_id=b'F-id')
+        builder.build_snapshot(['E-id', 'F-id'], [], revision_id=b'H-id')
+        builder.build_snapshot(['D-id', 'F-id'], [], revision_id=b'G-id')
         merger = self.make_Merger(builder, 'H-id')
         self.assertEqual(['B-id', 'C-id', 'F-id'],
                          [t.get_revision_id() for t in merger._lca_trees])
@@ -1346,12 +1346,12 @@
         builder = self.get_builder()
         builder.build_snapshot(None,
             [('add', ('', None, 'directory', None))],
-            revision_id='A-id')
+            revision_id=b'A-id')
         builder.build_snapshot([],
             [('add', ('', None, 'directory', None))],
-            revision_id='B-id')
-        builder.build_snapshot(['A-id', 'B-id'], [], revision_id='D-id')
-        builder.build_snapshot(['A-id', 'B-id'], [], revision_id='C-id')
+            revision_id=b'B-id')
+        builder.build_snapshot(['A-id', 'B-id'], [], revision_id=b'D-id')
+        builder.build_snapshot(['A-id', 'B-id'], [], revision_id=b'C-id')
         merger = self.make_Merger(builder, 'D-id')
         self.assertEqual('A-id', merger.base_rev_id)
         self.assertTrue(merger._is_criss_cross)
@@ -1407,19 +1407,19 @@
         builder.build_snapshot(None,
             [('add', (u'', 'a-root-id', 'directory', None)),
              ('add', (u'a', 'a-id', 'file', 'a\nb\nc\n'))],
-            revision_id='A-id')
+            revision_id=b'A-id')
         builder.build_snapshot(['A-id'],
             [('modify', ('a', 'a\nb\nC\nc\n'))],
-            revision_id='C-id')
+            revision_id=b'C-id')
         builder.build_snapshot(['A-id'],
             [('modify', ('a', 'a\nB\nb\nc\n'))],
-            revision_id='B-id')
+            revision_id=b'B-id')
         builder.build_snapshot(['C-id', 'B-id'],
             [('modify', ('a', 'a\nB\nb\nC\nc\nE\n'))],
-            revision_id='E-id')
+            revision_id=b'E-id')
         builder.build_snapshot(['B-id', 'C-id'],
             [('modify', ('a', 'a\nB\nb\nC\nc\n'))],
-            revision_id='D-id', )
+            revision_id=b'D-id', )
         merge_obj = self.make_merge_obj(builder, 'E-id')
 
         self.assertEqual(['B-id', 'C-id'], [t.get_revision_id()
@@ -1452,23 +1452,23 @@
         builder = self.get_builder()
         builder.build_snapshot(None,
             [('add', (u'', 'a-root-id', 'directory', None))],
-            revision_id='A-id')
+            revision_id=b'A-id')
         builder.build_snapshot(['A-id'],
             [('add', (u'foo', 'foo-id', 'file', 'a\nb\nc\n'))],
-            revision_id='B-id')
+            revision_id=b'B-id')
         builder.build_snapshot(['A-id'],
             [('add', (u'bar', 'bar-id', 'file', 'd\ne\nf\n'))],
-            revision_id='C-id')
+            revision_id=b'C-id')
         builder.build_snapshot(['B-id', 'C-id'],
             [('add', (u'bar', 'bar-id', 'file', 'd\ne\nf\n'))],
-            revision_id='D-id')
+            revision_id=b'D-id')
         builder.build_snapshot(['C-id', 'B-id'],
             [('add', (u'foo', 'foo-id', 'file', 'a\nb\nc\n'))],
-            revision_id='E-id')
+            revision_id=b'E-id')
         builder.build_snapshot(['E-id', 'D-id'],
             [('modify', (u'bar', 'd\ne\nf\nG\n'))],
-            revision_id='G-id')
-        builder.build_snapshot(['D-id', 'E-id'], [], revision_id='F-id')
+            revision_id=b'G-id')
+        builder.build_snapshot(['D-id', 'E-id'], [], revision_id=b'F-id')
         merge_obj = self.make_merge_obj(builder, 'G-id')
 
         self.assertEqual(['D-id', 'E-id'], [t.get_revision_id()
@@ -1488,19 +1488,19 @@
         builder.build_snapshot(None,
             [('add', (u'', 'a-root-id', 'directory', None)),
              ('add', (u'a', 'a-id', 'file', 'a\nb\nc\n'))],
-            revision_id='A-id')
+            revision_id=b'A-id')
         builder.build_snapshot(['A-id'],
             [('modify', ('a', 'a\nB\nb\nc\n'))],
-            revision_id='B-id')
+            revision_id=b'B-id')
         builder.build_snapshot(['A-id'],
             [('modify', ('a', 'a\nb\nC\nc\n'))],
-            revision_id='C-id')
+            revision_id=b'C-id')
         builder.build_snapshot(['C-id', 'B-id'],
             [('modify', ('a', 'a\nB\nb\nC\nc\nE\n'))],
-            revision_id='E-id')
+            revision_id=b'E-id')
         builder.build_snapshot(['B-id', 'C-id'],
             [('unversion', 'a')],
-            revision_id='D-id')
+            revision_id=b'D-id')
         merge_obj = self.make_merge_obj(builder, 'E-id')
 
         self.assertEqual(['B-id', 'C-id'], [t.get_revision_id()
@@ -1525,16 +1525,16 @@
         builder = self.get_builder()
         builder.build_snapshot(None,
             [('add', (u'', 'a-root-id', 'directory', None))],
-            revision_id='A-id')
-        builder.build_snapshot(['A-id'], [], revision_id='B-id')
+            revision_id=b'A-id')
+        builder.build_snapshot(['A-id'], [], revision_id=b'B-id')
         builder.build_snapshot(['A-id'],
             [('add', (u'a', 'a-id', 'file', 'a\nb\nc\n'))],
-            revision_id='C-id')
+            revision_id=b'C-id')
         builder.build_snapshot(['C-id', 'B-id'],
-                               [], revision_id='E-id') # Inherited from C
+                               [], revision_id=b'E-id') # Inherited from C
         builder.build_snapshot(['B-id', 'C-id'], # Merged from C
             [('add', (u'a', 'a-id', 'file', 'a\nb\nc\n'))],
-            revision_id='D-id')
+            revision_id=b'D-id')
         merge_obj = self.make_merge_obj(builder, 'E-id')
 
         self.assertEqual(['B-id', 'C-id'], [t.get_revision_id()
@@ -1549,13 +1549,13 @@
         builder.build_snapshot(None,
             [('add', (u'', 'a-root-id', 'directory', None)),
              ('add', (u'a', 'a-id', 'file', 'a\nb\nc\n'))],
-            revision_id='A-id')
-        builder.build_snapshot(['A-id'], [], revision_id='B-id')
-        builder.build_snapshot(['A-id'], [], revision_id='C-id')
+            revision_id=b'A-id')
+        builder.build_snapshot(['A-id'], [], revision_id=b'B-id')
+        builder.build_snapshot(['A-id'], [], revision_id=b'C-id')
         builder.build_snapshot(
                 ['C-id', 'B-id'],
-                [('unversion', 'a')], revision_id='E-id')
-        builder.build_snapshot(['B-id', 'C-id'], [], revision_id='D-id')
+                [('unversion', 'a')], revision_id=b'E-id')
+        builder.build_snapshot(['B-id', 'C-id'], [], revision_id=b'D-id')
         merge_obj = self.make_merge_obj(builder, 'E-id')
 
         entries = list(merge_obj._entries_lca())
@@ -1583,12 +1583,12 @@
         builder.build_snapshot(None,
             [('add', (u'', 'a-root-id', 'directory', None)),
              ('add', (u'foo', 'foo-id', 'file', 'content\n'))],
-            revision_id='A-id')
-        builder.build_snapshot(['A-id'], [], revision_id='B-id')
+            revision_id=b'A-id')
+        builder.build_snapshot(['A-id'], [], revision_id=b'B-id')
         builder.build_snapshot(['A-id'],
-            [('unversion', 'foo')], revision_id='C-id')
-        builder.build_snapshot(['C-id', 'B-id'], [], revision_id='E-id')
-        builder.build_snapshot(['B-id', 'C-id'], [], revision_id='D-id')
+            [('unversion', 'foo')], revision_id=b'C-id')
+        builder.build_snapshot(['C-id', 'B-id'], [], revision_id=b'E-id')
+        builder.build_snapshot(['B-id', 'C-id'], [], revision_id=b'D-id')
         merge_obj = self.make_merge_obj(builder, 'E-id')
 
         entries = list(merge_obj._entries_lca())
@@ -1613,15 +1613,15 @@
         builder.build_snapshot(None,
             [('add', (u'', 'a-root-id', 'directory', None)),
              ('add', (u'foo', 'foo-id', 'file', 'content\n'))],
-            revision_id='A-id')
+            revision_id=b'A-id')
         builder.build_snapshot(['A-id'], [
             ('modify', ('foo', 'new-content\n'))],
-            revision_id='B-id')
+            revision_id=b'B-id')
         builder.build_snapshot(['A-id'],
             [('unversion', 'foo')],
-            revision_id='C-id')
-        builder.build_snapshot(['C-id', 'B-id'], [], revision_id='E-id')
-        builder.build_snapshot(['B-id', 'C-id'], [], revision_id='D-id')
+            revision_id=b'C-id')
+        builder.build_snapshot(['C-id', 'B-id'], [], revision_id=b'E-id')
+        builder.build_snapshot(['B-id', 'C-id'], [], revision_id=b'D-id')
         merge_obj = self.make_merge_obj(builder, 'E-id')
 
         entries = list(merge_obj._entries_lca())
@@ -1652,15 +1652,15 @@
         builder = self.get_builder()
         builder.build_snapshot(None,
             [('add', (u'', 'a-root-id', 'directory', None))],
-            revision_id='A-id')
-        builder.build_snapshot(['A-id'], [], revision_id='B-id')
+            revision_id=b'A-id')
+        builder.build_snapshot(['A-id'], [], revision_id=b'B-id')
         builder.build_snapshot(['A-id'],
             [('add', (u'a', 'a-id', 'file', 'a\nb\nc\n'))],
-            revision_id='C-id')
+            revision_id=b'C-id')
         builder.build_snapshot(['C-id', 'B-id'],
             [('unversion', 'a')],
-            revision_id='E-id')
-        builder.build_snapshot(['B-id', 'C-id'], [], revision_id='D-id')
+            revision_id=b'E-id')
+        builder.build_snapshot(['B-id', 'C-id'], [], revision_id=b'D-id')
         merge_obj = self.make_merge_obj(builder, 'E-id')
 
         entries = list(merge_obj._entries_lca())
@@ -1670,13 +1670,13 @@
         builder = self.get_builder()
         builder.build_snapshot(None,
             [('add', (u'', 'a-root-id', 'directory', None))],
-            revision_id='A-id')
-        builder.build_snapshot(['A-id'], [], revision_id='B-id')
-        builder.build_snapshot(['A-id'], [], revision_id='C-id')
+            revision_id=b'A-id')
+        builder.build_snapshot(['A-id'], [], revision_id=b'B-id')
+        builder.build_snapshot(['A-id'], [], revision_id=b'C-id')
         builder.build_snapshot(['C-id', 'B-id'],
             [('add', (u'a', 'a-id', 'file', 'a\nb\nc\n'))],
-            revision_id='E-id')
-        builder.build_snapshot(['B-id', 'C-id'], [], revision_id='D-id')
+            revision_id=b'E-id')
+        builder.build_snapshot(['B-id', 'C-id'], [], revision_id=b'D-id')
         merge_obj = self.make_merge_obj(builder, 'E-id')
 
         entries = list(merge_obj._entries_lca())
@@ -1706,19 +1706,19 @@
         builder.build_snapshot(None,
             [('add', (u'', 'a-root-id', 'directory', None)),
              ('add', (u'foo', 'foo-id', 'file', 'A content\n'))],
-            revision_id='A-id')
-        builder.build_snapshot(['A-id'], [], revision_id='C-id')
+            revision_id=b'A-id')
+        builder.build_snapshot(['A-id'], [], revision_id=b'C-id')
         builder.build_snapshot(['A-id'],
             [('modify', ('foo', 'B content\n'))],
-            revision_id='B-id')
-        builder.build_snapshot(['B-id', 'C-id'], [], revision_id='D-id')
+            revision_id=b'B-id')
+        builder.build_snapshot(['B-id', 'C-id'], [], revision_id=b'D-id')
         builder.build_snapshot(['C-id', 'B-id'],
             [('modify', ('foo', 'E content\n'))],
-            revision_id='E-id')
-        builder.build_snapshot(['E-id', 'D-id'], [], revision_id='G-id')
+            revision_id=b'E-id')
+        builder.build_snapshot(['E-id', 'D-id'], [], revision_id=b'G-id')
         builder.build_snapshot(['D-id', 'E-id'],
             [('modify', ('foo', 'F content\n'))],
-            revision_id='F-id')
+            revision_id=b'F-id')
         merge_obj = self.make_merge_obj(builder, 'G-id')
 
         self.assertEqual([], list(merge_obj._entries_lca()))
@@ -1756,21 +1756,21 @@
         builder.build_snapshot(None,
             [('add', (u'', 'a-root-id', 'directory', None)),
              ('add', (u'foo', 'foo-id', 'file', 'A content\n'))],
-            revision_id='A-id')
-        builder.build_snapshot(['A-id'], [], revision_id='C-id')
+            revision_id=b'A-id')
+        builder.build_snapshot(['A-id'], [], revision_id=b'C-id')
         builder.build_snapshot(['A-id'],
             [('rename', ('foo', 'bar'))],
-            revision_id='B-id')
-        builder.build_snapshot(['B-id', 'C-id'], [], revision_id='D-id')
+            revision_id=b'B-id')
+        builder.build_snapshot(['B-id', 'C-id'], [], revision_id=b'D-id')
         builder.build_snapshot(['C-id', 'B-id'],
             [('rename', ('foo', 'bing'))],
-            revision_id='E-id') # override to bing
+            revision_id=b'E-id') # override to bing
         builder.build_snapshot(['E-id', 'D-id'],
             [('rename', ('bing', 'barry'))],
-            revision_id='G-id') # override to barry
+            revision_id=b'G-id') # override to barry
         builder.build_snapshot(['D-id', 'E-id'],
             [('rename', ('bar', 'bing'))],
-            revision_id='F-id') # Merge in E's change
+            revision_id=b'F-id') # Merge in E's change
         merge_obj = self.make_merge_obj(builder, 'G-id')
 
         self.expectFailure("We don't do an actual heads() check on lca values,"
@@ -1794,19 +1794,19 @@
         builder.build_snapshot(None,
             [('add', (u'', 'a-root-id', 'directory', None)),
              ('add', (u'foo', 'foo-id', 'file', 'A content\n'))],
-            revision_id='A-id')
-        builder.build_snapshot(['A-id'], [], revision_id='C-id')
+            revision_id=b'A-id')
+        builder.build_snapshot(['A-id'], [], revision_id=b'C-id')
         builder.build_snapshot(['A-id'],
             [('rename', ('foo', 'bar'))],
-            revision_id='B-id')
-        builder.build_snapshot(['B-id', 'C-id'], [], revision_id='D-id')
-        builder.build_snapshot(['C-id', 'B-id'], [], revision_id='E-id')
+            revision_id=b'B-id')
+        builder.build_snapshot(['B-id', 'C-id'], [], revision_id=b'D-id')
+        builder.build_snapshot(['C-id', 'B-id'], [], revision_id=b'E-id')
         builder.build_snapshot(['E-id', 'D-id'],
             [('rename', ('foo', 'bar'))],
-            revision_id='G-id')
+            revision_id=b'G-id')
         builder.build_snapshot(['D-id', 'E-id'],
             [('rename', ('bar', 'bing'))],
-            revision_id='F-id') # should end up conflicting
+            revision_id=b'F-id') # should end up conflicting
         merge_obj = self.make_merge_obj(builder, 'G-id')
 
         entries = list(merge_obj._entries_lca())
@@ -1831,15 +1831,15 @@
         builder.build_snapshot(None,
             [('add', (u'', 'a-root-id', 'directory', None)),
              ('add', (u'foo', 'foo-id', 'file', 'A content\n'))],
-            revision_id='A-id')
+            revision_id=b'A-id')
         builder.build_snapshot(['A-id'],
             [('modify', ('foo', 'B content\n'))],
-            revision_id='B-id')
+            revision_id=b'B-id')
         builder.build_snapshot(['A-id'],
             [('modify', ('foo', 'C content\n'))],
-            revision_id='C-id')
-        builder.build_snapshot(['C-id', 'B-id'], [], revision_id='E-id')
-        builder.build_snapshot(['B-id', 'C-id'], [], revision_id='D-id')
+            revision_id=b'C-id')
+        builder.build_snapshot(['C-id', 'B-id'], [], revision_id=b'E-id')
+        builder.build_snapshot(['B-id', 'C-id'], [], revision_id=b'D-id')
         merge_obj = self.make_merge_obj(builder, 'E-id')
 
         entries = list(merge_obj._entries_lca())
@@ -1866,18 +1866,18 @@
         builder.build_snapshot(None,
             [('add', (u'', 'a-root-id', 'directory', None)),
              ('add', (u'foo', 'foo-id', 'file', 'A content\n'))],
-            revision_id='A-id')
+            revision_id=b'A-id')
         builder.build_snapshot(['A-id'],
             [('modify', ('foo', 'B content\n'))],
-            revision_id='B-id')
+            revision_id=b'B-id')
         builder.build_snapshot(['A-id'],
             [('modify', ('foo', 'C content\n'))],
-            revision_id='C-id', )
-        builder.build_snapshot(['C-id', 'B-id'], [], revision_id='E-id')
-        builder.build_snapshot(['B-id', 'C-id'], [], revision_id='D-id')
+            revision_id=b'C-id', )
+        builder.build_snapshot(['C-id', 'B-id'], [], revision_id=b'E-id')
+        builder.build_snapshot(['B-id', 'C-id'], [], revision_id=b'D-id')
         builder.build_snapshot(['D-id'],
             [('modify', ('foo', 'F content\n'))],
-            revision_id='F-id')
+            revision_id=b'F-id')
         merge_obj = self.make_merge_obj(builder, 'E-id')
 
         entries = list(merge_obj._entries_lca())
@@ -1907,20 +1907,20 @@
         builder.build_snapshot(None,
             [('add', (u'', 'a-root-id', 'directory', None)),
              ('add', (u'foo', 'foo-id', 'file', 'A content\n'))],
-            revision_id='A-id')
+            revision_id=b'A-id')
         builder.build_snapshot(['A-id'],
             [('modify', ('foo', 'B content\n'))],
-            revision_id='B-id')
+            revision_id=b'B-id')
         builder.build_snapshot(['A-id'],
             [('modify', ('foo', 'C content\n'))],
-            revision_id='C-id')
-        builder.build_snapshot(['C-id', 'B-id'], [], revision_id='E-id')
+            revision_id=b'C-id')
+        builder.build_snapshot(['C-id', 'B-id'], [], revision_id=b'E-id')
         builder.build_snapshot(['B-id', 'C-id'],
             [('modify', ('foo', 'C content\n'))],
-            revision_id='D-id') # Same as E
+            revision_id=b'D-id') # Same as E
         builder.build_snapshot(['D-id'],
             [('modify', ('foo', 'F content\n'))],
-            revision_id='F-id')
+            revision_id=b'F-id')
         merge_obj = self.make_merge_obj(builder, 'E-id')
 
         entries = list(merge_obj._entries_lca())
@@ -1933,13 +1933,13 @@
         builder.build_snapshot(None,
             [('add', (u'', 'a-root-id', 'directory', None)),
              ('add', (u'a', 'a-id', 'file', 'content\n'))],
-            revision_id='A-id')
-        builder.build_snapshot(['A-id'], [], revision_id='B-id')
-        builder.build_snapshot(['A-id'], [], revision_id='C-id')
+            revision_id=b'A-id')
+        builder.build_snapshot(['A-id'], [], revision_id=b'B-id')
+        builder.build_snapshot(['A-id'], [], revision_id=b'C-id')
         builder.build_snapshot(['C-id', 'B-id'],
             [('rename', (u'a', u'b'))],
-            revision_id='E-id')
-        builder.build_snapshot(['B-id', 'C-id'], [], revision_id='D-id')
+            revision_id=b'E-id')
+        builder.build_snapshot(['B-id', 'C-id'], [], revision_id=b'D-id')
         merge_obj = self.make_merge_obj(builder, 'E-id')
         entries = list(merge_obj._entries_lca())
         root_id = 'a-root-id'
@@ -1957,15 +1957,15 @@
         builder.build_snapshot(None,
             [('add', (u'', 'a-root-id', 'directory', None)),
              ('add', (u'a', 'a-id', 'file', 'content\n'))],
-            revision_id='A-id')
-        builder.build_snapshot(['A-id'], [], revision_id='B-id')
-        builder.build_snapshot(['A-id'], [], revision_id='C-id')
+            revision_id=b'A-id')
+        builder.build_snapshot(['A-id'], [], revision_id=b'B-id')
+        builder.build_snapshot(['A-id'], [], revision_id=b'C-id')
         builder.build_snapshot(['C-id', 'B-id'],
             [('unversion', 'a'),
              ('flush', None),
              ('add', (u'a', 'a-id', 'directory', None))],
-            revision_id='E-id')
-        builder.build_snapshot(['B-id', 'C-id'], [], revision_id='D-id')
+            revision_id=b'E-id')
+        builder.build_snapshot(['B-id', 'C-id'], [], revision_id=b'D-id')
         merge_obj = self.make_merge_obj(builder, 'E-id')
         entries = list(merge_obj._entries_lca())
         root_id = 'a-root-id'
@@ -1983,15 +1983,15 @@
         builder.build_snapshot(None,
             [('add', (u'', 'a-root-id', 'directory', None)),
              ('add', (u'a', 'a-id', 'file', 'content\n'))],
-            revision_id='A-id')
-        builder.build_snapshot(['A-id'], [], revision_id='B-id')
-        builder.build_snapshot(['A-id'], [], revision_id='C-id')
-        builder.build_snapshot(['C-id', 'B-id'], [], revision_id='E-id')
+            revision_id=b'A-id')
+        builder.build_snapshot(['A-id'], [], revision_id=b'B-id')
+        builder.build_snapshot(['A-id'], [], revision_id=b'C-id')
+        builder.build_snapshot(['C-id', 'B-id'], [], revision_id=b'E-id')
         builder.build_snapshot(['B-id', 'C-id'],
             [('unversion', 'a'),
              ('flush', None),
              ('add', (u'a', 'a-id', 'directory', None))],
-            revision_id='D-id')
+            revision_id=b'D-id')
         merge_obj = self.make_merge_obj(builder, 'E-id')
         entries = list(merge_obj._entries_lca())
         # Only the kind was changed (content)
@@ -2004,14 +2004,14 @@
             [('add', (u'', 'a-root-id', 'directory', None)),
              ('add', (u'a', 'a-id', 'file', 'content\n')),
              ('add', (u'b', 'b-id', 'file', 'content\n'))],
-            revision_id='A-id')
-        builder.build_snapshot(['A-id'], [], revision_id='B-id')
-        builder.build_snapshot(['A-id'], [], revision_id='C-id')
+            revision_id=b'A-id')
+        builder.build_snapshot(['A-id'], [], revision_id=b'B-id')
+        builder.build_snapshot(['A-id'], [], revision_id=b'C-id')
         builder.build_snapshot(['C-id', 'B-id'],
             [('modify', ('a', 'new-content\n')),
              ('modify', ('b', 'new-content\n'))],
-            revision_id='E-id')
-        builder.build_snapshot(['B-id', 'C-id'], [], revision_id='D-id')
+            revision_id=b'E-id')
+        builder.build_snapshot(['B-id', 'C-id'], [], revision_id=b'D-id')
         merge_obj = self.make_merge_obj(builder, 'E-id',
                                         interesting_files=['b'])
         entries = list(merge_obj._entries_lca())
@@ -2030,16 +2030,16 @@
             [('add', (u'', 'a-root-id', 'directory', None)),
              ('add', (u'a', 'a-id', 'file', 'content\n')),
              ('add', (u'b', 'b-id', 'file', 'content\n'))],
-            revision_id='A-id')
-        builder.build_snapshot(['A-id'], [], revision_id='B-id')
-        builder.build_snapshot(['A-id'], [], revision_id='C-id')
+            revision_id=b'A-id')
+        builder.build_snapshot(['A-id'], [], revision_id=b'B-id')
+        builder.build_snapshot(['A-id'], [], revision_id=b'C-id')
         builder.build_snapshot(['C-id', 'B-id'],
             [('modify', ('a', 'new-content\n')),
              ('modify', ('b', 'new-content\n'))],
-            revision_id='E-id')
+            revision_id=b'E-id')
         builder.build_snapshot(['B-id', 'C-id'],
             [('rename', ('b', 'c'))],
-            revision_id='D-id')
+            revision_id=b'D-id')
         merge_obj = self.make_merge_obj(builder, 'E-id',
                                         interesting_files=['c'])
         entries = list(merge_obj._entries_lca())
@@ -2058,18 +2058,18 @@
             [('add', (u'', 'a-root-id', 'directory', None)),
              ('add', (u'a', 'a-id', 'file', 'content\n')),
              ('add', (u'c', 'c-id', 'file', 'content\n'))],
-            revision_id='A-id')
-        builder.build_snapshot(['A-id'],
-            [('rename', ('c', 'b'))],
-            revision_id='B-id')
-        builder.build_snapshot(['A-id'],
-            [('rename', ('c', 'b'))],
-            revision_id='C-id')
+            revision_id=b'A-id')
+        builder.build_snapshot(['A-id'],
+            [('rename', ('c', 'b'))],
+            revision_id=b'B-id')
+        builder.build_snapshot(['A-id'],
+            [('rename', ('c', 'b'))],
+            revision_id=b'C-id')
         builder.build_snapshot(['C-id', 'B-id'],
             [('modify', ('a', 'new-content\n')),
              ('modify', ('b', 'new-content\n'))],
-            revision_id='E-id')
-        builder.build_snapshot(['B-id', 'C-id'], [], revision_id='D-id')
+            revision_id=b'E-id')
+        builder.build_snapshot(['B-id', 'C-id'], [], revision_id=b'D-id')
         merge_obj = self.make_merge_obj(builder, 'E-id',
                                         interesting_files=['c'])
         entries = list(merge_obj._entries_lca())
@@ -2088,16 +2088,16 @@
             [('add', (u'', 'a-root-id', 'directory', None)),
              ('add', (u'a', 'a-id', 'file', 'content\n')),
              ('add', (u'b', 'b-id', 'file', 'content\n'))],
-            revision_id='A-id')
+            revision_id=b'A-id')
         builder.build_snapshot(['A-id'],
-            [('rename', ('b', 'c'))], revision_id='B-id')
-        builder.build_snapshot(['A-id'], [], revision_id='C-id')
+            [('rename', ('b', 'c'))], revision_id=b'B-id')
+        builder.build_snapshot(['A-id'], [], revision_id=b'C-id')
         builder.build_snapshot(['C-id', 'B-id'],
             [('modify', ('a', 'new-content\n')),
              ('modify', ('b', 'new-content\n'))],
-            revision_id='E-id')
+            revision_id=b'E-id')
         builder.build_snapshot(['B-id', 'C-id'],
-            [('rename', ('c', 'b'))], revision_id='D-id')
+            [('rename', ('c', 'b'))], revision_id=b'D-id')
         merge_obj = self.make_merge_obj(builder, 'E-id',
                                         interesting_files=['c'])
         entries = list(merge_obj._entries_lca())
@@ -2116,13 +2116,13 @@
             [('add', (u'', 'a-root-id', 'directory', None)),
              ('add', (u'a', 'a-id', 'file', 'content\n')),
              ('add', (u'b', 'b-id', 'file', 'content\n'))],
-            revision_id='A-id')
-        builder.build_snapshot(['A-id'], [], revision_id='B-id')
-        builder.build_snapshot(['A-id'], [], revision_id='C-id')
+            revision_id=b'A-id')
+        builder.build_snapshot(['A-id'], [], revision_id=b'B-id')
+        builder.build_snapshot(['A-id'], [], revision_id=b'C-id')
         builder.build_snapshot(['C-id', 'B-id'],
             [('modify', ('a', 'new-content\n')),
-             ('modify', ('b', 'new-content\n'))], revision_id='E-id')
-        builder.build_snapshot(['B-id', 'C-id'], [], revision_id='D-id')
+             ('modify', ('b', 'new-content\n'))], revision_id=b'E-id')
+        builder.build_snapshot(['B-id', 'C-id'], [], revision_id=b'D-id')
         merge_obj = self.make_merge_obj(builder, 'E-id',
                                         interesting_files=['b'])
         entries = list(merge_obj._entries_lca())
@@ -2169,13 +2169,13 @@
         builder.build_snapshot(None,
             [('add', (u'', 'a-root-id', 'directory', None)),
              ('add', (u'a', 'a-id', 'file', 'a\nb\nc\n'))],
-            revision_id='A-id')
-        builder.build_snapshot(['A-id'], [], revision_id='C-id')
-        builder.build_snapshot(['A-id'], [], revision_id='B-id')
-        builder.build_snapshot(['C-id', 'B-id'], [], revision_id='E-id')
+            revision_id=b'A-id')
+        builder.build_snapshot(['A-id'], [], revision_id=b'C-id')
+        builder.build_snapshot(['A-id'], [], revision_id=b'B-id')
+        builder.build_snapshot(['C-id', 'B-id'], [], revision_id=b'E-id')
         builder.build_snapshot(['B-id', 'C-id'],
             [('modify', ('a', 'a\nb\nc\nd\ne\nf\n'))],
-            revision_id='D-id')
+            revision_id=b'D-id')
         wt, conflicts = self.do_merge(builder, 'E-id')
         self.assertEqual(0, conflicts)
         # The merge should have simply update the contents of 'a'
@@ -2197,15 +2197,15 @@
         builder.build_snapshot(None,
             [('add', (u'', 'a-root-id', 'directory', None)),
              ('add', (u'foo', 'foo-id', 'file', 'a\nb\nc\n'))],
-            revision_id='A-id')
-        builder.build_snapshot(['A-id'], [], revision_id='C-id')
+            revision_id=b'A-id')
+        builder.build_snapshot(['A-id'], [], revision_id=b'C-id')
         builder.build_snapshot(['A-id'],
-            [('rename', ('foo', 'bar'))], revision_id='B-id', )
+            [('rename', ('foo', 'bar'))], revision_id=b'B-id', )
         builder.build_snapshot(['C-id', 'B-id'], # merge the rename
-            [('rename', ('foo', 'bar'))], revision_id='E-id')
+            [('rename', ('foo', 'bar'))], revision_id=b'E-id')
         builder.build_snapshot(['E-id'],
-            [('rename', ('bar', 'baz'))], revision_id='F-id')
-        builder.build_snapshot(['B-id', 'C-id'], [], revision_id='D-id')
+            [('rename', ('bar', 'baz'))], revision_id=b'F-id')
+        builder.build_snapshot(['B-id', 'C-id'], [], revision_id=b'D-id')
         wt, conflicts = self.do_merge(builder, 'F-id')
         self.assertEqual(0, conflicts)
         # The merge should simply recognize that the final rename takes
@@ -2228,15 +2228,15 @@
         builder.build_snapshot(None,
             [('add', (u'', 'a-root-id', 'directory', None)),
              ('add', (u'foo', 'foo-id', 'file', 'a\nb\nc\n'))],
-            revision_id='A-id')
-        builder.build_snapshot(['A-id'], [], revision_id='C-id')
+            revision_id=b'A-id')
+        builder.build_snapshot(['A-id'], [], revision_id=b'C-id')
         builder.build_snapshot(['A-id'],
-            [('rename', ('foo', 'bar'))], revision_id='B-id')
+            [('rename', ('foo', 'bar'))], revision_id=b'B-id')
         builder.build_snapshot(['C-id', 'B-id'], # merge the rename
-            [('rename', ('foo', 'bar'))], revision_id='E-id')
+            [('rename', ('foo', 'bar'))], revision_id=b'E-id')
         builder.build_snapshot(['E-id'],
-            [('unversion', 'bar')], revision_id='F-id')
-        builder.build_snapshot(['B-id', 'C-id'], [], revision_id='D-id')
+            [('unversion', 'bar')], revision_id=b'F-id')
+        builder.build_snapshot(['B-id', 'C-id'], [], revision_id=b'D-id')
         wt, conflicts = self.do_merge(builder, 'F-id')
         self.assertEqual(0, conflicts)
         self.assertRaises(errors.NoSuchId, wt.id2path, 'foo-id')
@@ -2255,11 +2255,11 @@
         builder.build_snapshot(None,
             [('add', (u'', 'a-root-id', 'directory', None)),
              ('add', (u'foo', 'foo-id', 'file', 'a\nb\nc\n'))],
-            revision_id='A-id')
-        builder.build_snapshot(['A-id'], [], revision_id='C-id')
-        builder.build_snapshot(['A-id'], [], revision_id='B-id')
-        builder.build_snapshot(['B-id', 'C-id'], [], revision_id='D-id')
-        builder.build_snapshot(['C-id', 'B-id'], [], revision_id='E-id')
+            revision_id=b'A-id')
+        builder.build_snapshot(['A-id'], [], revision_id=b'C-id')
+        builder.build_snapshot(['A-id'], [], revision_id=b'B-id')
+        builder.build_snapshot(['B-id', 'C-id'], [], revision_id=b'D-id')
+        builder.build_snapshot(['C-id', 'B-id'], [], revision_id=b'E-id')
         # Have to use a real WT, because BranchBuilder doesn't support exec bit
         wt = self.get_wt_from_builder(builder)
         tt = transform.TreeTransform(wt)
@@ -2296,11 +2296,11 @@
         builder = self.get_builder()
         builder.build_snapshot(None,
             [('add', (u'', 'a-root-id', 'directory', None))],
-            revision_id='A-id')
-        builder.build_snapshot(['A-id'], [], revision_id='C-id')
-        builder.build_snapshot(['A-id'], [], revision_id='B-id')
-        builder.build_snapshot(['B-id', 'C-id'], [], revision_id='D-id')
-        builder.build_snapshot(['C-id', 'B-id'], [], revision_id='E-id')
+            revision_id=b'A-id')
+        builder.build_snapshot(['A-id'], [], revision_id=b'C-id')
+        builder.build_snapshot(['A-id'], [], revision_id=b'B-id')
+        builder.build_snapshot(['B-id', 'C-id'], [], revision_id=b'D-id')
+        builder.build_snapshot(['C-id', 'B-id'], [], revision_id=b'E-id')
         # Have to use a real WT, because BranchBuilder doesn't support exec bit
         wt = self.get_wt_from_builder(builder)
         os.symlink('bar', 'path/foo')
@@ -2331,17 +2331,17 @@
         builder.build_snapshot(None,
             [('add', (u'', 'a-root-id', 'directory', None)),
              ('add', (u'foo', 'foo-id', 'file', 'A content\n'))],
-            revision_id='A-id')
+            revision_id=b'A-id')
         builder.build_snapshot(['A-id'],
             [('modify', ('foo', 'B content\n'))],
-            revision_id='B-id')
+            revision_id=b'B-id')
         builder.build_snapshot(['A-id'],
             [('modify', ('foo', 'C content\n'))],
-            revision_id='C-id')
+            revision_id=b'C-id')
         builder.build_snapshot(['C-id', 'B-id'], [],
-                revision_id='E-id')
+                revision_id=b'E-id')
         builder.build_snapshot(['B-id', 'C-id'], [],
-                revision_id='D-id')
+                revision_id=b'D-id')
         wt, conflicts = self.do_merge(builder, 'E-id')
         self.assertEqual(1, conflicts)
         self.assertEqualDiff('<<<<<<< TREE\n'
@@ -2703,19 +2703,19 @@
             [('add', (u'', 'a-root-id', 'directory', None)),
              ('add', (u'a', 'a-id', 'file', 'base content\n')),
              ('add', (u'foo', 'foo-id', 'file', 'base content\n'))],
-            revision_id='A-id')
+            revision_id=b'A-id')
         builder.build_snapshot(['A-id'],
             [('modify', ('foo', 'B content\n'))],
-            revision_id='B-id')
+            revision_id=b'B-id')
         builder.build_snapshot(['A-id'],
             [('rename', ('a', 'b'))],
-            revision_id='C-id')
+            revision_id=b'C-id')
         builder.build_snapshot(['C-id', 'B-id'],
             [('rename', ('b', 'c')),
              ('modify', ('foo', 'E content\n'))],
-            revision_id='E-id')
+            revision_id=b'E-id')
         builder.build_snapshot(['B-id', 'C-id'],
-            [('rename', ('a', 'b'))], revision_id='D-id') # merged change
+            [('rename', ('a', 'b'))], revision_id=b'D-id') # merged change
         wt_this = self.get_wt_from_builder(builder)
         wt_base = wt_this.controldir.sprout('base', 'A-id').open_workingtree()
         wt_base.lock_read()

=== modified file 'breezy/tests/test_merge_core.py'
--- breezy/tests/test_merge_core.py	2018-03-26 00:54:10 +0000
+++ breezy/tests/test_merge_core.py	2018-06-21 08:27:55 +0000
@@ -526,17 +526,17 @@
         # attributes like 'executable' in A.
         builder.build_snapshot(None, [
             ('add', ('', 'TREE_ROOT', 'directory', None))],
-            revision_id='A-id')
-        builder.build_snapshot(['A-id'], [], revision_id='B-id')
+            revision_id=b'A-id')
+        builder.build_snapshot(['A-id'], [], revision_id=b'B-id')
         builder.build_snapshot(['A-id'], [
             ('add', ('foo', 'foo-id', 'file', 'orig\ncontents\n'))],
-            revision_id='C-id')
+            revision_id=b'C-id')
         builder.build_snapshot(['B-id', 'C-id'], [
             ('add', ('foo', 'foo-id', 'file', 'orig\ncontents\nand D\n'))],
-            revision_id='D-id')
+            revision_id=b'D-id')
         builder.build_snapshot(['C-id', 'B-id'], [
             ('modify', ('foo', 'orig\ncontents\nand E\n'))],
-            revision_id='E-id')
+            revision_id=b'E-id')
         builder.finish_series()
         tree = builder.get_branch().create_checkout('tree', lightweight=True)
         self.assertEqual(1, tree.merge_from_branch(tree.branch,

=== modified file 'breezy/tests/test_merge_directive.py'
--- breezy/tests/test_merge_directive.py	2018-02-18 15:21:06 +0000
+++ breezy/tests/test_merge_directive.py	2018-06-21 08:27:55 +0000
@@ -278,7 +278,7 @@
 
     def make_merge_directive(self, revision_id, testament_sha1, time, timezone,
                  target_branch, patch=None, patch_type=None,
-                 source_branch=None, message=None, base_revision_id='null:'):
+                 source_branch=None, message=None, base_revision_id=b'null:'):
         if patch_type == 'bundle':
             bundle = patch
             patch = None
@@ -639,7 +639,7 @@
 
     def make_merge_directive(self, revision_id, testament_sha1, time, timezone,
                  target_branch, patch=None, patch_type=None,
-                 source_branch=None, message=None, base_revision_id='null:'):
+                 source_branch=None, message=None, base_revision_id=b'null:'):
         if patch_type == 'bundle':
             bundle = patch
             patch = None
@@ -657,7 +657,7 @@
         self.assertEqual(b'rev1', md.base_revision_id)
         md = self.from_objects(tree_a.branch.repository, b'rev2a', 500, 60,
             tree_b.branch.base, patch_type='bundle',
-            public_branch=tree_a.branch.base, base_revision_id='null:')
+            public_branch=tree_a.branch.base, base_revision_id=b'null:')
         self.assertEqual('null:', md.base_revision_id)
         lines = md.to_lines()
         md2 = merge_directive.MergeDirective.from_lines(lines)

=== modified file 'breezy/tests/test_reconfigure.py'
--- breezy/tests/test_reconfigure.py	2018-05-13 02:18:13 +0000
+++ breezy/tests/test_reconfigure.py	2018-06-21 08:27:55 +0000
@@ -92,9 +92,9 @@
         checkout_branch = checkout.controldir.open_branch()
         self.assertEqual(checkout_branch.controldir.root_transport.base,
                          checkout.controldir.root_transport.base)
-        self.assertEqual('rev1', checkout_branch.last_revision())
+        self.assertEqual(b'rev1', checkout_branch.last_revision())
         repo = checkout.controldir.open_repository()
-        repo.get_revision('rev1')
+        repo.get_revision(b'rev1')
 
     def test_lightweight_checkout_to_branch_tags(self):
         reconfiguration, checkout = \
@@ -245,7 +245,7 @@
         wt = checkout.controldir.open_workingtree()
         self.assertTrue(parent.repository.has_same_location(
             wt.branch.repository))
-        parent.repository.get_revision('new-commit')
+        parent.repository.get_revision(b'new-commit')
         self.assertRaises(errors.NoRepositoryPresent,
                           checkout.controldir.open_repository)
 
@@ -267,7 +267,7 @@
         wt = child.controldir.open_workingtree()
         self.assertTrue(parent.repository.has_same_location(
             wt.branch.repository))
-        parent.repository.get_revision('new-commit')
+        parent.repository.get_revision(b'new-commit')
         self.assertRaises(errors.NoRepositoryPresent,
                           child.controldir.open_repository)
 
@@ -335,7 +335,7 @@
         reconfiguration.apply()
         tree = workingtree.WorkingTree.open('root/tree')
         self.assertTrue(repo.has_same_location(tree.branch.repository))
-        self.assertEqual('Hello', repo.get_revision('hello-id').message)
+        self.assertEqual('Hello', repo.get_revision(b'hello-id').message)
 
     def add_dead_head(self, tree):
         revno, revision_id = tree.branch.last_revision_info()
@@ -352,7 +352,7 @@
         reconfiguration = reconfigure.Reconfigure.to_use_shared(tree.controldir)
         reconfiguration.apply()
         tree = workingtree.WorkingTree.open('root/tree')
-        message = repo.get_revision('dead-head-id').message
+        message = repo.get_revision(b'dead-head-id').message
         self.assertEqual('Dead head', message)
 
     def make_repository_tree(self):
@@ -375,7 +375,7 @@
         repo = tree.branch.repository
         self.assertEqual(repo.controldir.root_transport.base,
                          tree.controldir.root_transport.base)
-        self.assertEqual('Hello', repo.get_revision('hello-id').message)
+        self.assertEqual('Hello', repo.get_revision(b'hello-id').message)
 
     def test_use_shared_to_standalone_preserves_dead_heads(self):
         tree = self.make_repository_tree()

=== modified file 'breezy/tests/test_repository.py'
--- breezy/tests/test_repository.py	2018-03-26 00:54:10 +0000
+++ breezy/tests/test_repository.py	2018-06-21 08:27:55 +0000
@@ -501,7 +501,7 @@
         format.repository_format = knitrepo.RepositoryFormatKnit1()
         tree = self.make_branch_and_tree('.', format)
         tree.commit("Dull commit", rev_id="dull")
-        revision_tree = tree.branch.repository.revision_tree('dull')
+        revision_tree = tree.branch.repository.revision_tree(b'dull')
         revision_tree.lock_read()
         try:
             self.assertRaises(errors.NoSuchFile, revision_tree.get_file_lines,
@@ -512,14 +512,14 @@
         format.repository_format = knitrepo.RepositoryFormatKnit3()
         upgrade.Convert('.', format)
         tree = workingtree.WorkingTree.open('.')
-        revision_tree = tree.branch.repository.revision_tree('dull')
+        revision_tree = tree.branch.repository.revision_tree(b'dull')
         revision_tree.lock_read()
         try:
             revision_tree.get_file_lines(u'', revision_tree.get_root_id())
         finally:
             revision_tree.unlock()
         tree.commit("Another dull commit", rev_id=b'dull2')
-        revision_tree = tree.branch.repository.revision_tree('dull2')
+        revision_tree = tree.branch.repository.revision_tree(b'dull2')
         revision_tree.lock_read()
         self.addCleanup(revision_tree.unlock)
         self.assertEqual('dull',
@@ -555,7 +555,7 @@
         builder.build_snapshot(None, [
             ('add', ('', b'root-id', 'directory', '')),
             ('add', ('file', b'file-id', 'file', b'content\n'))],
-            revision_id='1')
+            revision_id=b'1')
         builder.build_snapshot([b'1'], [
             ('modify', ('file', b'content-2\n'))],
             revision_id=b'2')
@@ -834,7 +834,7 @@
         self.builder.start_series()
         self.builder.build_snapshot(None,
             [('add', ('', 'tree-root', 'directory', None))],
-            revision_id='initial')
+            revision_id=b'initial')
         self.repo = self.builder.get_branch().repository
         self.addCleanup(self.builder.finish_series)
 
@@ -843,15 +843,15 @@
             sorted(self.repo._find_parent_ids_of_revisions(rev_set)))
 
     def test_simple(self):
-        self.builder.build_snapshot(None, [], revision_id='revid1')
-        self.builder.build_snapshot(['revid1'], [], revision_id='revid2')
+        self.builder.build_snapshot(None, [], revision_id=b'revid1')
+        self.builder.build_snapshot(['revid1'], [], revision_id=b'revid2')
         rev_set = ['revid2']
         self.assertParentIds(['revid1'], rev_set)
 
     def test_not_first_parent(self):
-        self.builder.build_snapshot(None, [], revision_id='revid1')
-        self.builder.build_snapshot(['revid1'], [], revision_id='revid2')
-        self.builder.build_snapshot(['revid2'], [], revision_id='revid3')
+        self.builder.build_snapshot(None, [], revision_id=b'revid1')
+        self.builder.build_snapshot(['revid1'], [], revision_id=b'revid2')
+        self.builder.build_snapshot(['revid2'], [], revision_id=b'revid3')
         rev_set = ['revid3', 'revid2']
         self.assertParentIds(['revid1'], rev_set)
 
@@ -860,27 +860,27 @@
         self.assertParentIds([], rev_set)
 
     def test_not_null_set(self):
-        self.builder.build_snapshot(None, [], revision_id='revid1')
+        self.builder.build_snapshot(None, [], revision_id=b'revid1')
         rev_set = [_mod_revision.NULL_REVISION]
         self.assertParentIds([], rev_set)
 
     def test_ghost(self):
-        self.builder.build_snapshot(None, [], revision_id='revid1')
+        self.builder.build_snapshot(None, [], revision_id=b'revid1')
         rev_set = ['ghost', 'revid1']
         self.assertParentIds(['initial'], rev_set)
 
     def test_ghost_parent(self):
-        self.builder.build_snapshot(None, [], revision_id='revid1')
-        self.builder.build_snapshot(['revid1', 'ghost'], [], revision_id='revid2')
+        self.builder.build_snapshot(None, [], revision_id=b'revid1')
+        self.builder.build_snapshot(['revid1', 'ghost'], [], revision_id=b'revid2')
         rev_set = ['revid2', 'revid1']
         self.assertParentIds(['ghost', 'initial'], rev_set)
 
     def test_righthand_parent(self):
-        self.builder.build_snapshot(None, [], revision_id='revid1')
-        self.builder.build_snapshot(['revid1'], [], revision_id='revid2a')
-        self.builder.build_snapshot(['revid1'], [], revision_id='revid2b')
+        self.builder.build_snapshot(None, [], revision_id=b'revid1')
+        self.builder.build_snapshot(['revid1'], [], revision_id=b'revid2a')
+        self.builder.build_snapshot(['revid1'], [], revision_id=b'revid2b')
         self.builder.build_snapshot(['revid2a', 'revid2b'], [],
-                                    revision_id='revid3')
+                                    revision_id=b'revid3')
         rev_set = ['revid3', 'revid2a']
         self.assertParentIds(['revid1', 'revid2b'], rev_set)
 
@@ -900,7 +900,7 @@
             repo.start_write_group()
             cleanups.append(repo.commit_write_group)
             # make rev1a: A well-formed revision, containing 'file1'
-            inv = inventory.Inventory(revision_id='rev1a')
+            inv = inventory.Inventory(revision_id=b'rev1a')
             inv.root.revision = 'rev1a'
             self.add_file(repo, inv, 'file1', 'rev1a', [])
             repo.texts.add_lines((inv.root.file_id, 'rev1a'), [], [])
@@ -912,7 +912,7 @@
 
             # make rev1b, which has no Revision, but has an Inventory, and
             # file1
-            inv = inventory.Inventory(revision_id='rev1b')
+            inv = inventory.Inventory(revision_id=b'rev1b')
             inv.root.revision = 'rev1b'
             self.add_file(repo, inv, 'file1', 'rev1b', [])
             repo.add_inventory('rev1b', inv, [])
@@ -1475,16 +1475,16 @@
         builder.build_snapshot(None, [
             ('add', ('', 'root-id', 'directory', None)),
             ('add', ('f', 'f-id', 'file', 'content\n'))],
-            revision_id='A')
+            revision_id=b'A')
         builder.build_snapshot(['A'],
             [('modify', ('f', 'new-content\n'))],
-            revision_id='B')
+            revision_id=b'B')
         builder.build_snapshot(['B'],
             [('modify', ('f', 'third-content\n'))],
-            revision_id='C')
+            revision_id=b'C')
         builder.build_snapshot(['C'],
             [('modify', ('f', 'fourth-content\n'))],
-            revision_id='D')
+            revision_id=b'D')
         b = builder.get_branch()
         b.lock_read()
         builder.finish_series()
@@ -1532,13 +1532,13 @@
         builder.build_snapshot(None, [
             ('add', ('', 'root-id', 'directory', None)),
             ('add', ('file', 'file-id', 'file', 'content\n')),
-            ], revision_id='A')
+            ], revision_id=b'A')
         builder.build_snapshot(['A'], [
             ('add', ('dir', 'dir-id', 'directory', None))],
-            revision_id='B')
+            revision_id=b'B')
         builder.build_snapshot(['B'], [
             ('modify', ('file', 'new content\n'))],
-            revision_id='C')
+            revision_id=b'C')
         builder.finish_series()
         return builder.get_branch()
 
@@ -1554,7 +1554,7 @@
                   pack_name_with_rev_C_content)
         """
         b_source = self.make_abc_branch()
-        b_base = b_source.controldir.sprout('base', revision_id='A').open_branch()
+        b_base = b_source.controldir.sprout('base', revision_id=b'A').open_branch()
         b_stacked = b_base.controldir.sprout('stacked', stacked=True).open_branch()
         b_stacked.lock_write()
         self.addCleanup(b_stacked.unlock)

=== modified file 'breezy/tests/test_revert.py'
--- breezy/tests/test_revert.py	2018-03-25 00:39:16 +0000
+++ breezy/tests/test_revert.py	2018-06-21 08:27:55 +0000
@@ -128,7 +128,7 @@
         os.unlink('file')
         tree.commit('removed file')
         self.assertPathDoesNotExist('file')
-        tree.revert(old_tree=tree.branch.repository.revision_tree('rev1'))
+        tree.revert(old_tree=tree.branch.repository.revision_tree(b'rev1'))
         self.assertPathExists('file')
         tree.revert()
         self.assertPathDoesNotExist('file')

=== modified file 'breezy/tests/test_revision.py'
--- breezy/tests/test_revision.py	2017-11-12 13:53:51 +0000
+++ breezy/tests/test_revision.py	2018-06-21 08:27:55 +0000
@@ -165,18 +165,18 @@
         # indicator. i.e. NULL_REVISION
         # RBC 20060608
         tree = self.make_branch_and_tree('.')
-        tree.commit('1', rev_id = '1', allow_pointless=True)
-        tree.commit('2', rev_id = '2', allow_pointless=True)
-        tree.commit('3', rev_id = '3', allow_pointless=True)
-        rev = tree.branch.repository.get_revision('1')
-        history = rev.get_history(tree.branch.repository)
-        self.assertEqual([None, '1'], history)
-        rev = tree.branch.repository.get_revision('2')
-        history = rev.get_history(tree.branch.repository)
-        self.assertEqual([None, '1', '2'], history)
-        rev = tree.branch.repository.get_revision('3')
-        history = rev.get_history(tree.branch.repository)
-        self.assertEqual([None, '1', '2', '3'], history)
+        tree.commit('1', rev_id=b'1', allow_pointless=True)
+        tree.commit('2', rev_id=b'2', allow_pointless=True)
+        tree.commit('3', rev_id=b'3', allow_pointless=True)
+        rev = tree.branch.repository.get_revision(b'1')
+        history = rev.get_history(tree.branch.repository)
+        self.assertEqual([None, b'1'], history)
+        rev = tree.branch.repository.get_revision(b'2')
+        history = rev.get_history(tree.branch.repository)
+        self.assertEqual([None, b'1', b'2'], history)
+        rev = tree.branch.repository.get_revision(b'3')
+        history = rev.get_history(tree.branch.repository)
+        self.assertEqual([None, b'1', b'2', b'3'], history)
 
 
 class TestReservedId(TestCase):

=== modified file 'breezy/tests/test_revisionspec.py'
--- breezy/tests/test_revisionspec.py	2018-02-18 15:21:06 +0000
+++ breezy/tests/test_revisionspec.py	2018-06-21 08:27:55 +0000
@@ -151,14 +151,14 @@
     # covers that well for us
     def test_dwim_spec_revno(self):
         self.assertInHistoryIs(2, 'r2', '2')
-        self.assertAsRevisionId('alt_r2', '1.1.1')
+        self.assertAsRevisionId(b'alt_r2', '1.1.1')
 
     def test_dwim_spec_revid(self):
         self.assertInHistoryIs(2, 'r2', 'r2')
 
     def test_dwim_spec_tag(self):
         self.tree.branch.tags.set_tag('footag', 'r1')
-        self.assertAsRevisionId('r1', 'footag')
+        self.assertAsRevisionId(b'r1', 'footag')
         self.tree.branch.tags.delete_tag('footag')
         self.assertRaises(errors.InvalidRevisionSpec,
                           self.get_in_history, 'footag')
@@ -168,14 +168,14 @@
         # but aren't.  Tags are convenient for testing this since we can
         # make them look however we want.
         self.tree.branch.tags.set_tag('3', 'r2')
-        self.assertAsRevisionId('r2', '3')
+        self.assertAsRevisionId(b'r2', '3')
         self.build_tree(['tree/b'])
         self.tree.add(['b'])
         self.tree.commit('b', rev_id=b'r3')
-        self.assertAsRevisionId('r3', '3')
+        self.assertAsRevisionId(b'r3', '3')
 
     def test_dwim_spec_date(self):
-        self.assertAsRevisionId('r1', 'today')
+        self.assertAsRevisionId(b'r1', 'today')
 
     def test_dwim_spec_branch(self):
         self.assertInHistoryIs(None, 'alt_r2', 'tree2')
@@ -194,7 +194,7 @@
             RevisionSpec_dwim._possible_revspecs = original_dwim_revspecs
         self.addCleanup(reset_dwim_revspecs)
         RevisionSpec_dwim.append_possible_revspec(RevisionSpec_bork)
-        self.assertAsRevisionId('r1', 'bork')
+        self.assertAsRevisionId(b'r1', 'bork')
 
     def test_append_lazy_dwim_revspec(self):
         original_dwim_revspecs = list(RevisionSpec_dwim._possible_revspecs)
@@ -203,7 +203,7 @@
         self.addCleanup(reset_dwim_revspecs)
         RevisionSpec_dwim.append_possible_lazy_revspec(
             "breezy.tests.test_revisionspec", "RevisionSpec_bork")
-        self.assertAsRevisionId('r1', 'bork')
+        self.assertAsRevisionId(b'r1', 'bork')
 
 
 class TestRevisionSpec_revno(TestRevisionSpec):
@@ -341,26 +341,26 @@
                          spec_in_history('revno:2:b/', None))
 
     def test_as_revision_id(self):
-        self.assertAsRevisionId('null:', '0')
-        self.assertAsRevisionId('r1', '1')
-        self.assertAsRevisionId('r2', '2')
-        self.assertAsRevisionId('r1', '-2')
-        self.assertAsRevisionId('r2', '-1')
-        self.assertAsRevisionId('alt_r2', '1.1.1')
+        self.assertAsRevisionId(b'null:', '0')
+        self.assertAsRevisionId(b'r1', '1')
+        self.assertAsRevisionId(b'r2', '2')
+        self.assertAsRevisionId(b'r1', '-2')
+        self.assertAsRevisionId(b'r2', '-1')
+        self.assertAsRevisionId(b'alt_r2', '1.1.1')
 
     def test_as_tree(self):
         tree = self.get_as_tree('0')
         self.assertEqual(_mod_revision.NULL_REVISION, tree.get_revision_id())
         tree = self.get_as_tree('1')
-        self.assertEqual('r1', tree.get_revision_id())
+        self.assertEqual(b'r1', tree.get_revision_id())
         tree = self.get_as_tree('2')
-        self.assertEqual('r2', tree.get_revision_id())
+        self.assertEqual(b'r2', tree.get_revision_id())
         tree = self.get_as_tree('-2')
-        self.assertEqual('r1', tree.get_revision_id())
+        self.assertEqual(b'r1', tree.get_revision_id())
         tree = self.get_as_tree('-1')
-        self.assertEqual('r2', tree.get_revision_id())
+        self.assertEqual(b'r2', tree.get_revision_id())
         tree = self.get_as_tree('1.1.1')
-        self.assertEqual('alt_r2', tree.get_revision_id())
+        self.assertEqual(b'alt_r2', tree.get_revision_id())
 
 
 class TestRevisionSpec_revid(TestRevisionSpec):
@@ -368,15 +368,15 @@
     def test_in_history(self):
         # We should be able to access revisions that are directly
         # in the history.
-        self.assertInHistoryIs(1, 'r1', 'revid:r1')
-        self.assertInHistoryIs(2, 'r2', 'revid:r2')
+        self.assertInHistoryIs(1, b'r1', 'revid:r1')
+        self.assertInHistoryIs(2, b'r2', 'revid:r2')
 
     def test_missing(self):
         self.assertInvalid('revid:r3', invalid_as_revision_id=False)
 
     def test_merged(self):
         """We can reach revisions in the ancestry"""
-        self.assertInHistoryIs(None, 'alt_r2', 'revid:alt_r2')
+        self.assertInHistoryIs(None, b'alt_r2', 'revid:alt_r2')
 
     def test_not_here(self):
         self.tree2.commit('alt third', rev_id=b'alt_r3')
@@ -387,31 +387,31 @@
         """We can get any revision id in the repository"""
         # XXX: This may change in the future, but for now, it is true
         self.tree2.commit('alt third', rev_id=b'alt_r3')
-        self.tree.branch.fetch(self.tree2.branch, 'alt_r3')
-        self.assertInHistoryIs(None, 'alt_r3', 'revid:alt_r3')
+        self.tree.branch.fetch(self.tree2.branch, b'alt_r3')
+        self.assertInHistoryIs(None, b'alt_r3', 'revid:alt_r3')
 
     def test_unicode(self):
         """We correctly convert a unicode ui string to an encoded revid."""
         revision_id = u'\N{SNOWMAN}'.encode('utf-8')
         self.tree.commit('unicode', rev_id=revision_id)
         self.assertInHistoryIs(3, revision_id, u'revid:\N{SNOWMAN}')
-        self.assertInHistoryIs(3, revision_id, 'revid:' + revision_id)
+        self.assertInHistoryIs(3, revision_id, b'revid:' + revision_id)
 
     def test_as_revision_id(self):
-        self.assertAsRevisionId('r1', 'revid:r1')
-        self.assertAsRevisionId('r2', 'revid:r2')
-        self.assertAsRevisionId('alt_r2', 'revid:alt_r2')
+        self.assertAsRevisionId(b'r1', 'revid:r1')
+        self.assertAsRevisionId(b'r2', 'revid:r2')
+        self.assertAsRevisionId(b'alt_r2', 'revid:alt_r2')
 
 
 class TestRevisionSpec_last(TestRevisionSpec):
 
     def test_positive(self):
-        self.assertInHistoryIs(2, 'r2', 'last:1')
-        self.assertInHistoryIs(1, 'r1', 'last:2')
-        self.assertInHistoryIs(0, 'null:', 'last:3')
+        self.assertInHistoryIs(2, b'r2', 'last:1')
+        self.assertInHistoryIs(1, b'r1', 'last:2')
+        self.assertInHistoryIs(0, b'null:', 'last:3')
 
     def test_empty(self):
-        self.assertInHistoryIs(2, 'r2', 'last:')
+        self.assertInHistoryIs(2, b'r2', 'last:')
 
     def test_negative(self):
         self.assertInvalid('last:-1',
@@ -434,44 +434,44 @@
         self.assertInvalid('last:Y', extra='\n' + str(e))
 
     def test_as_revision_id(self):
-        self.assertAsRevisionId('r2', 'last:1')
-        self.assertAsRevisionId('r1', 'last:2')
+        self.assertAsRevisionId(b'r2', 'last:1')
+        self.assertAsRevisionId(b'r1', 'last:2')
 
 
 class TestRevisionSpec_before(TestRevisionSpec):
 
     def test_int(self):
-        self.assertInHistoryIs(1, 'r1', 'before:2')
-        self.assertInHistoryIs(1, 'r1', 'before:-1')
+        self.assertInHistoryIs(1, b'r1', 'before:2')
+        self.assertInHistoryIs(1, b'r1', 'before:-1')
 
     def test_before_one(self):
-        self.assertInHistoryIs(0, 'null:', 'before:1')
+        self.assertInHistoryIs(0, b'null:', 'before:1')
 
     def test_before_none(self):
         self.assertInvalid('before:0',
                            extra='\ncannot go before the null: revision')
 
     def test_revid(self):
-        self.assertInHistoryIs(1, 'r1', 'before:revid:r2')
+        self.assertInHistoryIs(1, b'r1', 'before:revid:r2')
 
     def test_last(self):
-        self.assertInHistoryIs(1, 'r1', 'before:last:1')
+        self.assertInHistoryIs(1, b'r1', 'before:last:1')
 
     def test_alt_revid(self):
         # This will grab the left-most ancestor for alternate histories
-        self.assertInHistoryIs(1, 'r1', 'before:revid:alt_r2')
+        self.assertInHistoryIs(1, b'r1', 'before:revid:alt_r2')
 
     def test_alt_no_parents(self):
         new_tree = self.make_branch_and_tree('new_tree')
         new_tree.commit('first', rev_id=b'new_r1')
         self.tree.branch.fetch(new_tree.branch, 'new_r1')
-        self.assertInHistoryIs(0, 'null:', 'before:revid:new_r1')
+        self.assertInHistoryIs(0, b'null:', 'before:revid:new_r1')
 
     def test_as_revision_id(self):
-        self.assertAsRevisionId('r1', 'before:revid:r2')
-        self.assertAsRevisionId('r1', 'before:2')
-        self.assertAsRevisionId('r1', 'before:1.1.1')
-        self.assertAsRevisionId('r1', 'before:revid:alt_r2')
+        self.assertAsRevisionId(b'r1', 'before:revid:r2')
+        self.assertAsRevisionId(b'r1', 'before:2')
+        self.assertAsRevisionId(b'r1', 'before:1.1.1')
+        self.assertAsRevisionId(b'r1', 'before:revid:alt_r2')
 
 
 class TestRevisionSpec_tag(TestRevisionSpec):
@@ -487,10 +487,10 @@
         self.assertEqual(spec.spec, 'bzr-0.14')
 
     def test_lookup_tag(self):
-        self.tree.branch.tags.set_tag('bzr-0.14', 'r1')
-        self.assertInHistoryIs(1, 'r1', 'tag:bzr-0.14')
-        self.tree.branch.tags.set_tag('null_rev', 'null:')
-        self.assertInHistoryIs(0, 'null:', 'tag:null_rev')
+        self.tree.branch.tags.set_tag('bzr-0.14', b'r1')
+        self.assertInHistoryIs(1, b'r1', 'tag:bzr-0.14')
+        self.tree.branch.tags.set_tag('null_rev', b'null:')
+        self.assertInHistoryIs(0, b'null:', 'tag:null_rev')
 
     def test_failed_lookup(self):
         # tags that don't exist give a specific message: arguably we should
@@ -500,11 +500,11 @@
             'tag:some-random-tag')
 
     def test_as_revision_id(self):
-        self.tree.branch.tags.set_tag('my-tag', 'r2')
-        self.tree.branch.tags.set_tag('null_rev', 'null:')
-        self.assertAsRevisionId('r2', 'tag:my-tag')
-        self.assertAsRevisionId('null:', 'tag:null_rev')
-        self.assertAsRevisionId('r1', 'before:tag:my-tag')
+        self.tree.branch.tags.set_tag('my-tag', b'r2')
+        self.tree.branch.tags.set_tag('null_rev', b'null:')
+        self.assertAsRevisionId(b'r2', 'tag:my-tag')
+        self.assertAsRevisionId(b'null:', 'tag:null_rev')
+        self.assertAsRevisionId(b'r1', 'before:tag:my-tag')
 
 
 class TestRevisionSpec_date(TestRevisionSpec):
@@ -524,11 +524,11 @@
         self.assertInvalid('date:tomorrow')
 
     def test_today(self):
-        self.assertInHistoryIs(2, 'new_r2', 'date:today')
-        self.assertInHistoryIs(1, 'new_r1', 'before:date:today')
+        self.assertInHistoryIs(2, b'new_r2', 'date:today')
+        self.assertInHistoryIs(1, b'new_r1', 'before:date:today')
 
     def test_yesterday(self):
-        self.assertInHistoryIs(1, 'new_r1', 'date:yesterday')
+        self.assertInHistoryIs(1, b'new_r1', 'date:yesterday')
 
     def test_invalid(self):
         self.assertInvalid('date:foobar', extra='\ninvalid date')
@@ -539,11 +539,11 @@
 
     def test_day(self):
         now = datetime.datetime.now()
-        self.assertInHistoryIs(2, 'new_r2',
+        self.assertInHistoryIs(2, b'new_r2',
             'date:%04d-%02d-%02d' % (now.year, now.month, now.day))
 
     def test_as_revision_id(self):
-        self.assertAsRevisionId('new_r2', 'date:today')
+        self.assertAsRevisionId(b'new_r2', 'date:today')
 
 
 class TestRevisionSpec_ancestor(TestRevisionSpec):
@@ -556,16 +556,16 @@
 
     def test_simple(self):
         # Common ancestor of trees is 'alt_r2'
-        self.assertInHistoryIs(None, 'alt_r2', 'ancestor:tree2')
+        self.assertInHistoryIs(None, b'alt_r2', 'ancestor:tree2')
 
         # Going the other way, we get a valid revno
         tmp = self.tree
         self.tree = self.tree2
         self.tree2 = tmp
-        self.assertInHistoryIs(2, 'alt_r2', 'ancestor:tree')
+        self.assertInHistoryIs(2, b'alt_r2', 'ancestor:tree')
 
     def test_self(self):
-        self.assertInHistoryIs(2, 'r2', 'ancestor:tree')
+        self.assertInHistoryIs(2, b'r2', 'ancestor:tree')
 
     def test_unrelated(self):
         new_tree = self.make_branch_and_tree('new_tree')
@@ -589,7 +589,7 @@
                                            new_tree.branch)
 
     def test_as_revision_id(self):
-        self.assertAsRevisionId('alt_r2', 'ancestor:tree2')
+        self.assertAsRevisionId(b'alt_r2', 'ancestor:tree2')
 
     def test_default(self):
         # We don't have a parent to default to
@@ -600,7 +600,7 @@
         tree3 = self.tree.controldir.sprout('tree3').open_workingtree()
         tree3.commit('foo', rev_id=b'r3')
         self.tree = tree3
-        self.assertInHistoryIs(2, 'r2', 'ancestor:')
+        self.assertInHistoryIs(2, b'r2', 'ancestor:')
 
 
 class TestRevisionSpec_branch(TestRevisionSpec):
@@ -612,10 +612,10 @@
                           self.get_in_history, 'branch:tree2/a')
 
     def test_simple(self):
-        self.assertInHistoryIs(None, 'alt_r2', 'branch:tree2')
+        self.assertInHistoryIs(None, b'alt_r2', 'branch:tree2')
 
     def test_self(self):
-        self.assertInHistoryIs(2, 'r2', 'branch:tree')
+        self.assertInHistoryIs(2, b'r2', 'branch:tree')
 
     def test_unrelated(self):
         new_tree = self.make_branch_and_tree('new_tree')
@@ -624,12 +624,12 @@
         new_tree.commit('Commit two', rev_id=b'new_r2')
         new_tree.commit('Commit three', rev_id=b'new_r3')
 
-        self.assertInHistoryIs(None, 'new_r3', 'branch:new_tree')
+        self.assertInHistoryIs(None, b'new_r3', 'branch:new_tree')
 
         # XXX: Right now, we use fetch() to make sure the remote revisions
         # have been pulled into the local branch. We may change that
         # behavior in the future.
-        self.assertTrue(self.tree.branch.repository.has_revision('new_r3'))
+        self.assertTrue(self.tree.branch.repository.has_revision(b'new_r3'))
 
     def test_no_commits(self):
         new_tree = self.make_branch_and_tree('new_tree')
@@ -639,12 +639,12 @@
                           self.get_as_tree, 'branch:new_tree')
 
     def test_as_revision_id(self):
-        self.assertAsRevisionId('alt_r2', 'branch:tree2')
+        self.assertAsRevisionId(b'alt_r2', 'branch:tree2')
 
     def test_as_tree(self):
         tree = self.get_as_tree('branch:tree', self.tree2)
-        self.assertEqual('r2', tree.get_revision_id())
-        self.assertFalse(self.tree2.branch.repository.has_revision('r2'))
+        self.assertEqual(b'r2', tree.get_revision_id())
+        self.assertFalse(self.tree2.branch.repository.has_revision(b'r2'))
 
 
 class TestRevisionSpec_submit(TestRevisionSpec):
@@ -654,25 +654,25 @@
         self.assertRaises(errors.NoSubmitBranch, self.get_in_history,
                           'submit:')
         self.tree.branch.set_parent('../tree2')
-        self.assertInHistoryIs(None, 'alt_r2', 'submit:')
+        self.assertInHistoryIs(None, b'alt_r2', 'submit:')
         self.tree.branch.set_parent('bogus')
         self.assertRaises(errors.NotBranchError, self.get_in_history,
             'submit:')
         # submit branch overrides parent branch
         self.tree.branch.set_submit_branch('tree2')
-        self.assertInHistoryIs(None, 'alt_r2', 'submit:')
+        self.assertInHistoryIs(None, b'alt_r2', 'submit:')
 
     def test_as_revision_id(self):
         self.tree.branch.set_submit_branch('tree2')
-        self.assertAsRevisionId('alt_r2', 'branch:tree2')
+        self.assertAsRevisionId(b'alt_r2', 'branch:tree2')
 
 
 class TestRevisionSpec_mainline(TestRevisionSpec):
 
     def test_as_revision_id(self):
-        self.assertAsRevisionId('r1', 'mainline:1')
-        self.assertAsRevisionId('r2', 'mainline:1.1.1')
-        self.assertAsRevisionId('r2', 'mainline:revid:alt_r2')
+        self.assertAsRevisionId(b'r1', 'mainline:1')
+        self.assertAsRevisionId(b'r2', 'mainline:1.1.1')
+        self.assertAsRevisionId(b'r2', 'mainline:revid:alt_r2')
         spec = RevisionSpec.from_string('mainline:revid:alt_r22')
         e = self.assertRaises(errors.InvalidRevisionSpec,
                               spec.as_revision_id, self.tree.branch)
@@ -681,7 +681,7 @@
             " branch: ")
 
     def test_in_history(self):
-        self.assertInHistoryIs(2, 'r2', 'mainline:revid:alt_r2')
+        self.assertInHistoryIs(2, b'r2', 'mainline:revid:alt_r2')
 
 
 class TestRevisionSpec_annotate(TestRevisionSpec):
@@ -697,10 +697,10 @@
         self.build_tree_contents([('annotate-tree/file1', b'2\n1\n3\n')])
 
     def test_as_revision_id_r1(self):
-        self.assertAsRevisionId('r1', 'annotate:annotate-tree/file1:2')
+        self.assertAsRevisionId(b'r1', 'annotate:annotate-tree/file1:2')
 
     def test_as_revision_id_r2(self):
-        self.assertAsRevisionId('r2', 'annotate:annotate-tree/file1:1')
+        self.assertAsRevisionId(b'r2', 'annotate:annotate-tree/file1:1')
 
     def test_as_revision_id_uncommitted(self):
         spec = RevisionSpec.from_string('annotate:annotate-tree/file1:3')

=== modified file 'breezy/tests/test_smart.py'
--- breezy/tests/test_smart.py	2018-05-19 17:31:48 +0000
+++ breezy/tests/test_smart.py	2018-06-21 08:27:55 +0000
@@ -121,9 +121,9 @@
 
     def test_repeated_substreams_same_kind_are_one_stream(self):
         # Make a stream - an iterable of bytestrings.
-        stream = [('text', [versionedfile.FulltextContentFactory(('k1',), None,
-            None, 'foo')]), ('text', [
-            versionedfile.FulltextContentFactory(('k2',), None, None, 'bar')])]
+        stream = [('text', [versionedfile.FulltextContentFactory((b'k1',), None,
+            None, b'foo')]), ('text', [
+            versionedfile.FulltextContentFactory((b'k2',), None, None, b'bar')])]
         fmt = controldir.format_registry.get('pack-0.92')().repository_format
         bytes = smart_repo._stream_to_byte_stream(stream, fmt)
         streams = []
@@ -141,11 +141,11 @@
     def test__eq__(self):
         self.assertEqual(smart_req.SmartServerResponse((b'ok', )),
             smart_req.SmartServerResponse((b'ok', )))
-        self.assertEqual(smart_req.SmartServerResponse((b'ok', ), 'body'),
-            smart_req.SmartServerResponse((b'ok', ), 'body'))
+        self.assertEqual(smart_req.SmartServerResponse((b'ok', ), b'body'),
+            smart_req.SmartServerResponse((b'ok', ), b'body'))
         self.assertNotEqual(smart_req.SmartServerResponse((b'ok', )),
             smart_req.SmartServerResponse((b'notok', )))
-        self.assertNotEqual(smart_req.SmartServerResponse((b'ok', ), 'body'),
+        self.assertNotEqual(smart_req.SmartServerResponse((b'ok', ), b'body'),
             smart_req.SmartServerResponse((b'ok', )))
         self.assertNotEqual(None,
             smart_req.SmartServerResponse((b'ok', )))
@@ -167,17 +167,17 @@
     def test_translate_client_path(self):
         transport = self.get_transport()
         request = smart_req.SmartServerRequest(transport, 'foo/')
-        self.assertEqual('./', request.translate_client_path('foo/'))
-        self.assertRaises(
-            urlutils.InvalidURLJoin, request.translate_client_path, 'foo/..')
-        self.assertRaises(
-            errors.PathNotChild, request.translate_client_path, '/')
-        self.assertRaises(
-            errors.PathNotChild, request.translate_client_path, 'bar/')
-        self.assertEqual('./baz', request.translate_client_path('foo/baz'))
+        self.assertEqual('./', request.translate_client_path(b'foo/'))
+        self.assertRaises(
+            urlutils.InvalidURLJoin, request.translate_client_path, b'foo/..')
+        self.assertRaises(
+            errors.PathNotChild, request.translate_client_path, b'/')
+        self.assertRaises(
+            errors.PathNotChild, request.translate_client_path, b'bar/')
+        self.assertEqual('./baz', request.translate_client_path(b'foo/baz'))
         e_acute = u'\N{LATIN SMALL LETTER E WITH ACUTE}'.encode('utf-8')
         self.assertEqual('./' + urlutils.escape(e_acute),
-                         request.translate_client_path('foo/' + e_acute))
+                         request.translate_client_path(b'foo/' + e_acute))
 
     def test_translate_client_path_vfs(self):
         """VfsRequests receive escaped paths rather than raw UTF-8."""
@@ -210,8 +210,8 @@
         expected = smart_req.SuccessfulSmartServerResponse(
             (local_result.network_name(),
             local_result.repository_format.network_name(),
-            ('branch', local_result.get_branch_format().network_name())))