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

[Jelmer Vernooij]

Fix another 1.5k tests on python3.

This brings the number of failing python3 tests to below 10k.

[Martin Packman (gz)]

Thanks! See some inline comments.

review: Needs Fixing

[Martin Packman (gz)]

Thanks! Lets try it.

review: Approve

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

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

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

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

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

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

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

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

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

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

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

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

=== modified file 'breezy/builtins.py'
--- breezy/builtins.py	2018-06-04 11:35:48 +0000
+++ breezy/builtins.py	2018-06-30 17:35:22 +0000
@@ -6764,15 +6764,8 @@
         from .transform import link_tree
         target_tree = WorkingTree.open_containing(".")[0]
         source_tree = WorkingTree.open(location)
-        target_tree.lock_write()
-        try:
-            source_tree.lock_read()
-            try:
-                link_tree(target_tree, source_tree)
-            finally:
-                source_tree.unlock()
-        finally:
-            target_tree.unlock()
+        with target_tree.lock_write(), source_tree.lock_read():
+            link_tree(target_tree, source_tree)
 
 
 class cmd_fetch_ghosts(Command):

=== modified file 'breezy/bundle/apply_bundle.py'
--- breezy/bundle/apply_bundle.py	2018-03-01 01:41:45 +0000
+++ breezy/bundle/apply_bundle.py	2018-06-30 17:35:22 +0000
@@ -46,8 +46,7 @@
 def merge_bundle(reader, tree, check_clean, merge_type,
                     reprocess, show_base, change_reporter=None):
     """Merge a revision bundle into the current tree."""
-    pb = ui.ui_factory.nested_progress_bar()
-    try:
+    with ui.ui_factory.nested_progress_bar() as pb:
         pp = ProgressPhase("Merge phase", 6, pb)
         pp.next_phase()
         install_bundle(tree.branch.repository, reader)
@@ -70,6 +69,4 @@
         merger.reprocess = reprocess
         conflicts = merger.do_merge()
         merger.set_pending()
-    finally:
-        pb.clear()
     return conflicts

=== modified file 'breezy/bundle/serializer/v4.py'
--- breezy/bundle/serializer/v4.py	2018-06-22 01:22:25 +0000
+++ breezy/bundle/serializer/v4.py	2018-06-30 17:35:22 +0000
@@ -468,13 +468,10 @@
             all into memory at once.  Reading it into memory all at once is
             (currently) faster.
         """
-        repository.lock_write()
-        try:
+        with repository.lock_write():
             ri = RevisionInstaller(self.get_bundle_reader(stream_input),
                                    self._serializer, repository)
             return ri.install()
-        finally:
-            repository.unlock()
 
     def get_merge_request(self, target_repo):
         """Provide data for performing a merge

=== modified file 'breezy/bzr/branch.py'
--- breezy/bzr/branch.py	2018-06-22 01:50:22 +0000
+++ breezy/bzr/branch.py	2018-06-30 17:35:22 +0000
@@ -1052,13 +1052,10 @@
 
         # Copy source data into target
         new_branch._write_last_revision_info(*branch.last_revision_info())
-        new_branch.lock_write()
-        try:
+        with new_branch.lock_write():
             new_branch.set_parent(branch.get_parent())
             new_branch.set_bound_location(branch.get_bound_location())
             new_branch.set_push_location(branch.get_push_location())
-        finally:
-            new_branch.unlock()
 
         # New branch has no tags by default
         new_branch.tags._set_tag_dict({})
@@ -1070,15 +1067,12 @@
 
         # Clean up old files
         new_branch._transport.delete('revision-history')
-        branch.lock_write()
-        try:
+        with branch.lock_write():
             try:
                 branch.set_parent(None)
             except errors.NoSuchFile:
                 pass
             branch.set_bound_location(None)
-        finally:
-            branch.unlock()
 
 
 class Converter6to7(object):

=== modified file 'breezy/bzr/bzrdir.py'
--- breezy/bzr/bzrdir.py	2018-06-16 11:29:34 +0000
+++ breezy/bzr/bzrdir.py	2018-06-30 17:35:22 +0000
@@ -450,15 +450,12 @@
             (result_repo is None or result_repo.make_working_trees())):
             wt = result.create_workingtree(accelerator_tree=accelerator_tree,
                 hardlink=hardlink, from_branch=result_branch)
-            wt.lock_write()
-            try:
+            with wt.lock_write():
                 if not wt.is_versioned(''):
                     try:
                         wt.set_root_id(self.open_workingtree.get_root_id())
                     except errors.NoWorkingTree:
                         pass
-            finally:
-                wt.unlock()
         else:
             wt = None
         if recurse == 'down':

=== modified file 'breezy/bzr/dirstate.py'
--- breezy/bzr/dirstate.py	2018-05-27 18:00:21 +0000
+++ breezy/bzr/dirstate.py	2018-06-30 17:35:22 +0000
@@ -1319,12 +1319,21 @@
         return result
 
     def _check_delta_is_valid(self, delta):
-        return list(inventory._check_delta_unique_ids(
-                    inventory._check_delta_unique_old_paths(
-                    inventory._check_delta_unique_new_paths(
-                    inventory._check_delta_ids_match_entry(
-                    inventory._check_delta_ids_are_valid(
-                    inventory._check_delta_new_path_entry_both_or_None(delta)))))))
+        delta = list(inventory._check_delta_unique_ids(
+                     inventory._check_delta_unique_old_paths(
+                     inventory._check_delta_unique_new_paths(
+                     inventory._check_delta_ids_match_entry(
+                     inventory._check_delta_ids_are_valid(
+                     inventory._check_delta_new_path_entry_both_or_None(delta)))))))
+        def delta_key(d):
+            (old_path, new_path, file_id, new_entry) = d
+            if old_path is None:
+                old_path = ''
+            if new_path is None:
+                new_path = ''
+            return (old_path, new_path, file_id, new_entry)
+        delta.sort(key=delta_key, reverse=True)
+        return delta
 
     def update_by_delta(self, delta):
         """Apply an inventory delta to the dirstate for tree 0
@@ -1349,9 +1358,9 @@
         new_ids = set()
         # This loop transforms the delta to single atomic operations that can
         # be executed and validated.
-        delta = sorted(self._check_delta_is_valid(delta), reverse=True)
+        delta = self._check_delta_is_valid(delta)
         for old_path, new_path, file_id, inv_entry in delta:
-            if file_id.__class__ is not bytes:
+            if not isinstance(file_id, bytes):
                 raise AssertionError(
                     "must be a utf8 file_id not %s" % (type(file_id), ))
             if (file_id in insertions) or (file_id in removals):
@@ -1486,7 +1495,7 @@
 
         self._parents[0] = new_revid
 
-        delta = sorted(self._check_delta_is_valid(delta), reverse=True)
+        delta = self._check_delta_is_valid(delta)
         adds = []
         changes = []
         deletes = []
@@ -1634,7 +1643,7 @@
                 if entry[0][2] != file_id:
                     # Different file_id, so not what we want.
                     continue
-                self._raise_invalid(("%s/%s" % key[0:2]).decode('utf8'), file_id,
+                self._raise_invalid((b"%s/%s" % key[0:2]).decode('utf8'), file_id,
                     "This file_id is new in the delta but already present in "
                     "the target")
 
@@ -1851,12 +1860,12 @@
                 # removed.
                 entry[1][1] = null
                 block_i, entry_i, d_present, f_present = \
-                    self._get_block_entry_index(old_path, '', 1)
+                    self._get_block_entry_index(old_path, b'', 1)
                 if d_present:
                     dir_block = self._dirblocks[block_i][1]
             for child_entry in dir_block:
                 child_basis_kind = child_entry[1][1][0]
-                if child_basis_kind not in 'ar':
+                if child_basis_kind not in b'ar':
                     self._raise_invalid(old_path, file_id,
                         "The file id was deleted but its children were "
                         "not deleted.")

=== modified file 'breezy/bzr/index.py'
--- breezy/bzr/index.py	2018-05-13 02:18:13 +0000
+++ breezy/bzr/index.py	2018-06-30 17:35:22 +0000
@@ -43,8 +43,10 @@
     )
 from ..sixish import (
     BytesIO,
+    bytesintern,
     viewvalues,
     viewitems,
+    zip,
     )
 from ..static_tuple import StaticTuple
 
@@ -286,15 +288,15 @@
         """
         (node_refs,
          absent_references) = self._check_key_ref_value(key, references, value)
-        if key in self._nodes and self._nodes[key][0] != 'a':
+        if key in self._nodes and self._nodes[key][0] != b'a':
             raise BadIndexDuplicateKey(key, self)
         for reference in absent_references:
             # There may be duplicates, but I don't think it is worth worrying
             # about
-            self._nodes[reference] = ('a', (), '')
+            self._nodes[reference] = (b'a', (), b'')
         self._absent_keys.update(absent_references)
         self._absent_keys.discard(key)
-        self._nodes[key] = ('', node_refs, value)
+        self._nodes[key] = (b'', node_refs, value)
         if self._nodes_by_key is not None and self._key_length > 1:
             self._update_nodes_by_key(key, value, node_refs)
 
@@ -499,6 +501,16 @@
     def __ne__(self, other):
         return not self.__eq__(other)
 
+    def __lt__(self, other):
+        # We don't really care about the order, just that there is an order.
+        if (not isinstance(other, GraphIndex) and
+            not isinstance(other, InMemoryGraphIndex)):
+            raise TypeError(other)
+        return hash(self) < hash(other)
+
+    def __hash__(self):
+        return hash((type(self), self._transport, self._name, self._size))
+
     def __repr__(self):
         return "%s(%r)" % (self.__class__.__name__,
             self._transport.abspath(self._name))
@@ -520,19 +532,20 @@
                 # This is wasteful, but it is better than dealing with
                 # adjusting all the offsets, etc.
                 stream = BytesIO(stream.read()[self._base_offset:])
-        self._read_prefix(stream)
-        self._expected_elements = 3 + self._key_length
-        line_count = 0
-        # raw data keyed by offset
-        self._keys_by_offset = {}
-        # ready-to-return key:value or key:value, node_ref_lists
-        self._nodes = {}
-        self._nodes_by_key = None
-        trailers = 0
-        pos = stream.tell()
-        lines = stream.read().split(b'\n')
-        # GZ 2009-09-20: Should really use a try/finally block to ensure close
-        stream.close()
+        try:
+            self._read_prefix(stream)
+            self._expected_elements = 3 + self._key_length
+            line_count = 0
+            # raw data keyed by offset
+            self._keys_by_offset = {}
+            # ready-to-return key:value or key:value, node_ref_lists
+            self._nodes = {}
+            self._nodes_by_key = None
+            trailers = 0
+            pos = stream.tell()
+            lines = stream.read().split(b'\n')
+        finally:
+            stream.close()
         del lines[-1]
         _, _, _, trailers = self._parse_lines(lines, pos)
         for key, absent, references, value in viewvalues(self._keys_by_offset):
@@ -1145,7 +1158,7 @@
                 raise BadIndexData(self)
             # keys are tuples. Each element is a string that may occur many
             # times, so we intern them to save space. AB, RC, 200807
-            key = tuple([intern(element) for element in elements[:self._key_length]])
+            key = tuple([bytesintern(element) for element in elements[:self._key_length]])
             if first_key is None:
                 first_key = key
             absent, references, value = elements[-3:]
@@ -1599,7 +1612,7 @@
         """
         if self._reload_func is None:
             return False
-        trace.mutter('Trying to reload after getting exception: %s', error)
+        trace.mutter('Trying to reload after getting exception: %s', str(error))
         if not self._reload_func():
             # We tried to reload, but nothing changed, so we fail anyway
             trace.mutter('_reload_func indicated nothing has changed.'
@@ -1731,6 +1744,13 @@
     def validate(self):
         """In memory index's have no known corruption at the moment."""
 
+    def __lt__(self, other):
+        # We don't really care about the order, just that there is an order.
+        if (not isinstance(other, GraphIndex) and
+            not isinstance(other, InMemoryGraphIndex)):
+            raise TypeError(other)
+        return hash(self) < hash(other)
+
 
 class GraphIndexPrefixAdapter(object):
     """An adapter between GraphIndex with different key lengths.

=== modified file 'breezy/bzr/inventory.py'
--- breezy/bzr/inventory.py	2018-06-18 00:19:26 +0000
+++ breezy/bzr/inventory.py	2018-06-30 17:35:22 +0000
@@ -227,6 +227,8 @@
         """
         if u'/' in name:
             raise errors.InvalidEntryName(name=name)
+        if not isinstance(file_id, bytes):
+            raise TypeError(file_id)
         self.file_id = file_id
         self.revision = None
         self.name = name
@@ -1152,6 +1154,8 @@
         >>> inv.get_entry('123123').name
         'hello.c'
         """
+        if not isinstance(file_id, bytes):
+            raise TypeError(file_id)
         try:
             return self._byid[file_id]
         except KeyError:

=== modified file 'breezy/bzr/knit.py'
--- breezy/bzr/knit.py	2018-06-14 18:03:42 +0000
+++ breezy/bzr/knit.py	2018-06-30 17:35:22 +0000
@@ -2750,13 +2750,10 @@
                 self._filename = prefix
                 try:
                     path = self._mapper.map(prefix) + '.kndx'
-                    fp = self._transport.get(path)
-                    try:
+                    with self._transport.get(path) as fp:
                         # _load_data may raise NoSuchFile if the target knit is
                         # completely empty.
                         _load_data(self, fp)
-                    finally:
-                        fp.close()
                     self._kndx_cache[prefix] = (self._cache, self._history)
                     del self._cache
                     del self._filename
@@ -2917,17 +2914,17 @@
                 if key_dependencies is not None:
                     key_dependencies.add_references(key, parents)
             index, pos, size = access_memo
-            if 'no-eol' in options:
-                value = 'N'
+            if b'no-eol' in options:
+                value = b'N'
             else:
-                value = ' '
-            value += "%d %d" % (pos, size)
+                value = b' '
+            value += b"%d %d" % (pos, size)
             if not self._deltas:
-                if 'line-delta' in options:
+                if b'line-delta' in options:
                     raise KnitCorrupt(self, "attempt to add line-delta in non-delta knit")
             if self._parents:
                 if self._deltas:
-                    if 'line-delta' in options:
+                    if b'line-delta' in options:
                         node_refs = (parents, (parents[0],))
                         if missing_compression_parents:
                             compression_parents.add(parents[0])
@@ -2949,7 +2946,7 @@
                 # Sometimes these are passed as a list rather than a tuple
                 passed = static_tuple.as_tuples(keys[key])
                 passed_parents = passed[1][:1]
-                if (value[0] != keys[key][0][0] or
+                if (value[0:1] != keys[key][0][0:1] or
                     parents != passed_parents):
                     node_refs = static_tuple.as_tuples(node_refs)
                     raise KnitCorrupt(self, "inconsistent details in add_records"

=== modified file 'breezy/bzr/knitrepo.py'
--- breezy/bzr/knitrepo.py	2018-06-23 18:15:06 +0000
+++ breezy/bzr/knitrepo.py	2018-06-30 17:35:22 +0000
@@ -181,7 +181,7 @@
         # Reconciling when the output has no revisions would result in no
         # writes - but we want to ensure there is an inventory for
         # compatibility with older clients that don't lazy-load.
-        result.get_parent_map([('A',)])
+        result.get_parent_map([(b'A',)])
         return result
 
     def get_revision(self, revision_id):
@@ -309,9 +309,9 @@
         result.lock_write()
         # the revision id here is irrelevant: it will not be stored, and cannot
         # already exist, we do this to create files on disk for older clients.
-        result.inventories.get_parent_map([('A',)])
-        result.revisions.get_parent_map([('A',)])
-        result.signatures.get_parent_map([('A',)])
+        result.inventories.get_parent_map([(b'A',)])
+        result.revisions.get_parent_map([(b'A',)])
+        result.signatures.get_parent_map([(b'A',)])
         result.unlock()
         self._run_post_repo_init_hooks(result, a_controldir, shared)
         return result

=== modified file 'breezy/bzr/smart/repository.py'
--- breezy/bzr/smart/repository.py	2018-06-30 14:28:33 +0000
+++ breezy/bzr/smart/repository.py	2018-06-30 17:35:22 +0000
@@ -845,9 +845,8 @@
     def _tarball_of_dir(self, dirname, compression, ofile):
         import tarfile
         filename = os.path.basename(ofile.name)
-        tarball = tarfile.open(fileobj=ofile, name=filename,
-            mode='w|' + compression)
-        try:
+        with tarfile.open(fileobj=ofile, name=filename,
+                mode='w|' + compression) as tarball:
             # The tarball module only accepts ascii names, and (i guess)
             # packs them with their 8bit names.  We know all the files
             # within the repository have ASCII names so the should be safe
@@ -858,8 +857,6 @@
             if not dirname.endswith('.bzr'):
                 raise ValueError(dirname)
             tarball.add(dirname, '.bzr') # recursive by default
-        finally:
-            tarball.close()
 
 
 class SmartServerRepositoryInsertStreamLocked(SmartServerRepositoryRequest):

=== modified file 'breezy/bzr/vf_repository.py'
--- breezy/bzr/vf_repository.py	2018-06-30 14:38:26 +0000
+++ breezy/bzr/vf_repository.py	2018-06-30 17:35:22 +0000
@@ -1276,7 +1276,7 @@
         # always a tricky proposition.
         inventory_cache = lru_cache.LRUCache(10)
         batch_size = 10 # should be ~150MB on a 55K path tree
-        batch_count = len(revision_order) / batch_size + 1
+        batch_count = len(revision_order) // batch_size + 1
         processed_texts = 0
         pb.update(gettext("Calculating text parents"), processed_texts, text_count)
         for offset in range(batch_count):

=== modified file 'breezy/diff.py'
--- breezy/diff.py	2018-06-18 20:53:01 +0000
+++ breezy/diff.py	2018-06-30 17:35:22 +0000
@@ -990,7 +990,8 @@
             properties_changed.extend(get_executable_change(executable[0], executable[1]))
 
             if properties_changed:
-                prop_str = b" (properties changed: %s)" % (", ".join(properties_changed),)
+                prop_str = b" (properties changed: %s)" % (
+                        b", ".join(properties_changed),)
             else:
                 prop_str = b""
 

=== modified file 'breezy/export.py'
--- breezy/export.py	2018-05-21 21:32:43 +0000
+++ breezy/export.py	2018-06-30 17:35:22 +0000
@@ -91,7 +91,7 @@
         else:
             with open(dest, 'wb') as f:
                 for chunk in chunks:
-                    f.writelines(chunk)
+                    f.write(chunk)
 
 
 def guess_format(filename, default='dir'):

=== modified file 'breezy/export_pot.py'
--- breezy/export_pot.py	2017-08-26 19:31:51 +0000
+++ breezy/export_pot.py	2018-06-30 17:35:22 +0000
@@ -150,13 +150,14 @@
         else:
             comment = "# %s\n" % comment
         mutter("Exporting msg %r at line %d in %r", s[:20], lineno, path)
-        self.outf.write(
+        line = (
             "#: {path}:{lineno}\n"
             "{comment}"
             "msgid {msg}\n"
             "msgstr \"\"\n"
             "\n".format(
                 path=path, lineno=lineno, comment=comment, msg=_normalize(s)))
+        self.outf.write(line.encode('utf-8'))
 
     def poentry_in_context(self, context, string, comment=None):
         context = context.from_string(string)

=== modified file 'breezy/fetch.py'
--- breezy/fetch.py	2018-05-13 02:18:13 +0000
+++ breezy/fetch.py	2018-06-30 17:35:22 +0000
@@ -268,7 +268,7 @@
         parent_keys = _parent_keys_for_root_version(
             root_id, rev_id, rev_id_to_root_id_map, parent_map, repo, graph)
         yield versionedfile.FulltextContentFactory(
-            root_key, parent_keys, None, '')
+            root_key, parent_keys, None, b'')
 
 
 def _parent_keys_for_root_version(

=== modified file 'breezy/merge_directive.py'
--- breezy/merge_directive.py	2018-06-29 23:04:43 +0000
+++ breezy/merge_directive.py	2018-06-30 17:35:22 +0000
@@ -253,7 +253,7 @@
         :return: a string
         """
         my_gpg = gpg.GPGStrategy(branch.get_config_stack())
-        return my_gpg.sign(''.join(self.to_lines()), gpg.MODE_CLEAR)
+        return my_gpg.sign(b''.join(self.to_lines()), gpg.MODE_CLEAR)
 
     def to_email(self, mail_to, branch, sign=False):
         """Serialize as an email message.
@@ -273,7 +273,7 @@
         if sign:
             body = self.to_signed(branch)
         else:
-            body = ''.join(self.to_lines())
+            body = b''.join(self.to_lines())
         message = email_message.EmailMessage(mail_from, mail_to, subject,
             body)
         return message
@@ -349,7 +349,7 @@
                           ' client %s does not support message bodies.',
                         mail_client.__class__.__name__)
         mail_client.compose_merge_request(to, subject,
-                                          ''.join(self.to_lines()),
+                                          b''.join(self.to_lines()),
                                           basename, body)
 
 
@@ -437,7 +437,7 @@
             patch = None
             patch_type = None
         else:
-            patch = ''.join(patch_lines)
+            patch = b''.join(patch_lines)
             try:
                 bundle_serializer.read_bundle(BytesIO(patch))
             except (errors.NotABundle, errors.BundleNotSupported,
@@ -522,19 +522,19 @@
         except StopIteration:
             pass
         else:
-            if start.startswith('# Begin patch'):
+            if start.startswith(b'# Begin patch'):
                 patch_lines = []
                 for line in line_iter:
-                    if line.startswith('# Begin bundle'):
+                    if line.startswith(b'# Begin bundle'):
                         start = line
                         break
                     patch_lines.append(line)
                 else:
                     start = None
-                patch = ''.join(patch_lines)
+                patch = b''.join(patch_lines)
             if start is not None:
-                if start.startswith('# Begin bundle'):
-                    bundle = ''.join(line_iter)
+                if start.startswith(b'# Begin bundle'):
+                    bundle = b''.join(line_iter)
                 else:
                     raise errors.IllegalMergeDirectivePayload(start)
         time, timezone = timestamp.parse_patch_date(stanza.get('timestamp'))

=== modified file 'breezy/plugins/git/__init__.py'
--- breezy/plugins/git/__init__.py	2018-06-17 11:15:04 +0000
+++ breezy/plugins/git/__init__.py	2018-06-30 17:35:22 +0000
@@ -151,10 +151,11 @@
         headers = {"Content-Type": "application/x-git-upload-pack-request"}
         req = Request('GET', url, accepted_errors=[200, 403, 404, 405],
                       headers=headers)
-        if req.get_host() == "github.com":
+        (scheme, user, password, host, port, path) = urlutils.parse_url(req.get_full_url())
+        if host == "github.com":
             # GitHub requires we lie. https://github.com/dulwich/dulwich/issues/562
             req.add_header("User-Agent", user_agent_for_github())
-        elif req.get_host() == "bazaar.launchpad.net":
+        elif host == "bazaar.launchpad.net":
             # Don't attempt Git probes against bazaar.launchpad.net; pad.lv/1744830
             raise bzr_errors.NotBranchError(transport.base)
         req.follow_redirections = True

=== modified file 'breezy/plugins/git/cache.py'
--- breezy/plugins/git/cache.py	2018-06-30 12:28:52 +0000
+++ breezy/plugins/git/cache.py	2018-06-30 17:35:22 +0000
@@ -529,10 +529,10 @@
             (type_name, hexsha) = obj
             sha = hex_to_sha(hexsha)
         else:
-            type_name = obj.type_name
+            type_name = obj.type_name.decode('ascii')
             sha = obj.sha().digest()
         if type_name == "commit":
-            self.db["commit\0" + self.revid] = "\0".join((sha, obj.tree))
+            self.db[b"commit\0" + self.revid] = b"\0".join((sha, obj.tree))
             if type(bzr_key_data) is not dict:
                 raise TypeError(bzr_key_data)
             type_data = (self.revid, obj.tree)
@@ -544,7 +544,7 @@
         elif type_name == "blob":
             if bzr_key_data is None:
                 return
-            self.db["\0".join(("blob", bzr_key_data[0], bzr_key_data[1]))] = sha
+            self.db[b"\0".join((b"blob", bzr_key_data[0], bzr_key_data[1]))] = sha
             type_data = bzr_key_data
         elif type_name == "tree":
             if bzr_key_data is None:
@@ -552,17 +552,17 @@
             type_data = bzr_key_data
         else:
             raise AssertionError
-        entry = "\0".join((type_name, ) + type_data) + "\n"
-        key = "git\0" + sha
+        entry = b"\0".join((type_name.encode('ascii'), ) + type_data) + b"\n"
+        key = b"git\0" + sha
         try:
             oldval = self.db[key]
         except KeyError:
             self.db[key] = entry
         else:
-            if oldval[-1] != "\n":
-                self.db[key] = "".join([oldval, "\n", entry])
+            if not oldval.endswith(b'\n'):
+                self.db[key] = b"".join([oldval, b"\n", entry])
             else:
-                self.db[key] = "".join([oldval, entry])
+                self.db[key] = b"".join([oldval, entry])
 
     def finish(self):
         if self._commit is None:
@@ -619,13 +619,13 @@
                                           os.O_RDWR|os.O_CREAT)
             self.db = mapdbs()[path]
         try:
-            if int(self.db["version"]) not in (2, 3):
+            if int(self.db[b"version"]) not in (2, 3):
                 trace.warning("SHA Map is incompatible (%s -> %d), rebuilding database.",
-                              self.db["version"], self.TDB_MAP_VERSION)
+                              self.db[b"version"], self.TDB_MAP_VERSION)
                 self.db.clear()
         except KeyError:
             pass
-        self.db["version"] = str(self.TDB_MAP_VERSION)
+        self.db[b"version"] = b'%d' % self.TDB_MAP_VERSION
 
     def start_write_group(self):
         """Start writing changes."""
@@ -644,12 +644,12 @@
 
     def lookup_commit(self, revid):
         try:
-            return sha_to_hex(self.db["commit\0" + revid][:20])
+            return sha_to_hex(self.db[b"commit\0" + revid][:20])
         except KeyError:
             raise KeyError("No cache entry for %r" % revid)
 
     def lookup_blob_id(self, fileid, revision):
-        return sha_to_hex(self.db["\0".join(("blob", fileid, revision))])
+        return sha_to_hex(self.db[b"\0".join(("blob", fileid, revision))])
 
     def lookup_git_sha(self, sha):
         """Lookup a Git sha in the database.
@@ -662,36 +662,37 @@
         """
         if len(sha) == 40:
             sha = hex_to_sha(sha)
-        value = self.db["git\0" + sha]
+        value = self.db[b"git\0" + sha]
         for data in value.splitlines():
-            data = data.split("\0")
-            if data[0] == "commit":
+            data = data.split(b"\0")
+            type_name = data[0].decode('ascii')
+            if type_name == "commit":
                 if len(data) == 3:
-                    yield (data[0], (data[1], data[2], {}))
+                    yield (type_name, (data[1], data[2], {}))
                 else:
-                    yield (data[0], (data[1], data[2], {"testament3-sha1": data[3]}))
-            elif data[0] in ("tree", "blob"):
-                yield (data[0], tuple(data[1:]))
+                    yield (type_name, (data[1], data[2], {"testament3-sha1": data[3]}))
+            elif type_name in ("tree", "blob"):
+                yield (type_name, tuple(data[1:]))
             else:
-                raise AssertionError("unknown type %r" % data[0])
+                raise AssertionError("unknown type %r" % type_name)
 
     def missing_revisions(self, revids):
         ret = set()
         for revid in revids:
-            if self.db.get("commit\0" + revid) is None:
+            if self.db.get(b"commit\0" + revid) is None:
                 ret.add(revid)
         return ret
 
     def revids(self):
         """List the revision ids known."""
         for key in self.db.iterkeys():
-            if key.startswith("commit\0"):
+            if key.startswith(b"commit\0"):
                 yield key[7:]
 
     def sha1s(self):
         """List the SHA1s."""
         for key in self.db.iterkeys():
-            if key.startswith("git\0"):
+            if key.startswith(b"git\0"):
                 yield sha_to_hex(key[4:])
 
 

=== modified file 'breezy/plugins/git/tests/test_cache.py'
--- breezy/plugins/git/tests/test_cache.py	2018-06-30 12:28:52 +0000
+++ breezy/plugins/git/tests/test_cache.py	2018-06-30 17:35:22 +0000
@@ -60,32 +60,32 @@
 
     def _get_test_commit(self):
         c = Commit()
-        c.committer = "Jelmer <[e-mail]>"
+        c.committer = b"Jelmer <[e-mail]>"
         c.commit_time = 0
         c.commit_timezone = 0
-        c.author = "Jelmer <[e-mail]>"
+        c.author = b"Jelmer <[e-mail]>"
         c.author_time = 0
         c.author_timezone = 0
-        c.message = "Teh foo bar"
-        c.tree = "cc9462f7f8263ef5adfbeff2fb936bb36b504cba"
+        c.message = b"Teh foo bar"
+        c.tree = b"cc9462f7f8263ef5adfbeff2fb936bb36b504cba"
         return c
 
     def test_commit(self):
         self.map.start_write_group()
-        updater = self.cache.get_updater(Revision("myrevid"))
+        updater = self.cache.get_updater(Revision(b"myrevid"))
         c = self._get_test_commit()
         updater.add_object(c, {
-            "testament3-sha1": "cc9462f7f8263ef5adf8eff2fb936bb36b504cba"},
+            "testament3-sha1": b"cc9462f7f8263ef5adf8eff2fb936bb36b504cba"},
             None)
         updater.finish()
         self.map.commit_write_group()
         self.assertEqual(
-            [("commit", ("myrevid",
-                "cc9462f7f8263ef5adfbeff2fb936bb36b504cba",
-                {"testament3-sha1": "cc9462f7f8263ef5adf8eff2fb936bb36b504cba"},
+            [("commit", (b"myrevid",
+                b"cc9462f7f8263ef5adfbeff2fb936bb36b504cba",
+                {"testament3-sha1": b"cc9462f7f8263ef5adf8eff2fb936bb36b504cba"},
                 ))],
             list(self.map.lookup_git_sha(c.id)))
-        self.assertEqual(c.id, self.map.lookup_commit("myrevid"))
+        self.assertEqual(c.id, self.map.lookup_commit(b"myrevid"))
 
     def test_lookup_notfound(self):
         self.assertRaises(KeyError, list,

=== modified file 'breezy/plugins/git/tests/test_object_store.py'
--- breezy/plugins/git/tests/test_object_store.py	2018-05-27 18:00:21 +0000
+++ breezy/plugins/git/tests/test_object_store.py	2018-06-30 17:35:22 +0000
@@ -234,25 +234,25 @@
         self.assertEqual(None, t)
 
     def test_empty_dir(self):
-        child_ie = InventoryDirectory('bar', 'bar', 'bar')
+        child_ie = InventoryDirectory(b'bar', 'bar', b'bar')
         t = directory_to_tree('', [child_ie], lambda p, x: None, {}, None,
                 allow_empty=False)
         self.assertEqual(None, t)
 
     def test_empty_dir_dummy_files(self):
-        child_ie = InventoryDirectory('bar', 'bar', 'bar')
+        child_ie = InventoryDirectory(b'bar', 'bar', b'bar')
         t = directory_to_tree('', [child_ie], lambda p, x: None, {}, ".mydummy",
                 allow_empty=False)
         self.assertTrue(".mydummy" in t)
 
     def test_empty_root(self):
-        child_ie = InventoryDirectory('bar', 'bar', 'bar')
+        child_ie = InventoryDirectory(b'bar', 'bar', b'bar')
         t = directory_to_tree('', [child_ie], lambda p, x: None, {}, None,
                 allow_empty=True)
         self.assertEqual(Tree(), t)
 
     def test_with_file(self):
-        child_ie = InventoryFile('bar', 'bar', 'bar')
+        child_ie = InventoryFile(b'bar', 'bar', b'bar')
         b = Blob.from_string("bla")
         t1 = directory_to_tree('', [child_ie], lambda p, x: b.id, {}, None,
                 allow_empty=False)
@@ -261,8 +261,8 @@
         self.assertEqual(t1, t2)
 
     def test_with_gitdir(self):
-        child_ie = InventoryFile('bar', 'bar', 'bar')
-        git_file_ie = InventoryFile('gitid', '.git', 'bar')
+        child_ie = InventoryFile(b'bar', 'bar', b'bar')
+        git_file_ie = InventoryFile(b'gitid', '.git', b'bar')
         b = Blob.from_string("bla")
         t1 = directory_to_tree('', [child_ie, git_file_ie],
                 lambda p, x: b.id, {}, None,

=== modified file 'breezy/shelf.py'
--- breezy/shelf.py	2018-06-16 11:29:34 +0000
+++ breezy/shelf.py	2018-06-30 17:35:22 +0000
@@ -266,7 +266,7 @@
             to_transform.adjust_path(name, s_parent_id, s_trans_id)
             if existing_path is None:
                 if kind is None:
-                    to_transform.create_file('', s_trans_id)
+                    to_transform.create_file([b''], s_trans_id)
                 else:
                     transform.create_from_tree(
                             to_transform, s_trans_id, tree,

=== modified file 'breezy/tests/__init__.py'
--- breezy/tests/__init__.py	2018-06-22 01:50:22 +0000
+++ breezy/tests/__init__.py	2018-06-30 17:35:22 +0000
@@ -1524,7 +1524,8 @@
     def assertFileEqual(self, content, path):
         """Fail if path does not contain 'content'."""
         self.assertPathExists(path)
-        with open(path, 'rb') as f:
+        
+        with open(path, 'r' + ('b' if isinstance(content, bytes) else '')) as f:
             s = f.read()
         self.assertEqualDiff(content, s)
 

=== modified file 'breezy/tests/http_server.py'
--- breezy/tests/http_server.py	2018-04-01 02:02:12 +0000
+++ breezy/tests/http_server.py	2018-06-30 17:35:22 +0000
@@ -26,6 +26,7 @@
 import random
 import re
 import socket
+import sys
 try:
     from urlparse import urlparse
 except ImportError:
@@ -125,7 +126,7 @@
         self.send_header('Connection', 'close')
         self.end_headers()
         if self.command != 'HEAD' and code >= 200 and code not in (204, 304):
-            self.wfile.write(content)
+            self.wfile.write(content.encode('utf-8'))
 
     def _handle_one_request(self):
         http_server.SimpleHTTPRequestHandler.handle_one_request(self)
@@ -339,7 +340,8 @@
         # abandon query parameters
         path = urlparse(path)[2]
         path = posixpath.normpath(urlutils.unquote(path))
-        path = path.decode('utf-8')
+        if sys.version_info[0] == 2:
+             path = path.decode('utf-8')
         words = path.split('/')
         path = self._cwd
         for num, word in enumerate(w for w in words if w):

=== modified file 'breezy/tests/per_intertree/test_compare.py'
--- breezy/tests/per_intertree/test_compare.py	2018-06-16 13:09:13 +0000
+++ breezy/tests/per_intertree/test_compare.py	2018-06-30 17:35:22 +0000
@@ -755,8 +755,8 @@
         tree2 = self.get_tree_no_parents_abc_content(tree2)
         # the pathname is chosen to fall between 'a' and 'b'.
         self.build_tree(['1/a-empty/', '2/a-empty/'])
-        tree1.add(['a-empty'], ['a-empty'])
-        tree2.add(['a-empty'], ['a-empty'])
+        tree1.add(['a-empty'], [b'a-empty'])
+        tree2.add(['a-empty'], [b'a-empty'])
         tree1, tree2 = self.mutable_trees_to_test_trees(self, tree1, tree2)
         expected = []
         self.assertEqual(expected, self.do_iter_changes(tree1, tree2))

=== modified file 'breezy/tests/per_repository/test_signatures.py'
--- breezy/tests/per_repository/test_signatures.py	2018-03-25 00:39:16 +0000
+++ breezy/tests/per_repository/test_signatures.py	2018-06-30 17:35:22 +0000
@@ -48,10 +48,10 @@
         repo.start_write_group()
         repo.sign_revision(a, strategy)
         repo.commit_write_group()
-        self.assertEqual('-----BEGIN PSEUDO-SIGNED CONTENT-----\n' +
+        self.assertEqual(b'-----BEGIN PSEUDO-SIGNED CONTENT-----\n' +
                          Testament.from_revision(repo,
                          a).as_short_text() +
-                         '-----END PSEUDO-SIGNED CONTENT-----\n',
+                         b'-----END PSEUDO-SIGNED CONTENT-----\n',
                          repo.get_signature_text(a))
 
     def test_store_signature(self):
@@ -62,7 +62,7 @@
             branch.repository.start_write_group()
             try:
                 branch.repository.store_revision_signature(
-                    gpg.LoopbackGPGStrategy(None), 'FOO', 'A')
+                    gpg.LoopbackGPGStrategy(None), b'FOO', b'A')
             except errors.NoSuchRevision:
                 branch.repository.abort_write_group()
                 raise tests.TestNotApplicable(
@@ -78,11 +78,11 @@
         # A signature without a revision should not be accessible.
         self.assertRaises(errors.NoSuchRevision,
                           branch.repository.has_signature_for_revision_id,
-                          'A')
+                          b'A')
         if wt.branch.repository._format.supports_setting_revision_ids:
             wt.commit("base", rev_id=b'A', allow_pointless=True)
-            self.assertEqual('-----BEGIN PSEUDO-SIGNED CONTENT-----\n'
-                             'FOO-----END PSEUDO-SIGNED CONTENT-----\n',
+            self.assertEqual(b'-----BEGIN PSEUDO-SIGNED CONTENT-----\n'
+                             b'FOO-----END PSEUDO-SIGNED CONTENT-----\n',
                              branch.repository.get_signature_text('A'))
 
     def test_clone_preserves_signatures(self):
@@ -118,9 +118,9 @@
         repo.start_write_group()
         repo.sign_revision(a, strategy)
         repo.commit_write_group()
-        self.assertEqual('-----BEGIN PSEUDO-SIGNED CONTENT-----\n' +
+        self.assertEqual(b'-----BEGIN PSEUDO-SIGNED CONTENT-----\n' +
                          Testament.from_revision(repo, a).as_short_text() +
-                         '-----END PSEUDO-SIGNED CONTENT-----\n',
+                         b'-----END PSEUDO-SIGNED CONTENT-----\n',
                          repo.get_signature_text(a))
         self.assertEqual(
             (gpg.SIGNATURE_VALID, None),
@@ -136,9 +136,9 @@
         repo.start_write_group()
         repo.sign_revision(a, strategy)
         repo.commit_write_group()
-        self.assertEqual('-----BEGIN PSEUDO-SIGNED CONTENT-----\n' +
+        self.assertEqual(b'-----BEGIN PSEUDO-SIGNED CONTENT-----\n' +
                          Testament.from_revision(repo, a).as_short_text() +
-                         '-----END PSEUDO-SIGNED CONTENT-----\n',
+                         b'-----END PSEUDO-SIGNED CONTENT-----\n',
                          repo.get_signature_text(a))
         self.assertEqual(
             [(a, gpg.SIGNATURE_VALID, None),
@@ -153,7 +153,7 @@
             raise tests.TestNotApplicable(
                 "repository supports signing revisions")
         wt = self.make_branch_and_tree('source')
-        a = wt.commit('A', allow_pointless=True)
+        a = wt.commit(b'A', allow_pointless=True)
         repo = wt.branch.repository
         repo.lock_write()
         repo.start_write_group()

=== modified file 'breezy/tests/per_repository_vf/test_repository.py'
--- breezy/tests/per_repository_vf/test_repository.py	2018-06-19 01:27:34 +0000
+++ breezy/tests/per_repository_vf/test_repository.py	2018-06-30 17:35:22 +0000
@@ -330,7 +330,7 @@
             tree_a.branch.repository.start_write_group()
             try:
                 inv_file = tree_a.branch.repository.inventories
-                inv_file.add_lines(('orphan',), [], [])
+                inv_file.add_lines((b'orphan',), [], [])
             except:
                 tree_a.branch.repository.commit_write_group()
                 raise
@@ -370,7 +370,7 @@
         repository.lock_read()
         self.addCleanup(repository.unlock)
         revisions = [repository.get_revision(r) for r in
-                     ['rev1', 'rev2', 'rev3', 'rev4']]
+                     [b'rev1', b'rev2', b'rev3', b'rev4']]
         deltas1 = list(repository.get_deltas_for_revisions(revisions))
         deltas2 = [repository.get_revision_delta(r.revision_id) for r in
                    revisions]
@@ -378,7 +378,7 @@
 
     def test_all_revision_ids(self):
         # all_revision_ids -> all revisions
-        self.assertEqual({'rev1', 'rev2', 'rev3', 'rev4'},
+        self.assertEqual({b'rev1', b'rev2', b'rev3', b'rev4'},
             set(self.controldir.open_repository().all_revision_ids()))
 
     def test_reserved_id(self):
@@ -387,11 +387,11 @@
         repo.start_write_group()
         try:
             self.assertRaises(errors.ReservedId, repo.add_inventory,
-                'reserved:', None, None)
+                b'reserved:', None, None)
             self.assertRaises(errors.ReservedId, repo.add_inventory_by_delta,
-                "foo", [], 'reserved:', None)
+                "foo", [], b'reserved:', None)
             self.assertRaises(errors.ReservedId, repo.add_revision,
-                'reserved:', None)
+                b'reserved:', None)
         finally:
             repo.abort_write_group()
             repo.unlock()
@@ -408,37 +408,37 @@
         repo = self.make_repository('inventory_with_unnecessary_ghost')
         repo.lock_write()
         repo.start_write_group()
-        inv = inventory.Inventory(revision_id = 'ghost')
-        inv.root.revision = 'ghost'
+        inv = inventory.Inventory(revision_id = b'ghost')
+        inv.root.revision = b'ghost'
         if repo.supports_rich_root():
             root_id = inv.root.file_id
-            repo.texts.add_lines((root_id, 'ghost'), [], [])
-        sha1 = repo.add_inventory('ghost', inv, [])
+            repo.texts.add_lines((root_id, b'ghost'), [], [])
+        sha1 = repo.add_inventory(b'ghost', inv, [])
         rev = _mod_revision.Revision(
             timestamp=0, timezone=None, committer="Foo Bar <[e-mail]>",
             message="Message", inventory_sha1=sha1, revision_id=b'ghost')
-        rev.parent_ids = ['the_ghost']
+        rev.parent_ids = [b'the_ghost']
         try:
-            repo.add_revision('ghost', rev)
+            repo.add_revision(b'ghost', rev)
         except (errors.NoSuchRevision, errors.RevisionNotPresent):
             raise tests.TestNotApplicable(
                 "Cannot test with ghosts for this format.")
 
-        inv = inventory.Inventory(revision_id = 'the_ghost')
-        inv.root.revision = 'the_ghost'
+        inv = inventory.Inventory(revision_id = b'the_ghost')
+        inv.root.revision = b'the_ghost'
         if repo.supports_rich_root():
             root_id = inv.root.file_id
-            repo.texts.add_lines((root_id, 'the_ghost'), [], [])
-        sha1 = repo.add_inventory('the_ghost', inv, [])
+            repo.texts.add_lines((root_id, b'the_ghost'), [], [])
+        sha1 = repo.add_inventory(b'the_ghost', inv, [])
         rev = _mod_revision.Revision(
             timestamp=0, timezone=None, committer="Foo Bar <[e-mail]>",
             message="Message", inventory_sha1=sha1, revision_id=b'the_ghost')
         rev.parent_ids = []
-        repo.add_revision('the_ghost', rev)
+        repo.add_revision(b'the_ghost', rev)
         # check its setup usefully
         inv_weave = repo.inventories
-        possible_parents = (None, (('ghost',),))
-        self.assertSubset(inv_weave.get_parent_map([('ghost',)])[('ghost',)],
+        possible_parents = (None, ((b'ghost',),))
+        self.assertSubset(inv_weave.get_parent_map([(b'ghost',)])[(b'ghost',)],
             possible_parents)
         repo.commit_write_group()
         repo.unlock()
@@ -446,19 +446,19 @@
     def test_corrupt_revision_access_asserts_if_reported_wrong(self):
         repo_url = self.get_url('inventory_with_unnecessary_ghost')
         repo = _mod_repository.Repository.open(repo_url)
-        m = MatchesAncestry(repo, 'ghost')
+        m = MatchesAncestry(repo, b'ghost')
         reported_wrong = False
         try:
-            if m.match(['the_ghost', 'ghost']) is not None:
+            if m.match([b'the_ghost', b'ghost']) is not None:
                 reported_wrong = True
         except errors.CorruptRepository:
             # caught the bad data:
             return
         if not reported_wrong:
             return
-        self.assertRaises(errors.CorruptRepository, repo.get_revision, 'ghost')
+        self.assertRaises(errors.CorruptRepository, repo.get_revision, b'ghost')
 
     def test_corrupt_revision_get_revision_reconcile(self):
         repo_url = self.get_url('inventory_with_unnecessary_ghost')
         repo = _mod_repository.Repository.open(repo_url)
-        repo.get_revision_reconcile('ghost')
+        repo.get_revision_reconcile(b'ghost')

=== modified file 'breezy/tests/per_tree/test_tree.py'
--- breezy/tests/per_tree/test_tree.py	2018-06-17 11:15:04 +0000
+++ breezy/tests/per_tree/test_tree.py	2018-06-30 17:35:22 +0000
@@ -65,12 +65,12 @@
         tree_b.lock_read()
         self.addCleanup(tree_b.unlock)
         self.assertEqual([
-            ('killed-a', 'a\n'),
-            ('killed-b', 'b\n'),
-            ('unchanged', 'c\n'),
-            ('unchanged', 'd\n'),
-            ('new-a', 'e\n'),
-            ('new-b', 'f\n'),
+            ('killed-a', b'a\n'),
+            ('killed-b', b'b\n'),
+            ('unchanged', b'c\n'),
+            ('unchanged', b'd\n'),
+            ('new-a', b'e\n'),
+            ('new-b', b'f\n'),
         ], list(tree_a.plan_file_merge(file_id, tree_b)))
 
 
@@ -115,7 +115,7 @@
         tree = self.make_branch_and_tree('tree')
         root_id = tree.get_root_id()
         if root_id is not None:
-            self.assertIsInstance(root_id, str)
+            self.assertIsInstance(root_id, bytes)
 
     def test_is_versioned(self):
         tree = self.make_branch_and_tree('tree')

=== modified file 'breezy/tests/per_workingtree/test_parents.py'
--- breezy/tests/per_workingtree/test_parents.py	2018-06-19 18:31:46 +0000
+++ breezy/tests/per_workingtree/test_parents.py	2018-06-30 17:35:22 +0000
@@ -79,25 +79,25 @@
 
     def test_set_null_parent(self):
         t = self.make_branch_and_tree('.')
-        self.assertRaises(errors.ReservedId, t.set_parent_ids, ['null:'],
+        self.assertRaises(errors.ReservedId, t.set_parent_ids, [b'null:'],
                           allow_leftmost_as_ghost=True)
         self.assertRaises(errors.ReservedId, t.set_parent_trees,
-                          [('null:', None)], allow_leftmost_as_ghost=True)
+                          [(b'null:', None)], allow_leftmost_as_ghost=True)
 
     def test_set_one_ghost_parent_rejects(self):
         t = self.make_branch_and_tree('.')
         self.assertRaises(errors.GhostRevisionUnusableHere,
-            t.set_parent_trees, [('missing-revision-id', None)])
+            t.set_parent_trees, [(b'missing-revision-id', None)])
 
     def test_set_one_ghost_parent_force(self):
         t = self.make_branch_and_tree('.')
         if t._format.supports_leftmost_parent_id_as_ghost:
-            t.set_parent_trees([('missing-revision-id', None)],
+            t.set_parent_trees([(b'missing-revision-id', None)],
                 allow_leftmost_as_ghost=True)
-            self.assertConsistentParents(['missing-revision-id'], t)
+            self.assertConsistentParents([b'missing-revision-id'], t)
         else:
             self.assertRaises(errors.GhostRevisionUnusableHere,
-                t.set_parent_trees, [('missing-revision-id', None)])
+                t.set_parent_trees, [(b'missing-revision-id', None)])
             self.assertConsistentParents([], t)
 
     def test_set_two_parents_one_ghost(self):
@@ -108,12 +108,12 @@
         rev_tree = t.branch.repository.revision_tree(revision_in_repo)
         if t._format.supports_righthand_parent_id_as_ghost:
             t.set_parent_trees([(revision_in_repo, rev_tree),
-                ('another-missing', None)])
-            self.assertConsistentParents([revision_in_repo, 'another-missing'], t)
+                (b'another-missing', None)])
+            self.assertConsistentParents([revision_in_repo, b'another-missing'], t)
         else:
             self.assertRaises(errors.GhostRevisionUnusableHere,
                 t.set_parent_trees, [(revision_in_repo, rev_tree),
-                ('another-missing', None)])
+                (b'another-missing', None)])
 
     def test_set_three_parents(self):
         t = self.make_branch_and_tree('.')
@@ -144,7 +144,7 @@
     def test_set_one_ghost_parent_ids_rejects(self):
         t = self.make_branch_and_tree('.')
         self.assertRaises(errors.GhostRevisionUnusableHere,
-            t.set_parent_ids, ['missing-revision-id'])
+            t.set_parent_ids, [b'missing-revision-id'])
 
     def test_set_one_ghost_parent_ids_force(self):
         t = self.make_branch_and_tree('.')
@@ -488,9 +488,9 @@
 
     def add_new_root(self, new_shape, old_revid, new_revid):
         if self.bzrdir_format.repository_format.rich_root_data:
-            self.add_dir(new_shape, old_revid, 'root-id', None, '')
+            self.add_dir(new_shape, old_revid, b'root-id', None, '')
         else:
-            self.add_dir(new_shape, new_revid, 'root-id', None, '')
+            self.add_dir(new_shape, new_revid, b'root-id', None, '')
 
     def assertTransitionFromBasisToShape(self, basis_shape, basis_revid,
         new_shape, new_revid, extra_parent=None, set_current_inventory=True):
@@ -533,66 +533,66 @@
     def test_no_parents_full_tree(self):
         """Test doing a regular initial commit with files and dirs."""
         basis_shape = Inventory(root_id=None) # empty tree
-        revid = 'new-parent'
+        revid = b'new-parent'
         new_shape = Inventory(root_id=None)
-        self.add_dir(new_shape, revid, 'root-id', None, '')
-        self.add_link(new_shape, revid, 'link-id', 'root-id', 'link', 'target')
-        self.add_file(new_shape, revid, 'file-id', 'root-id', 'file', '1' * 32,
+        self.add_dir(new_shape, revid, b'root-id', None, '')
+        self.add_link(new_shape, revid, b'link-id', b'root-id', 'link', 'target')
+        self.add_file(new_shape, revid, b'file-id', b'root-id', 'file', '1' * 32,
             12)
-        self.add_dir(new_shape, revid, 'dir-id', 'root-id', 'dir')
-        self.add_file(new_shape, revid, 'subfile-id', 'dir-id', 'subfile',
+        self.add_dir(new_shape, revid, b'dir-id', b'root-id', 'dir')
+        self.add_file(new_shape, revid, b'subfile-id', b'dir-id', 'subfile',
             '2' * 32, 24)
         self.assertTransitionFromBasisToShape(basis_shape, None, new_shape,
             revid)
 
     def test_file_content_change(self):
-        old_revid = 'old-parent'
+        old_revid = b'old-parent'
         basis_shape = Inventory(root_id=None)
-        self.add_dir(basis_shape, old_revid, 'root-id', None, '')
-        self.add_file(basis_shape, old_revid, 'file-id', 'root-id', 'file',
+        self.add_dir(basis_shape, old_revid, b'root-id', None, '')
+        self.add_file(basis_shape, old_revid, b'file-id', b'root-id', 'file',
             '1' * 32, 12)
-        new_revid = 'new-parent'
+        new_revid = b'new-parent'
         new_shape = Inventory(root_id=None)
         self.add_new_root(new_shape, old_revid, new_revid)
-        self.add_file(new_shape, new_revid, 'file-id', 'root-id', 'file',
+        self.add_file(new_shape, new_revid, b'file-id', b'root-id', 'file',
             '2' * 32, 24)
         self.assertTransitionFromBasisToShape(basis_shape, old_revid,
             new_shape, new_revid)
 
     def test_link_content_change(self):
-        old_revid = 'old-parent'
+        old_revid = b'old-parent'
         basis_shape = Inventory(root_id=None)
-        self.add_dir(basis_shape, old_revid, 'root-id', None, '')
-        self.add_link(basis_shape, old_revid, 'link-id', 'root-id', 'link',
+        self.add_dir(basis_shape, old_revid, b'root-id', None, '')
+        self.add_link(basis_shape, old_revid, b'link-id', b'root-id', 'link',
             'old-target')
-        new_revid = 'new-parent'
+        new_revid = b'new-parent'
         new_shape = Inventory(root_id=None)
         self.add_new_root(new_shape, old_revid, new_revid)
-        self.add_link(new_shape, new_revid, 'link-id', 'root-id', 'link',
+        self.add_link(new_shape, new_revid, b'link-id', b'root-id', 'link',
             'new-target')
         self.assertTransitionFromBasisToShape(basis_shape, old_revid,
             new_shape, new_revid)
 
     def test_kind_changes(self):
         def do_file(inv, revid):
-            self.add_file(inv, revid, 'path-id', 'root-id', 'path', '1' * 32,
+            self.add_file(inv, revid, b'path-id', b'root-id', 'path', '1' * 32,
                 12)
 
         def do_link(inv, revid):
-            self.add_link(inv, revid, 'path-id', 'root-id', 'path', 'target')
+            self.add_link(inv, revid, b'path-id', b'root-id', 'path', 'target')
 
         def do_dir(inv, revid):
-            self.add_dir(inv, revid, 'path-id', 'root-id', 'path')
+            self.add_dir(inv, revid, b'path-id', b'root-id', 'path')
 
         for old_factory in (do_file, do_link, do_dir):
             for new_factory in (do_file, do_link, do_dir):
                 if old_factory == new_factory:
                     continue
-                old_revid = 'old-parent'
+                old_revid = b'old-parent'
                 basis_shape = Inventory(root_id=None)
-                self.add_dir(basis_shape, old_revid, 'root-id', None, '')
+                self.add_dir(basis_shape, old_revid, b'root-id', None, '')
                 old_factory(basis_shape, old_revid)
-                new_revid = 'new-parent'
+                new_revid = b'new-parent'
                 new_shape = Inventory(root_id=None)
                 self.add_new_root(new_shape, old_revid, new_revid)
                 new_factory(new_shape, new_revid)
@@ -602,23 +602,23 @@
     def test_content_from_second_parent_is_dropped(self):
         left_revid = 'left-parent'
         basis_shape = Inventory(root_id=None)
-        self.add_dir(basis_shape, left_revid, 'root-id', None, '')
-        self.add_link(basis_shape, left_revid, 'link-id', 'root-id', 'link',
+        self.add_dir(basis_shape, left_revid, b'root-id', None, '')
+        self.add_link(basis_shape, left_revid, b'link-id', b'root-id', 'link',
             'left-target')
         # the right shape has content - file, link, subdir with a child,
         # that should all be discarded by the call.
         right_revid = 'right-parent'
         right_shape = Inventory(root_id=None)
-        self.add_dir(right_shape, left_revid, 'root-id', None, '')
-        self.add_link(right_shape, right_revid, 'link-id', 'root-id', 'link',
+        self.add_dir(right_shape, left_revid, b'root-id', None, '')
+        self.add_link(right_shape, right_revid, b'link-id', b'root-id', 'link',
             'some-target')
-        self.add_dir(right_shape, right_revid, 'subdir-id', 'root-id', 'dir')
-        self.add_file(right_shape, right_revid, 'file-id', 'subdir-id', 'file',
+        self.add_dir(right_shape, right_revid, b'subdir-id', b'root-id', 'dir')
+        self.add_file(right_shape, right_revid, b'file-id', b'subdir-id', 'file',
             '2' * 32, 24)
-        new_revid = 'new-parent'
+        new_revid = b'new-parent'
         new_shape = Inventory(root_id=None)
         self.add_new_root(new_shape, left_revid, new_revid)
-        self.add_link(new_shape, new_revid, 'link-id', 'root-id', 'link',
+        self.add_link(new_shape, new_revid, b'link-id', b'root-id', 'link',
             'new-target')
         self.assertTransitionFromBasisToShape(basis_shape, left_revid,
             new_shape, new_revid, right_revid)
@@ -626,123 +626,123 @@
     def test_parent_id_changed(self):
         # test that when the only change to an entry is its parent id changing
         # that it is handled correctly (that is it keeps the same path)
-        old_revid = 'old-parent'
+        old_revid = b'old-parent'
         basis_shape = Inventory(root_id=None)
-        self.add_dir(basis_shape, old_revid, 'root-id', None, '')
-        self.add_dir(basis_shape, old_revid, 'orig-parent-id', 'root-id', 'dir')
-        self.add_dir(basis_shape, old_revid, 'dir-id', 'orig-parent-id', 'dir')
-        new_revid = 'new-parent'
+        self.add_dir(basis_shape, old_revid, b'root-id', None, '')
+        self.add_dir(basis_shape, old_revid, b'orig-parent-id', b'root-id', 'dir')
+        self.add_dir(basis_shape, old_revid, b'dir-id', b'orig-parent-id', 'dir')
+        new_revid = b'new-parent'
         new_shape = Inventory(root_id=None)
         self.add_new_root(new_shape, old_revid, new_revid)
-        self.add_dir(new_shape, new_revid, 'new-parent-id', 'root-id', 'dir')
-        self.add_dir(new_shape, new_revid, 'dir-id', 'new-parent-id', 'dir')
+        self.add_dir(new_shape, new_revid, b'new-parent-id', b'root-id', 'dir')
+        self.add_dir(new_shape, new_revid, b'dir-id', b'new-parent-id', 'dir')
         self.assertTransitionFromBasisToShape(basis_shape, old_revid,
             new_shape, new_revid)
 
     def test_name_changed(self):
         # test that when the only change to an entry is its name changing that
         # it is handled correctly (that is it keeps the same parent id)
-        old_revid = 'old-parent'
+        old_revid = b'old-parent'
         basis_shape = Inventory(root_id=None)
-        self.add_dir(basis_shape, old_revid, 'root-id', None, '')
-        self.add_dir(basis_shape, old_revid, 'parent-id', 'root-id', 'origdir')
-        self.add_dir(basis_shape, old_revid, 'dir-id', 'parent-id', 'olddir')
-        new_revid = 'new-parent'
+        self.add_dir(basis_shape, old_revid, b'root-id', None, '')
+        self.add_dir(basis_shape, old_revid, b'parent-id', b'root-id', 'origdir')
+        self.add_dir(basis_shape, old_revid, b'dir-id', b'parent-id', 'olddir')
+        new_revid = b'new-parent'
         new_shape = Inventory(root_id=None)
         self.add_new_root(new_shape, old_revid, new_revid)
-        self.add_dir(new_shape, new_revid, 'parent-id', 'root-id', 'newdir')
-        self.add_dir(new_shape, new_revid, 'dir-id', 'parent-id', 'newdir')
+        self.add_dir(new_shape, new_revid, b'parent-id', b'root-id', 'newdir')
+        self.add_dir(new_shape, new_revid, b'dir-id', b'parent-id', 'newdir')
         self.assertTransitionFromBasisToShape(basis_shape, old_revid,
             new_shape, new_revid)
 
     def test_parent_child_swap(self):
         # test a A->A/B and A/B->A path swap.
-        old_revid = 'old-parent'
+        old_revid = b'old-parent'
         basis_shape = Inventory(root_id=None)
-        self.add_dir(basis_shape, old_revid, 'root-id', None, '')
-        self.add_dir(basis_shape, old_revid, 'dir-id-A', 'root-id', 'A')
-        self.add_dir(basis_shape, old_revid, 'dir-id-B', 'dir-id-A', 'B')
-        self.add_link(basis_shape, old_revid, 'link-id-C', 'dir-id-B', 'C', 'C')
-        new_revid = 'new-parent'
+        self.add_dir(basis_shape, old_revid, b'root-id', None, '')
+        self.add_dir(basis_shape, old_revid, b'dir-id-A', b'root-id', 'A')
+        self.add_dir(basis_shape, old_revid, b'dir-id-B', b'dir-id-A', 'B')
+        self.add_link(basis_shape, old_revid, b'link-id-C', b'dir-id-B', 'C', 'C')
+        new_revid = b'new-parent'
         new_shape = Inventory(root_id=None)
         self.add_new_root(new_shape, old_revid, new_revid)
-        self.add_dir(new_shape, new_revid, 'dir-id-B', 'root-id', 'A')
-        self.add_dir(new_shape, new_revid, 'dir-id-A', 'dir-id-B', 'B')
-        self.add_link(new_shape, new_revid, 'link-id-C', 'dir-id-A', 'C', 'C')
+        self.add_dir(new_shape, new_revid, b'dir-id-B', b'root-id', 'A')
+        self.add_dir(new_shape, new_revid, b'dir-id-A', b'dir-id-B', 'B')
+        self.add_link(new_shape, new_revid, b'link-id-C', b'dir-id-A', 'C', 'C')
         self.assertTransitionFromBasisToShape(basis_shape, old_revid,
             new_shape, new_revid)
 
     def test_parent_deleted_child_renamed(self):
         # test a A->None and A/B->A.
-        old_revid = 'old-parent'
+        old_revid = b'old-parent'
         basis_shape = Inventory(root_id=None)
-        self.add_dir(basis_shape, old_revid, 'root-id', None, '')
-        self.add_dir(basis_shape, old_revid, 'dir-id-A', 'root-id', 'A')
-        self.add_dir(basis_shape, old_revid, 'dir-id-B', 'dir-id-A', 'B')
-        self.add_link(basis_shape, old_revid, 'link-id-C', 'dir-id-B', 'C', 'C')
-        new_revid = 'new-parent'
+        self.add_dir(basis_shape, old_revid, b'root-id', None, '')
+        self.add_dir(basis_shape, old_revid, b'dir-id-A', b'root-id', 'A')
+        self.add_dir(basis_shape, old_revid, b'dir-id-B', b'dir-id-A', 'B')
+        self.add_link(basis_shape, old_revid, b'link-id-C', b'dir-id-B', 'C', 'C')
+        new_revid = b'new-parent'
         new_shape = Inventory(root_id=None)
         self.add_new_root(new_shape, old_revid, new_revid)
-        self.add_dir(new_shape, new_revid, 'dir-id-B', 'root-id', 'A')
-        self.add_link(new_shape, old_revid, 'link-id-C', 'dir-id-B', 'C', 'C')
+        self.add_dir(new_shape, new_revid, b'dir-id-B', b'root-id', 'A')
+        self.add_link(new_shape, old_revid, b'link-id-C', b'dir-id-B', 'C', 'C')
         self.assertTransitionFromBasisToShape(basis_shape, old_revid,
             new_shape, new_revid)
 
     def test_dir_to_root(self):
         # test a A->''.
-        old_revid = 'old-parent'
+        old_revid = b'old-parent'
         basis_shape = Inventory(root_id=None)
-        self.add_dir(basis_shape, old_revid, 'root-id', None, '')
-        self.add_dir(basis_shape, old_revid, 'dir-id-A', 'root-id', 'A')
-        self.add_link(basis_shape, old_revid, 'link-id-B', 'dir-id-A', 'B', 'B')
-        new_revid = 'new-parent'
+        self.add_dir(basis_shape, old_revid, b'root-id', None, '')
+        self.add_dir(basis_shape, old_revid, b'dir-id-A', b'root-id', 'A')
+        self.add_link(basis_shape, old_revid, b'link-id-B', b'dir-id-A', 'B', 'B')
+        new_revid = b'new-parent'
         new_shape = Inventory(root_id=None)
-        self.add_dir(new_shape, new_revid, 'dir-id-A', None, '')
-        self.add_link(new_shape, old_revid, 'link-id-B', 'dir-id-A', 'B', 'B')
+        self.add_dir(new_shape, new_revid, b'dir-id-A', None, '')
+        self.add_link(new_shape, old_revid, b'link-id-B', b'dir-id-A', 'B', 'B')
         self.assertTransitionFromBasisToShape(basis_shape, old_revid,
             new_shape, new_revid)
 
     def test_path_swap(self):
         # test a A->B and B->A path swap.
-        old_revid = 'old-parent'
+        old_revid = b'old-parent'
         basis_shape = Inventory(root_id=None)
-        self.add_dir(basis_shape, old_revid, 'root-id', None, '')
-        self.add_dir(basis_shape, old_revid, 'dir-id-A', 'root-id', 'A')
-        self.add_dir(basis_shape, old_revid, 'dir-id-B', 'root-id', 'B')
-        self.add_link(basis_shape, old_revid, 'link-id-C', 'root-id', 'C', 'C')
-        self.add_link(basis_shape, old_revid, 'link-id-D', 'root-id', 'D', 'D')
-        self.add_file(basis_shape, old_revid, 'file-id-E', 'root-id', 'E',
+        self.add_dir(basis_shape, old_revid, b'root-id', None, '')
+        self.add_dir(basis_shape, old_revid, b'dir-id-A', b'root-id', 'A')
+        self.add_dir(basis_shape, old_revid, b'dir-id-B', b'root-id', 'B')
+        self.add_link(basis_shape, old_revid, b'link-id-C', b'root-id', 'C', 'C')
+        self.add_link(basis_shape, old_revid, b'link-id-D', b'root-id', 'D', 'D')
+        self.add_file(basis_shape, old_revid, b'file-id-E', b'root-id', 'E',
             '1' * 32, 12)
-        self.add_file(basis_shape, old_revid, 'file-id-F', 'root-id', 'F',
+        self.add_file(basis_shape, old_revid, b'file-id-F', b'root-id', 'F',
             '2' * 32, 24)
-        new_revid = 'new-parent'
+        new_revid = b'new-parent'
         new_shape = Inventory(root_id=None)
         self.add_new_root(new_shape, old_revid, new_revid)
-        self.add_dir(new_shape, new_revid, 'dir-id-A', 'root-id', 'B')
-        self.add_dir(new_shape, new_revid, 'dir-id-B', 'root-id', 'A')
-        self.add_link(new_shape, new_revid, 'link-id-C', 'root-id', 'D', 'C')
-        self.add_link(new_shape, new_revid, 'link-id-D', 'root-id', 'C', 'D')
-        self.add_file(new_shape, new_revid, 'file-id-E', 'root-id', 'F',
+        self.add_dir(new_shape, new_revid, b'dir-id-A', b'root-id', 'B')
+        self.add_dir(new_shape, new_revid, b'dir-id-B', b'root-id', 'A')
+        self.add_link(new_shape, new_revid, b'link-id-C', b'root-id', 'D', 'C')
+        self.add_link(new_shape, new_revid, b'link-id-D', b'root-id', 'C', 'D')
+        self.add_file(new_shape, new_revid, b'file-id-E', b'root-id', 'F',
             '1' * 32, 12)
-        self.add_file(new_shape, new_revid, 'file-id-F', 'root-id', 'E',
+        self.add_file(new_shape, new_revid, b'file-id-F', b'root-id', 'E',
             '2' * 32, 24)
         self.assertTransitionFromBasisToShape(basis_shape, old_revid,
             new_shape, new_revid)
 
     def test_adds(self):
         # test adding paths and dirs, including adding to a newly added dir.
-        old_revid = 'old-parent'
+        old_revid = b'old-parent'
         basis_shape = Inventory(root_id=None)
         # with a root, so its a commit after the first.
-        self.add_dir(basis_shape, old_revid, 'root-id', None, '')
-        new_revid = 'new-parent'
+        self.add_dir(basis_shape, old_revid, b'root-id', None, '')
+        new_revid = b'new-parent'
         new_shape = Inventory(root_id=None)
         self.add_new_root(new_shape, old_revid, new_revid)
-        self.add_dir(new_shape, new_revid, 'dir-id-A', 'root-id', 'A')
-        self.add_link(new_shape, new_revid, 'link-id-B', 'root-id', 'B', 'C')
-        self.add_file(new_shape, new_revid, 'file-id-C', 'root-id', 'C',
+        self.add_dir(new_shape, new_revid, b'dir-id-A', b'root-id', 'A')
+        self.add_link(new_shape, new_revid, b'link-id-B', b'root-id', 'B', 'C')
+        self.add_file(new_shape, new_revid, b'file-id-C', b'root-id', 'C',
             '1' * 32, 12)
-        self.add_file(new_shape, new_revid, 'file-id-D', 'dir-id-A', 'D',
+        self.add_file(new_shape, new_revid, b'file-id-D', b'dir-id-A', 'D',
             '2' * 32, 24)
         self.assertTransitionFromBasisToShape(basis_shape, old_revid,
             new_shape, new_revid)
@@ -750,75 +750,75 @@
     def test_removes(self):
         # test removing paths, including paths that are within other also
         # removed paths.
-        old_revid = 'old-parent'
+        old_revid = b'old-parent'
         basis_shape = Inventory(root_id=None)
-        self.add_dir(basis_shape, old_revid, 'root-id', None, '')
-        self.add_dir(basis_shape, old_revid, 'dir-id-A', 'root-id', 'A')
-        self.add_link(basis_shape, old_revid, 'link-id-B', 'root-id', 'B', 'C')
-        self.add_file(basis_shape, old_revid, 'file-id-C', 'root-id', 'C',
+        self.add_dir(basis_shape, old_revid, b'root-id', None, '')
+        self.add_dir(basis_shape, old_revid, b'dir-id-A', b'root-id', 'A')
+        self.add_link(basis_shape, old_revid, b'link-id-B', b'root-id', 'B', 'C')
+        self.add_file(basis_shape, old_revid, b'file-id-C', b'root-id', 'C',
             '1' * 32, 12)
-        self.add_file(basis_shape, old_revid, 'file-id-D', 'dir-id-A', 'D',
+        self.add_file(basis_shape, old_revid, b'file-id-D', b'dir-id-A', 'D',
             '2' * 32, 24)
-        new_revid = 'new-parent'
+        new_revid = b'new-parent'
         new_shape = Inventory(root_id=None)
         self.add_new_root(new_shape, old_revid, new_revid)
         self.assertTransitionFromBasisToShape(basis_shape, old_revid,
             new_shape, new_revid)
 
     def test_move_to_added_dir(self):
-        old_revid = 'old-parent'
+        old_revid = b'old-parent'
         basis_shape = Inventory(root_id=None)
-        self.add_dir(basis_shape, old_revid, 'root-id', None, '')
-        self.add_link(basis_shape, old_revid, 'link-id-B', 'root-id', 'B', 'C')
-        new_revid = 'new-parent'
+        self.add_dir(basis_shape, old_revid, b'root-id', None, '')
+        self.add_link(basis_shape, old_revid, b'link-id-B', b'root-id', 'B', 'C')
+        new_revid = b'new-parent'
         new_shape = Inventory(root_id=None)
         self.add_new_root(new_shape, old_revid, new_revid)
-        self.add_dir(new_shape, new_revid, 'dir-id-A', 'root-id', 'A')
-        self.add_link(new_shape, new_revid, 'link-id-B', 'dir-id-A', 'B', 'C')
+        self.add_dir(new_shape, new_revid, b'dir-id-A', b'root-id', 'A')
+        self.add_link(new_shape, new_revid, b'link-id-B', b'dir-id-A', 'B', 'C')
         self.assertTransitionFromBasisToShape(basis_shape, old_revid,
             new_shape, new_revid)
 
     def test_move_from_removed_dir(self):
-        old_revid = 'old-parent'
+        old_revid = b'old-parent'
         basis_shape = Inventory(root_id=None)
-        self.add_dir(basis_shape, old_revid, 'root-id', None, '')
-        self.add_dir(basis_shape, old_revid, 'dir-id-A', 'root-id', 'A')
-        self.add_link(basis_shape, old_revid, 'link-id-B', 'dir-id-A', 'B', 'C')
-        new_revid = 'new-parent'
+        self.add_dir(basis_shape, old_revid, b'root-id', None, '')
+        self.add_dir(basis_shape, old_revid, b'dir-id-A', b'root-id', 'A')
+        self.add_link(basis_shape, old_revid, b'link-id-B', b'dir-id-A', 'B', 'C')
+        new_revid = b'new-parent'
         new_shape = Inventory(root_id=None)
         self.add_new_root(new_shape, old_revid, new_revid)
-        self.add_link(new_shape, new_revid, 'link-id-B', 'root-id', 'B', 'C')
+        self.add_link(new_shape, new_revid, b'link-id-B', b'root-id', 'B', 'C')
         self.assertTransitionFromBasisToShape(basis_shape, old_revid,
             new_shape, new_revid)
 
     def test_move_moves_children_recursively(self):
-        old_revid = 'old-parent'
+        old_revid = b'old-parent'
         basis_shape = Inventory(root_id=None)
-        self.add_dir(basis_shape, old_revid, 'root-id', None, '')
-        self.add_dir(basis_shape, old_revid, 'dir-id-A', 'root-id', 'A')
-        self.add_dir(basis_shape, old_revid, 'dir-id-B', 'dir-id-A', 'B')
-        self.add_link(basis_shape, old_revid, 'link-id-C', 'dir-id-B', 'C', 'D')
-        new_revid = 'new-parent'
+        self.add_dir(basis_shape, old_revid, b'root-id', None, '')
+        self.add_dir(basis_shape, old_revid, b'dir-id-A', b'root-id', 'A')
+        self.add_dir(basis_shape, old_revid, b'dir-id-B', b'dir-id-A', 'B')
+        self.add_link(basis_shape, old_revid, b'link-id-C', b'dir-id-B', 'C', 'D')
+        new_revid = b'new-parent'
         new_shape = Inventory(root_id=None)
         self.add_new_root(new_shape, old_revid, new_revid)
         # the moved path:
-        self.add_dir(new_shape, new_revid, 'dir-id-A', 'root-id', 'B')
+        self.add_dir(new_shape, new_revid, b'dir-id-A', b'root-id', 'B')
         # unmoved children.
-        self.add_dir(new_shape, old_revid, 'dir-id-B', 'dir-id-A', 'B')
-        self.add_link(new_shape, old_revid, 'link-id-C', 'dir-id-B', 'C', 'D')
+        self.add_dir(new_shape, old_revid, b'dir-id-B', b'dir-id-A', 'B')
+        self.add_link(new_shape, old_revid, b'link-id-C', b'dir-id-B', 'C', 'D')
         self.assertTransitionFromBasisToShape(basis_shape, old_revid,
             new_shape, new_revid)
 
     def test_add_files_to_empty_directory(self):
-        old_revid = 'old-parent'
+        old_revid = b'old-parent'
         basis_shape = Inventory(root_id=None)
-        self.add_dir(basis_shape, old_revid, 'root-id', None, '')
-        self.add_dir(basis_shape, old_revid, 'dir-id-A', 'root-id', 'A')
-        new_revid = 'new-parent'
+        self.add_dir(basis_shape, old_revid, b'root-id', None, '')
+        self.add_dir(basis_shape, old_revid, b'dir-id-A', b'root-id', 'A')
+        new_revid = b'new-parent'
         new_shape = Inventory(root_id=None)
         self.add_new_root(new_shape, old_revid, new_revid)
-        self.add_dir(new_shape, old_revid, 'dir-id-A', 'root-id', 'A')
-        self.add_file(new_shape, new_revid, 'file-id-B', 'dir-id-A', 'B',
+        self.add_dir(new_shape, old_revid, b'dir-id-A', b'root-id', 'A')
+        self.add_file(new_shape, new_revid, b'file-id-B', b'dir-id-A', 'B',
             '1' * 32, 24)
         self.assertTransitionFromBasisToShape(basis_shape, old_revid,
                 new_shape, new_revid, set_current_inventory=False)

=== modified file 'breezy/tests/test_conflicts.py'
--- breezy/tests/test_conflicts.py	2018-06-21 23:03:42 +0000
+++ breezy/tests/test_conflicts.py	2018-06-30 17:35:22 +0000
@@ -76,7 +76,7 @@
                                   ('hello.BASE', b'hello world1'),
                                   ])
         os.mkdir('hello.OTHER')
-        tree.add('hello', 'q')
+        tree.add('hello', b'q')
         l = conflicts.ConflictList([conflicts.TextConflict('hello')])
         l.remove_files(tree)
 
@@ -144,7 +144,7 @@
         self.assertIsInstance(o.path, text_type)
 
         if o.file_id is not None:
-            self.assertIsInstance(o.file_id, str)
+            self.assertIsInstance(o.file_id, bytes)
 
         conflict_path = getattr(o, 'conflict_path', None)
         if conflict_path is not None:
@@ -152,7 +152,7 @@
 
         conflict_file_id = getattr(o, 'conflict_file_id', None)
         if conflict_file_id is not None:
-            self.assertIsInstance(conflict_file_id, str)
+            self.assertIsInstance(conflict_file_id, bytes)
 
     def test_stanzification(self):
         stanza = self.conflict.as_stanza()
@@ -329,7 +329,7 @@
     def _merge_other_into_this(self):
         b = self.builder.get_branch()
         wt = b.controldir.sprout('branch').open_workingtree()
-        wt.merge_from_branch(b, 'other')
+        wt.merge_from_branch(b, b'other')
         return wt
 
     def assertConflict(self, wt):
@@ -377,14 +377,14 @@
         [
             # File modified on both sides
             (dict(_base_actions='create_file',
-                  _path='file', _file_id='file-id'),
+                  _path='file', _file_id=b'file-id'),
              ('filed_modified_A',
               dict(actions='modify_file_A', check='file_has_content_A')),
              ('file_modified_B',
               dict(actions='modify_file_B', check='file_has_content_B')),),
             # File modified on both sides in dir
             (dict(_base_actions='create_file_in_dir',
-                  _path='dir/file', _file_id='file-id'),
+                  _path='dir/file', _file_id=b'file-id'),
              ('filed_modified_A_in_dir',
               dict(actions='modify_file_A_in_dir',
                    check='file_in_dir_has_content_A')),
@@ -394,30 +394,30 @@
             ])
 
     def do_create_file(self, path='file'):
-        return [('add', (path, 'file-id', 'file', 'trunk content\n'))]
+        return [('add', (path, b'file-id', 'file', b'trunk content\n'))]
 
     def do_modify_file_A(self):
-        return [('modify', ('file', 'trunk content\nfeature A\n'))]
+        return [('modify', ('file', b'trunk content\nfeature A\n'))]
 
     def do_modify_file_B(self):
-        return [('modify', ('file', 'trunk content\nfeature B\n'))]
+        return [('modify', ('file', b'trunk content\nfeature B\n'))]
 
     def do_modify_file_A_in_dir(self):
-        return [('modify', ('dir/file', 'trunk content\nfeature A\n'))]
+        return [('modify', ('dir/file', b'trunk content\nfeature A\n'))]
 
     def do_modify_file_B_in_dir(self):
-        return [('modify', ('dir/file', 'trunk content\nfeature B\n'))]
+        return [('modify', ('dir/file', b'trunk content\nfeature B\n'))]
 
     def check_file_has_content_A(self, path='file'):
-        self.assertFileEqual('trunk content\nfeature A\n',
+        self.assertFileEqual(b'trunk content\nfeature A\n',
                              osutils.pathjoin('branch', path))
 
     def check_file_has_content_B(self, path='file'):
-        self.assertFileEqual('trunk content\nfeature B\n',
+        self.assertFileEqual(b'trunk content\nfeature B\n',
                              osutils.pathjoin('branch', path))
 
     def do_create_file_in_dir(self):
-        return [('add', ('dir', 'dir-id', 'directory', '')),
+        return [('add', ('dir', b'dir-id', 'directory', '')),
             ] + self.do_create_file('dir/file')
 
     def check_file_in_dir_has_content_A(self):
@@ -448,14 +448,14 @@
         [
             # File modified/deleted
             (dict(_base_actions='create_file',
-                  _path='file', _file_id='file-id'),
+                  _path='file', _file_id=b'file-id'),
              ('file_modified',
               dict(actions='modify_file', check='file_has_more_content')),
              ('file_deleted',
               dict(actions='delete_file', check='file_doesnt_exist')),),
             # File renamed-modified/deleted
             (dict(_base_actions='create_file',
-                  _path='new-file', _file_id='file-id'),
+                  _path='new-file', _file_id=b'file-id'),
              ('file_renamed_and_modified',
               dict(actions='modify_and_rename_file',
                    check='file_renamed_and_more_content')),
@@ -463,7 +463,7 @@
               dict(actions='delete_file', check='file_doesnt_exist')),),
             # File modified/deleted in dir
             (dict(_base_actions='create_file_in_dir',
-                  _path='dir/file', _file_id='file-id'),
+                  _path='dir/file', _file_id=b'file-id'),
              ('file_modified_in_dir',
               dict(actions='modify_file_in_dir',
                    check='file_in_dir_has_more_content')),
@@ -473,20 +473,20 @@
             ])
 
     def do_create_file(self):
-        return [('add', ('file', 'file-id', 'file', 'trunk content\n'))]
+        return [('add', ('file', b'file-id', 'file', b'trunk content\n'))]
 
     def do_modify_file(self):
-        return [('modify', ('file', 'trunk content\nmore content\n'))]
+        return [('modify', ('file', b'trunk content\nmore content\n'))]
 
     def do_modify_and_rename_file(self):
-        return [('modify', ('new-file', 'trunk content\nmore content\n')),
+        return [('modify', ('new-file', b'trunk content\nmore content\n')),
                 ('rename', ('file', 'new-file'))]
 
     def check_file_has_more_content(self):
-        self.assertFileEqual('trunk content\nmore content\n', 'branch/file')
+        self.assertFileEqual(b'trunk content\nmore content\n', 'branch/file')
 
     def check_file_renamed_and_more_content(self):
-        self.assertFileEqual('trunk content\nmore content\n', 'branch/new-file')
+        self.assertFileEqual(b'trunk content\nmore content\n', 'branch/new-file')
 
     def do_delete_file(self):
         return [('unversion', 'file')]
@@ -498,14 +498,14 @@
         self.assertPathDoesNotExist('branch/file')
 
     def do_create_file_in_dir(self):
-        return [('add', ('dir', 'dir-id', 'directory', '')),
-                ('add', ('dir/file', 'file-id', 'file', 'trunk content\n'))]
+        return [('add', ('dir', b'dir-id', 'directory', '')),
+                ('add', ('dir/file', b'file-id', 'file', b'trunk content\n'))]
 
     def do_modify_file_in_dir(self):
-        return [('modify', ('dir/file', 'trunk content\nmore content\n'))]
+        return [('modify', ('dir/file', b'trunk content\nmore content\n'))]
 
     def check_file_in_dir_has_more_content(self):
-        self.assertFileEqual('trunk content\nmore content\n', 'branch/dir/file')
+        self.assertFileEqual(b'trunk content\nmore content\n', 'branch/dir/file')
 
     def check_file_in_dir_doesnt_exist(self):
         self.assertPathDoesNotExist('branch/dir/file')
@@ -535,55 +535,55 @@
             (dict(_base_actions='create_file'),
              ('file_renamed',
               dict(actions='rename_file', check='file_renamed',
-                   path='new-file', file_id='file-id')),
+                   path='new-file', file_id=b'file-id')),
              ('file_deleted',
               dict(actions='delete_file', check='file_doesnt_exist',
                    # PathConflicts deletion handling requires a special
                    # hard-coded value
-                   path='<deleted>', file_id='file-id')),),
+                   path='<deleted>', file_id=b'file-id')),),
             # File renamed/deleted in dir
             (dict(_base_actions='create_file_in_dir'),
              ('file_renamed_in_dir',
               dict(actions='rename_file_in_dir', check='file_in_dir_renamed',
-                   path='dir/new-file', file_id='file-id')),
+                   path='dir/new-file', file_id=b'file-id')),
              ('file_deleted',
               dict(actions='delete_file_in_dir', check='file_in_dir_doesnt_exist',
                    # PathConflicts deletion handling requires a special
                    # hard-coded value
-                   path='<deleted>', file_id='file-id')),),
+                   path='<deleted>', file_id=b'file-id')),),
             # File renamed/renamed differently
             (dict(_base_actions='create_file'),
              ('file_renamed',
               dict(actions='rename_file', check='file_renamed',
-                   path='new-file', file_id='file-id')),
+                   path='new-file', file_id=b'file-id')),
              ('file_renamed2',
               dict(actions='rename_file2', check='file_renamed2',
-                   path='new-file2', file_id='file-id')),),
+                   path='new-file2', file_id=b'file-id')),),
             # Dir renamed/deleted
             (dict(_base_actions='create_dir'),
              ('dir_renamed',
               dict(actions='rename_dir', check='dir_renamed',
-                   path='new-dir', file_id='dir-id')),
+                   path='new-dir', file_id=b'dir-id')),
              ('dir_deleted',
               dict(actions='delete_dir', check='dir_doesnt_exist',
                    # PathConflicts deletion handling requires a special
                    # hard-coded value
-                   path='<deleted>', file_id='dir-id')),),
+                   path='<deleted>', file_id=b'dir-id')),),
             # Dir renamed/renamed differently
             (dict(_base_actions='create_dir'),
              ('dir_renamed',
               dict(actions='rename_dir', check='dir_renamed',
-                   path='new-dir', file_id='dir-id')),
+                   path='new-dir', file_id=b'dir-id')),
              ('dir_renamed2',
               dict(actions='rename_dir2', check='dir_renamed2',
-                   path='new-dir2', file_id='dir-id')),),
+                   path='new-dir2', file_id=b'dir-id')),),
             ])
 
     def do_create_file(self):
-        return [('add', ('file', 'file-id', 'file', 'trunk content\n'))]
+        return [('add', ('file', b'file-id', 'file', b'trunk content\n'))]
 
     def do_create_dir(self):
-        return [('add', ('dir', 'dir-id', 'directory', ''))]
+        return [('add', ('dir', b'dir-id', 'directory', ''))]
 
     def do_rename_file(self):
         return [('rename', ('file', 'new-file'))]
@@ -629,8 +629,8 @@
         self.assertPathDoesNotExist('branch/dir')
 
     def do_create_file_in_dir(self):
-        return [('add', ('dir', 'dir-id', 'directory', '')),
-                ('add', ('dir/file', 'file-id', 'file', 'trunk content\n'))]
+        return [('add', ('dir', b'dir-id', 'directory', '')),
+                ('add', ('dir/file', b'file-id', 'file', b'trunk content\n'))]
 
     def do_rename_file_in_dir(self):
         return [('rename', ('dir/file', 'dir/new-file'))]
@@ -686,44 +686,44 @@
             (dict(_base_actions='nothing'),
              ('filea_created',
               dict(actions='create_file_a', check='file_content_a',
-                   path='file', file_id='file-a-id')),
+                   path='file', file_id=b'file-a-id')),
              ('fileb_created',
               dict(actions='create_file_b', check='file_content_b',
-                   path='file', file_id='file-b-id')),),
+                   path='file', file_id=b'file-b-id')),),
             # File created with different file-ids but deleted on one side
             (dict(_base_actions='create_file_a'),
              ('filea_replaced',
               dict(actions='replace_file_a_by_b', check='file_content_b',
-                   path='file', file_id='file-b-id')),
+                   path='file', file_id=b'file-b-id')),
              ('filea_modified',
               dict(actions='modify_file_a', check='file_new_content',
-                   path='file', file_id='file-a-id')),),
+                   path='file', file_id=b'file-a-id')),),
             ])
 
     def do_nothing(self):
         return []
 
     def do_create_file_a(self):
-        return [('add', ('file', 'file-a-id', 'file', 'file a content\n'))]
+        return [('add', ('file', b'file-a-id', 'file', b'file a content\n'))]
 
     def check_file_content_a(self):
-        self.assertFileEqual('file a content\n', 'branch/file')
+        self.assertFileEqual(b'file a content\n', 'branch/file')
 
     def do_create_file_b(self):
-        return [('add', ('file', 'file-b-id', 'file', 'file b content\n'))]
+        return [('add', ('file', b'file-b-id', 'file', b'file b content\n'))]
 
     def check_file_content_b(self):
-        self.assertFileEqual('file b content\n', 'branch/file')
+        self.assertFileEqual(b'file b content\n', 'branch/file')
 
     def do_replace_file_a_by_b(self):
         return [('unversion', 'file'),
-                ('add', ('file', 'file-b-id', 'file', 'file b content\n'))]
+                ('add', ('file', b'file-b-id', 'file', b'file b content\n'))]
 
     def do_modify_file_a(self):
-        return [('modify', ('file', 'new content\n'))]
+        return [('modify', ('file', b'new content\n'))]
 
     def check_file_new_content(self):
-        self.assertFileEqual('new content\n', 'branch/file')
+        self.assertFileEqual(b'new content\n', 'branch/file')
 
     def _get_resolve_path_arg(self, wt, action):
         return self._this['path']
@@ -933,23 +933,23 @@
             (dict(_base_actions='create_dir1_dir2'),
              ('dir1_into_dir2',
               dict(actions='move_dir1_into_dir2', check='dir1_moved',
-                   dir_id='dir1-id', target_id='dir2-id', xfail=False)),
+                   dir_id=b'dir1-id', target_id='dir2-id', xfail=False)),
              ('dir2_into_dir1',
               dict(actions='move_dir2_into_dir1', check='dir2_moved',
-                   dir_id='dir2-id', target_id='dir1-id', xfail=False))),
+                   dir_id=b'dir2-id', target_id='dir1-id', xfail=False))),
             # Subdirs moved into each other
             (dict(_base_actions='create_dir1_4'),
              ('dir1_into_dir4',
               dict(actions='move_dir1_into_dir4', check='dir1_2_moved',
-                   dir_id='dir1-id', target_id='dir4-id', xfail=True)),
+                   dir_id=b'dir1-id', target_id='dir4-id', xfail=True)),
              ('dir3_into_dir2',
               dict(actions='move_dir3_into_dir2', check='dir3_4_moved',
-                   dir_id='dir3-id', target_id='dir2-id', xfail=True))),
+                   dir_id=b'dir3-id', target_id='dir2-id', xfail=True))),
             ])
 
     def do_create_dir1_dir2(self):
-        return [('add', ('dir1', 'dir1-id', 'directory', '')),
-                ('add', ('dir2', 'dir2-id', 'directory', '')),]
+        return [('add', ('dir1', b'dir1-id', 'directory', '')),
+                ('add', ('dir2', b'dir2-id', 'directory', '')),]
 
     def do_move_dir1_into_dir2(self):
         return [('rename', ('dir1', 'dir2/dir1'))]
@@ -966,10 +966,10 @@
         self.assertPathExists('branch/dir1/dir2')
 
     def do_create_dir1_4(self):
-        return [('add', ('dir1', 'dir1-id', 'directory', '')),
-                ('add', ('dir1/dir2', 'dir2-id', 'directory', '')),
-                ('add', ('dir3', 'dir3-id', 'directory', '')),
-                ('add', ('dir3/dir4', 'dir4-id', 'directory', '')),]
+        return [('add', ('dir1', b'dir1-id', 'directory', '')),
+                ('add', ('dir1/dir2', b'dir2-id', 'directory', '')),
+                ('add', ('dir3', b'dir3-id', 'directory', '')),
+                ('add', ('dir3/dir4', b'dir4-id', 'directory', '')),]
 
     def do_move_dir1_into_dir4(self):
         return [('rename', ('dir1', 'dir3/dir4/dir1'))]
@@ -994,8 +994,8 @@
         return wt.id2path(self._other['dir_id'])
 
     def assertParentLoop(self, wt, c):
-        self.assertEqual(self._other['dir_id'], c.file_id)
-        self.assertEqual(self._other['target_id'], c.conflict_file_id)
+        self.assertEqual(self._other[b'dir_id'], c.file_id)
+        self.assertEqual(self._other[b'target_id'], c.conflict_file_id)
         # The conflict paths are irrelevant (they are deterministic but not
         # worth checking since they don't provide the needed information
         # anyway)

=== modified file 'breezy/tests/test_export.py'
--- breezy/tests/test_export.py	2018-05-20 12:21:54 +0000
+++ breezy/tests/test_export.py	2018-06-30 17:35:22 +0000
@@ -115,10 +115,10 @@
         builder = self.make_branch_builder('source')
         builder.start_series()
         builder.build_snapshot(None, [
-            ('add', ('', 'root-id', 'directory', '')),
-            ('add', ('a', 'a-id', 'file', 'content\n'))])
+            ('add', ('', b'root-id', 'directory', '')),
+            ('add', ('a', b'a-id', 'file', b'content\n'))])
         builder.build_snapshot(None, [
-            ('add', ('b', 'b-id', 'file', 'content\n'))])
+            ('add', ('b', b'b-id', 'file', b'content\n'))])
         builder.finish_series()
         b = builder.get_branch()
         b.lock_read()
@@ -146,11 +146,11 @@
         a_time = time.mktime((1999, 12, 12, 0, 0, 0, 0, 0, 0))
         b_time = time.mktime((1980, 0o1, 0o1, 0, 0, 0, 0, 0, 0))
         builder.build_snapshot(None, [
-            ('add', ('', 'root-id', 'directory', '')),
-            ('add', ('a', 'a-id', 'file', 'content\n'))],
+            ('add', ('', b'root-id', 'directory', '')),
+            ('add', ('a', b'a-id', 'file', b'content\n'))],
             timestamp=a_time)
         builder.build_snapshot(None, [
-            ('add', ('b', 'b-id', 'file', 'content\n'))],
+            ('add', ('b', b'b-id', 'file', b'content\n'))],
             timestamp=b_time)
         builder.finish_series()
         b = builder.get_branch()
@@ -167,9 +167,9 @@
         builder.start_series()
         foo_time = time.mktime((1999, 12, 12, 0, 0, 0, 0, 0, 0))
         builder.build_snapshot(None, [
-            ('add', ('', 'root-id', 'directory', '')),
-            ('add', ('subdir', 'subdir-id', 'directory', '')),
-            ('add', ('subdir/foo.txt', 'foo-id', 'file', 'content\n'))],
+            ('add', ('', b'root-id', 'directory', '')),
+            ('add', ('subdir', b'subdir-id', 'directory', '')),
+            ('add', ('subdir/foo.txt', b'foo-id', 'file', b'content\n'))],
             timestamp=foo_time)
         builder.finish_series()
         b = builder.get_branch()
@@ -228,18 +228,18 @@
             per_file_timestamps=True)
         export.export(wt, 'testdir2/target.tar.gz', format="tgz",
             per_file_timestamps=True)
-        file1 = open('testdir1/target.tar.gz', 'r')
+        file1 = open('testdir1/target.tar.gz', 'rb')
         self.addCleanup(file1.close)
-        file2 = open('testdir1/target.tar.gz', 'r')
+        file2 = open('testdir1/target.tar.gz', 'rb')
         self.addCleanup(file2.close)
         content1 = file1.read()
         content2 = file2.read()
         self.assertEqualDiff(content1, content2)
         # the gzip module doesn't have a way to read back to the original
         # filename, but it's stored as-is in the tarfile.
-        self.assertFalse("testdir1" in content1)
-        self.assertFalse("target.tar.gz" in content1)
-        self.assertTrue("target.tar" in content1)
+        self.assertFalse(b"testdir1" in content1)
+        self.assertFalse(b"target.tar.gz" in content1)
+        self.assertTrue(b"target.tar" in content1)
 
     def test_tbz2(self):
         wt = self.make_branch_and_tree('.')

=== modified file 'breezy/tests/test_export_pot.py'
--- breezy/tests/test_export_pot.py	2018-02-17 02:02:38 +0000
+++ breezy/tests/test_export_pot.py	2018-06-30 17:35:22 +0000
@@ -237,13 +237,13 @@
 
     def test_option_without_help(self):
         opt = option.Option("helpless")
-        self.assertEqual("", self.pot_from_option(opt))
+        self.assertEqual(b"", self.pot_from_option(opt))
 
     def test_option_with_help(self):
         opt = option.Option("helpful", help="Info.")
-        self.assertContainsString(self.pot_from_option(opt), "\n"
-            "# help of 'helpful' test\n"
-            "msgid \"Info.\"\n")
+        self.assertContainsString(self.pot_from_option(opt), b"\n"
+            b"# help of 'helpful' test\n"
+            b"msgid \"Info.\"\n")
 
     def test_option_hidden(self):
         opt = option.Option("hidden", help="Unseen.", hidden=True)
@@ -253,57 +253,57 @@
         context = export_pot._ModuleContext("remote.py", 3)
         opt = option.Option("metaphor", help="Not a literal in the source.")
         self.assertContainsString(self.pot_from_option(opt, context),
-            "#: remote.py:3\n"
-            "# help of 'metaphor' test\n")
+            b"#: remote.py:3\n"
+            b"# help of 'metaphor' test\n")
 
     def test_option_context_string(self):
         s = "Literally."
         context = export_pot._ModuleContext("local.py", 3, ({}, {s: 17}))
         opt = option.Option("example", help=s)
         self.assertContainsString(self.pot_from_option(opt, context),
-            "#: local.py:17\n"
-            "# help of 'example' test\n")
+            b"#: local.py:17\n"
+            b"# help of 'example' test\n")
 
     def test_registry_option_title(self):
         opt = option.RegistryOption.from_kwargs("group", help="Pick one.",
             title="Choose!")
         pot = self.pot_from_option(opt)
-        self.assertContainsString(pot, "\n"
-            "# title of 'group' test\n"
-            "msgid \"Choose!\"\n")
-        self.assertContainsString(pot, "\n"
-            "# help of 'group' test\n"
-            "msgid \"Pick one.\"\n")
+        self.assertContainsString(pot, b"\n"
+            b"# title of 'group' test\n"
+            b"msgid \"Choose!\"\n")
+        self.assertContainsString(pot, b"\n"
+            b"# help of 'group' test\n"
+            b"msgid \"Pick one.\"\n")
 
     def test_registry_option_title_context_missing(self):
         context = export_pot._ModuleContext("theory.py", 3)
         opt = option.RegistryOption.from_kwargs("abstract", title="Unfounded!")
         self.assertContainsString(self.pot_from_option(opt, context),
-            "#: theory.py:3\n"
-            "# title of 'abstract' test\n")
+            b"#: theory.py:3\n"
+            b"# title of 'abstract' test\n")
 
     def test_registry_option_title_context_string(self):
         s = "Grounded!"
         context = export_pot._ModuleContext("practice.py", 3, ({}, {s: 144}))
         opt = option.RegistryOption.from_kwargs("concrete", title=s)
         self.assertContainsString(self.pot_from_option(opt, context),
-            "#: practice.py:144\n"
-            "# title of 'concrete' test\n")
+            b"#: practice.py:144\n"
+            b"# title of 'concrete' test\n")
 
     def test_registry_option_value_switches(self):
         opt = option.RegistryOption.from_kwargs("switch", help="Flip one.",
             value_switches=True, enum_switch=False,
             red="Big.", green="Small.")
         pot = self.pot_from_option(opt)
-        self.assertContainsString(pot, "\n"
-            "# help of 'switch' test\n"
-            "msgid \"Flip one.\"\n")
-        self.assertContainsString(pot, "\n"
-            "# help of 'switch=red' test\n"
-            "msgid \"Big.\"\n")
-        self.assertContainsString(pot, "\n"
-            "# help of 'switch=green' test\n"
-            "msgid \"Small.\"\n")
+        self.assertContainsString(pot, b"\n"
+            b"# help of 'switch' test\n"
+            b"msgid \"Flip one.\"\n")
+        self.assertContainsString(pot, b"\n"
+            b"# help of 'switch=red' test\n"
+            b"msgid \"Big.\"\n")
+        self.assertContainsString(pot, b"\n"
+            b"# help of 'switch=green' test\n"
+            b"msgid \"Small.\"\n")
 
     def test_registry_option_value_switches_hidden(self):
         reg = registry.Registry()
@@ -314,13 +314,13 @@
         opt = option.RegistryOption("protocol", "Talking.", reg,
             value_switches=True, enum_switch=False)
         pot = self.pot_from_option(opt)
-        self.assertContainsString(pot, "\n"
-            "# help of 'protocol' test\n"
-            "msgid \"Talking.\"\n")
-        self.assertContainsString(pot, "\n"
-            "# help of 'protocol=new' test\n"
-            "msgid \"Current.\"\n")
-        self.assertNotContainsString(pot, "'protocol=old'")
+        self.assertContainsString(pot, b"\n"
+            b"# help of 'protocol' test\n"
+            b"msgid \"Talking.\"\n")
+        self.assertContainsString(pot, b"\n"
+            b"# help of 'protocol=new' test\n"
+            b"msgid \"Current.\"\n")
+        self.assertNotContainsString(pot, b"'protocol=old'")
 
 
 class TestPotExporter(tests.TestCase):
@@ -333,15 +333,15 @@
         exporter.poentry_in_context(context, "Common line.")
         context.lineno = 3
         exporter.poentry_in_context(context, "Common line.")
-        self.assertEqual(1, exporter.outf.getvalue().count("Common line."))
-    
+        self.assertEqual(1, exporter.outf.getvalue().count(b"Common line."))
+
     def test_duplicates_included(self):
         exporter = export_pot._PotExporter(BytesIO(), True)
         context = export_pot._ModuleContext("mod.py", 1)
         exporter.poentry_in_context(context, "Common line.")
         context.lineno = 3
         exporter.poentry_in_context(context, "Common line.")
-        self.assertEqual(2, exporter.outf.getvalue().count("Common line."))
+        self.assertEqual(2, exporter.outf.getvalue().count(b"Common line."))
 
 
 class PoEntryTestCase(tests.TestCase):
@@ -353,7 +353,7 @@
     def check_output(self, expected):
         self.assertEqual(
                 self.exporter.outf.getvalue(),
-                textwrap.dedent(expected)
+                textwrap.dedent(expected.decode('utf-8')).encode('utf-8')
                 )
 
 
@@ -362,7 +362,7 @@
     def test_simple(self):
         self.exporter.poentry('dummy', 1, "spam")
         self.exporter.poentry('dummy', 2, "ham", 'EGG')
-        self.check_output('''\
+        self.check_output(b'''\
                 #: dummy:1
                 msgid "spam"
                 msgstr ""
@@ -379,7 +379,7 @@
         # This should be ignored.
         self.exporter.poentry('dummy', 2, "spam", 'EGG')
 
-        self.check_output('''\
+        self.check_output(b'''\
                 #: dummy:1
                 msgid "spam"
                 msgstr ""\n
@@ -394,7 +394,7 @@
                 10,
                 '''foo\nbar\nbaz\n'''
                 )
-        self.check_output('''\
+        self.check_output(b'''\
                 #: dummy:10
                 msgid ""
                 "foo\\n"
@@ -409,7 +409,7 @@
                 10,
                 '''spam\nham\negg\n\nSPAM\nHAM\nEGG\n'''
                 )
-        self.check_output('''\
+        self.check_output(b'''\
                 #: dummy:10
                 msgid ""
                 "spam\\n"
@@ -447,22 +447,22 @@
         export_pot._write_command_help(self.exporter, cmd_Demo())
         result = self.exporter.outf.getvalue()
         # We don't care about filename and lineno here.
-        result = re.sub(r'(?m)^#: [^\n]+\n', '', result)
+        result = re.sub(br'(?m)^#: [^\n]+\n', b'', result)
 
         self.assertEqualDiff(
-                'msgid "A sample command."\n'
-                'msgstr ""\n'
-                '\n'                # :Usage: should not be translated.
-                'msgid ""\n'
-                '":Examples:\\n"\n'
-                '"    Example 1::"\n'
-                'msgstr ""\n'
-                '\n'
-                'msgid "        cmd arg1"\n'
-                'msgstr ""\n'
-                '\n'
-                'msgid "Blah Blah Blah"\n'
-                'msgstr ""\n'
-                '\n',
+                b'msgid "A sample command."\n'
+                b'msgstr ""\n'
+                b'\n'                # :Usage: should not be translated.
+                b'msgid ""\n'
+                b'":Examples:\\n"\n'
+                b'"    Example 1::"\n'
+                b'msgstr ""\n'
+                b'\n'
+                b'msgid "        cmd arg1"\n'
+                b'msgstr ""\n'
+                b'\n'
+                b'msgid "Blah Blah Blah"\n'
+                b'msgstr ""\n'
+                b'\n',
                 result
                 )

=== modified file 'breezy/tests/test_fetch.py'
--- breezy/tests/test_fetch.py	2018-06-19 01:27:34 +0000
+++ breezy/tests/test_fetch.py	2018-06-30 17:35:22 +0000
@@ -517,9 +517,9 @@
 
     def test_two_fetch_changed_root(self):
         self.make_two_commits(change_root=True, fetch_twice=True)
-        self.assertEqual((), self.get_parents('unique-id', 'second-id'))
+        self.assertEqual((), self.get_parents(b'unique-id', b'second-id'))
 
     def test_two_fetches(self):
         self.make_two_commits(change_root=False, fetch_twice=True)
-        self.assertEqual((('TREE_ROOT', 'first-id'),),
-            self.get_parents('TREE_ROOT', 'second-id'))
+        self.assertEqual(((b'TREE_ROOT', b'first-id'),),
+            self.get_parents(b'TREE_ROOT', b'second-id'))

=== modified file 'breezy/tests/test_http.py'
--- breezy/tests/test_http.py	2018-05-11 00:02:31 +0000
+++ breezy/tests/test_http.py	2018-06-30 17:35:22 +0000
@@ -1203,11 +1203,11 @@
 
     def assertProxied(self):
         t = self.get_readonly_transport()
-        self.assertEqual('proxied contents of foo\n', t.get('foo').read())
+        self.assertEqual(b'proxied contents of foo\n', t.get('foo').read())
 
     def assertNotProxied(self):
         t = self.get_readonly_transport()
-        self.assertEqual('contents of foo\n', t.get('foo').read())
+        self.assertEqual(b'contents of foo\n', t.get('foo').read())
 
     def test_http_proxy(self):
         self.overrideEnv('http_proxy', self.proxy_url)
@@ -1810,12 +1810,12 @@
         httpd = self.http_server.server
 
         socket = SampleSocket(
-            'POST /.bzr/smart %s \r\n' % self._protocol_version
+            b'POST /.bzr/smart %s \r\n' % self._protocol_version.encode('ascii')
             # HTTP/1.1 posts must have a Content-Length (but it doesn't hurt
             # for 1.0)
-            + 'Content-Length: 6\r\n'
-            '\r\n'
-            'hello\n')
+            + b'Content-Length: 6\r\n'
+            b'\r\n'
+            b'hello\n')
         # Beware: the ('localhost', 80) below is the
         # client_address parameter, but we don't have one because
         # we have defined a socket which is not bound to an
@@ -1827,7 +1827,7 @@
         response = socket.writefile.getvalue()
         self.assertStartsWith(response, '%s 200 ' % self._protocol_version)
         # This includes the end of the HTTP headers, and all the body.
-        expected_end_of_response = '\r\n\r\nok\x012\n'
+        expected_end_of_response = b'\r\n\r\nok\x012\n'
         self.assertEndsWith(response, expected_end_of_response)
 
 

=== modified file 'breezy/tests/test_http_response.py'
--- breezy/tests/test_http_response.py	2017-09-26 00:55:04 +0000
+++ breezy/tests/test_http_response.py	2018-06-30 17:35:22 +0000
@@ -88,13 +88,13 @@
 
     def test_iter_many(self):
         f = response.ResponseFile('many', BytesIO(b'0\n1\nboo!\n'))
-        self.assertEqual(['0\n', '1\n', 'boo!\n'], list(f))
+        self.assertEqual([b'0\n', b'1\n', b'boo!\n'], list(f))
 
 
 class TestHTTPConnection(tests.TestCase):
 
     def test_cleanup_pipe(self):
-        sock = ReadSocket("""HTTP/1.1 200 OK\r
+        sock = ReadSocket(b"""HTTP/1.1 200 OK\r
 Content-Type: text/plain; charset=UTF-8\r
 Content-Length: 18
 \r
@@ -108,7 +108,7 @@
         # Now, get the response
         resp = conn.getresponse()
         # Read part of the response
-        self.assertEqual('0123456789\n', resp.read(11))
+        self.assertEqual(b'0123456789\n', resp.read(11))
         # Override the thresold to force the warning emission
         conn._range_warning_thresold = 6 # There are 7 bytes pending
         conn.cleanup_pipe()
@@ -122,7 +122,7 @@
     # which offsets are easy to calculate for test writers. It's used as a
     # building block with slight variations but basically 'a' is the first char
     # of the range and 'z' is the last.
-    alpha = 'abcdefghijklmnopqrstuvwxyz'
+    alpha = b'abcdefghijklmnopqrstuvwxyz'
 
     def test_can_read_at_first_access(self):
         """Test that the just created file can be read."""
@@ -137,14 +137,14 @@
         cur = start # For an overall offset assertion
         f.seek(start + 3)
         cur += 3
-        self.assertEqual('def', f.read(3))
+        self.assertEqual(b'def', f.read(3))
         cur += len('def')
         f.seek(4, 1)
         cur += 4
-        self.assertEqual('klmn', f.read(4))
+        self.assertEqual(b'klmn', f.read(4))
         cur += len('klmn')
         # read(0) in the middle of a range
-        self.assertEqual('', f.read(0))
+        self.assertEqual(b'', f.read(0))
         # seek in place
         here = f.tell()
         f.seek(0, 1)
@@ -153,9 +153,9 @@
 
     def test_read_zero(self):
         f = self._file
-        self.assertEqual('', f.read(0))
+        self.assertEqual(b'', f.read(0))
         f.seek(10, 1)
-        self.assertEqual('', f.read(0))
+        self.assertEqual(b'', f.read(0))
 
     def test_seek_at_range_end(self):
         f = self._file
@@ -165,14 +165,14 @@
         """Test read behaviour at range end."""
         f = self._file
         self.assertEqual(self.alpha, f.read())
-        self.assertEqual('', f.read(0))
+        self.assertEqual(b'', f.read(0))
         self.assertRaises(errors.InvalidRange, f.read, 1)
 
     def test_unbounded_read_after_seek(self):
         f = self._file
         f.seek(24, 1)
         # Should not cross ranges
-        self.assertEqual('yz', f.read())
+        self.assertEqual(b'yz', f.read())
 
     def test_seek_backwards(self):
         f = self._file
@@ -212,7 +212,7 @@
        """
        f = self._file
        f.seek(-2, 2)
-       self.assertEqual('yz', f.read())
+       self.assertEqual(b'yz', f.read())
 
 
 class TestRangeFileSizeUnknown(tests.TestCase, TestRangeFileMixin):
@@ -236,8 +236,8 @@
         """Test read behaviour at range end."""
         f = self._file
         self.assertEqual(self.alpha, f.read())
-        self.assertEqual('', f.read(0))
-        self.assertEqual('', f.read(1))
+        self.assertEqual(b'', f.read(0))
+        self.assertEqual(b'', f.read(1))
 
 
 class TestRangeFileSizeKnown(tests.TestCase, TestRangeFileMixin):
@@ -286,14 +286,14 @@
     # in HTTP response headers and the boundary lines that separate
     # multipart content.
 
-    boundary = "separation"
+    boundary = b"separation"
 
     def setUp(self):
         super(TestRangeFileMultipleRanges, self).setUp()
 
         boundary = self.boundary
 
-        content = ''
+        content = b''
         self.first_range_start = 25
         file_size = 200 # big enough to encompass all ranges
         for (start, part) in [(self.first_range_start, self.alpha),
@@ -311,7 +311,7 @@
 
     def _boundary_line(self):
         """Helper to build the formatted boundary line."""
-        return '--' + self.boundary + '\r\n'
+        return b'--' + self.boundary + b'\r\n'
 
     def set_file_boundary(self):
         # Ranges are set by decoding the range headers, the RangeFile user is
@@ -320,7 +320,7 @@
         # which is part of the Content-Type header).
         self._file.set_boundary(self.boundary)
 
-    def _multipart_byterange(self, data, offset, boundary, file_size='*'):
+    def _multipart_byterange(self, data, offset, boundary, file_size=b'*'):
         """Encode a part of a file as a multipart/byterange MIME type.
 
         When a range request is issued, the HTTP response body can be
@@ -342,10 +342,12 @@
         # A range is described by a set of headers, but only 'Content-Range' is
         # required for our implementation (TestHandleResponse below will
         # exercise ranges with multiple or missing headers')
-        range += 'Content-Range: bytes %d-%d/%d\r\n' % (offset,
-                                                        offset+len(data)-1,
-                                                        file_size)
-        range += '\r\n'
+        if isinstance(file_size, int):
+            file_size = b'%d' % file_size
+        range += b'Content-Range: bytes %d-%d/%s\r\n' % (offset,
+                                                         offset+len(data)-1,
+                                                         file_size)
+        range += b'\r\n'
         # Finally the raw bytes
         range += data
         return range
@@ -357,9 +359,9 @@
         self.assertEqual(self.alpha, f.read()) # Read second range
         self.assertEqual(126, f.tell())
         f.seek(126) # Start of third range which is also the current pos !
-        self.assertEqual('A', f.read(1))
+        self.assertEqual(b'A', f.read(1))
         f.seek(10, 1)
-        self.assertEqual('LMN', f.read(3))
+        self.assertEqual(b'LMN', f.read(3))
 
     def test_seek_from_end(self):
         """See TestRangeFileMixin.test_seek_from_end."""
@@ -369,7 +371,7 @@
         # behaviour.
         f = self._file
         f.seek(-2, 2)
-        self.assertEqual('yz', f.read())
+        self.assertEqual(b'yz', f.read())
         self.assertRaises(errors.InvalidRange, f.seek, -2, 2)
 
     def test_seek_into_void(self):
@@ -387,14 +389,14 @@
     def test_seek_across_ranges(self):
         f = self._file
         f.seek(126) # skip the two first ranges
-        self.assertEqual('AB', f.read(2))
+        self.assertEqual(b'AB', f.read(2))
 
     def test_checked_read_dont_overflow_buffers(self):
         f = self._file
         # We force a very low value to exercise all code paths in _checked_read
         f._discarded_buf_size = 8
         f.seek(126) # skip the two first ranges
-        self.assertEqual('AB', f.read(2))
+        self.assertEqual(b'AB', f.read(2))
 
     def test_seek_twice_between_ranges(self):
         f = self._file
@@ -435,8 +437,8 @@
     """
     # The boundary as it appears in boundary lines
     # IIS 6 and 7 use this value
-    _boundary_trimmed = "q1w2e3r4t5y6u7i8o9p0zaxscdvfbgnhmjklkl"
-    boundary = '<' + _boundary_trimmed + '>'
+    _boundary_trimmed = b"q1w2e3r4t5y6u7i8o9p0zaxscdvfbgnhmjklkl"
+    boundary = b'<' + _boundary_trimmed + b'>'
 
     def set_file_boundary(self):
         # Emulate broken rfc822.unquote() here by removing angles
@@ -485,7 +487,7 @@
 
 
 # Taken from real request responses
-_full_text_response = (200, """HTTP/1.1 200 OK\r
+_full_text_response = (200, b"""HTTP/1.1 200 OK\r
 Date: Tue, 11 Jul 2006 04:32:56 GMT\r
 Server: Apache/2.0.54 (Fedora)\r
 Last-Modified: Sun, 23 Apr 2006 19:35:20 GMT\r
@@ -495,11 +497,11 @@
 Connection: close\r
 Content-Type: text/plain; charset=UTF-8\r
 \r
-""", """Bazaar-NG meta directory, format 1
+""", b"""Bazaar-NG meta directory, format 1
 """)
 
 
-_single_range_response = (206, """HTTP/1.1 206 Partial Content\r
+_single_range_response = (206, b"""HTTP/1.1 206 Partial Content\r
 Date: Tue, 11 Jul 2006 04:45:22 GMT\r
 Server: Apache/2.0.54 (Fedora)\r
 Last-Modified: Thu, 06 Jul 2006 20:22:05 GMT\r
@@ -510,11 +512,11 @@
 Connection: close\r
 Content-Type: text/plain; charset=UTF-8\r
 \r
-""", """[e-mail]-20050309040815-13242001617e4a06
+""", b"""[e-mail]-20050309040815-13242001617e4a06
 [e-mail]-20050309040929-eee0eb3e6d1e762""")
 
 
-_single_range_no_content_type = (206, """HTTP/1.1 206 Partial Content\r
+_single_range_no_content_type = (206, b"""HTTP/1.1 206 Partial Content\r
 Date: Tue, 11 Jul 2006 04:45:22 GMT\r
 Server: Apache/2.0.54 (Fedora)\r
 Last-Modified: Thu, 06 Jul 2006 20:22:05 GMT\r
@@ -524,11 +526,11 @@
 Content-Range: bytes 100-199/93890\r
 Connection: close\r
 \r
-""", """[e-mail]-20050309040815-13242001617e4a06
+""", b"""[e-mail]-20050309040815-13242001617e4a06
 [e-mail]-20050309040929-eee0eb3e6d1e762""")
 
 
-_multipart_range_response = (206, """HTTP/1.1 206 Partial Content\r
+_multipart_range_response = (206, b"""HTTP/1.1 206 Partial Content\r
 Date: Tue, 11 Jul 2006 04:49:48 GMT\r
 Server: Apache/2.0.54 (Fedora)\r
 Last-Modified: Thu, 06 Jul 2006 20:22:05 GMT\r
@@ -538,7 +540,7 @@
 Connection: close\r
 Content-Type: multipart/byteranges; boundary=418470f848b63279b\r
 \r
-\r""", """--418470f848b63279b\r
+\r""", b"""--418470f848b63279b\r
 Content-type: text/plain; charset=UTF-8\r
 Content-range: bytes 0-254/93890\r
 \r
@@ -578,7 +580,7 @@
 """)
 
 
-_multipart_squid_range_response = (206, """HTTP/1.0 206 Partial Content\r
+_multipart_squid_range_response = (206, b"""HTTP/1.0 206 Partial Content\r
 Date: Thu, 31 Aug 2006 21:16:22 GMT\r
 Server: Apache/2.2.2 (Unix) DAV/2\r
 Last-Modified: Thu, 31 Aug 2006 17:57:06 GMT\r
@@ -590,7 +592,7 @@
 Proxy-Connection: keep-alive\r
 \r
 """,
-"""\r
+b"""\r
 --squid/2.5.STABLE12:C99323425AD4FE26F726261FA6C24196\r
 Content-Type: text/plain\r
 Content-Range: bytes 0-99/18672\r
@@ -611,7 +613,7 @@
 
 
 # This is made up
-_full_text_response_no_content_type = (200, """HTTP/1.1 200 OK\r
+_full_text_response_no_content_type = (200, b"""HTTP/1.1 200 OK\r
 Date: Tue, 11 Jul 2006 04:32:56 GMT\r
 Server: Apache/2.0.54 (Fedora)\r
 Last-Modified: Sun, 23 Apr 2006 19:35:20 GMT\r
@@ -620,11 +622,11 @@
 Content-Length: 35\r
 Connection: close\r
 \r
-""", """Bazaar-NG meta directory, format 1
+""", b"""Bazaar-NG meta directory, format 1
 """)
 
 
-_full_text_response_no_content_length = (200, """HTTP/1.1 200 OK\r
+_full_text_response_no_content_length = (200, b"""HTTP/1.1 200 OK\r
 Date: Tue, 11 Jul 2006 04:32:56 GMT\r
 Server: Apache/2.0.54 (Fedora)\r
 Last-Modified: Sun, 23 Apr 2006 19:35:20 GMT\r
@@ -633,11 +635,11 @@
 Connection: close\r
 Content-Type: text/plain; charset=UTF-8\r
 \r
-""", """Bazaar-NG meta directory, format 1
+""", b"""Bazaar-NG meta directory, format 1
 """)
 
 
-_single_range_no_content_range = (206, """HTTP/1.1 206 Partial Content\r
+_single_range_no_content_range = (206, b"""HTTP/1.1 206 Partial Content\r
 Date: Tue, 11 Jul 2006 04:45:22 GMT\r
 Server: Apache/2.0.54 (Fedora)\r
 Last-Modified: Thu, 06 Jul 2006 20:22:05 GMT\r
@@ -646,11 +648,11 @@
 Content-Length: 100\r
 Connection: close\r
 \r
-""", """[e-mail]-20050309040815-13242001617e4a06
+""", b"""[e-mail]-20050309040815-13242001617e4a06
 [e-mail]-20050309040929-eee0eb3e6d1e762""")
 
 
-_single_range_response_truncated = (206, """HTTP/1.1 206 Partial Content\r
+_single_range_response_truncated = (206, b"""HTTP/1.1 206 Partial Content\r
 Date: Tue, 11 Jul 2006 04:45:22 GMT\r
 Server: Apache/2.0.54 (Fedora)\r
 Last-Modified: Thu, 06 Jul 2006 20:22:05 GMT\r
@@ -661,15 +663,15 @@
 Connection: close\r
 Content-Type: text/plain; charset=UTF-8\r
 \r
-""", """[e-mail]-20050309040815-13242001617e4a06""")
-
-
-_invalid_response = (444, """HTTP/1.1 444 Bad Response\r
+""", b"""[e-mail]-20050309040815-13242001617e4a06""")
+
+
+_invalid_response = (444, b"""HTTP/1.1 444 Bad Response\r
 Date: Tue, 11 Jul 2006 04:32:56 GMT\r
 Connection: close\r
 Content-Type: text/html; charset=iso-8859-1\r
 \r
-""", """<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML 2.0//EN">
+""", b"""<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML 2.0//EN">
 <html><head>
 <title>404 Not Found</title>
 </head><body>
@@ -680,12 +682,12 @@
 """)
 
 
-_multipart_no_content_range = (206, """HTTP/1.0 206 Partial Content\r
+_multipart_no_content_range = (206, b"""HTTP/1.0 206 Partial Content\r
 Content-Type: multipart/byteranges; boundary=THIS_SEPARATES\r
 Content-Length: 598\r
 \r
 """,
-"""\r
+b"""\r
 --THIS_SEPARATES\r
 Content-Type: text/plain\r
 \r
@@ -694,12 +696,12 @@
 """)
 
 
-_multipart_no_boundary = (206, """HTTP/1.0 206 Partial Content\r
+_multipart_no_boundary = (206, b"""HTTP/1.0 206 Partial Content\r
 Content-Type: multipart/byteranges; boundary=THIS_SEPARATES\r
 Content-Length: 598\r
 \r
 """,
-"""\r
+b"""\r
 --THIS_SEPARATES\r
 Content-Type: text/plain\r
 Content-Range: bytes 0-18/18672\r
@@ -816,8 +818,8 @@
         super(TestRangeFileSizeReadLimited, self).setUp()
         # create a test datablock larger than _max_read_size.
         chunk_size = response.RangeFile._max_read_size
-        test_pattern = '0123456789ABCDEF'
-        self.test_data =  test_pattern * (3 * chunk_size / len(test_pattern))
+        test_pattern = b'0123456789ABCDEF'
+        self.test_data =  test_pattern * (3 * chunk_size // len(test_pattern))
         self.test_data_len = len(self.test_data)
 
     def test_max_read_size(self):

=== modified file 'breezy/tests/test_index.py'
--- breezy/tests/test_index.py	2017-11-12 13:53:51 +0000
+++ breezy/tests/test_index.py	2018-06-30 17:35:22 +0000
@@ -21,6 +21,7 @@
     tests,
     transport,
     )
+from ..sixish import int2byte
 from ..bzr import (
     index as _mod_index,
     )
@@ -66,7 +67,7 @@
         stream = builder.finish()
         contents = stream.read()
         self.assertEqual(
-            "Bazaar Graph Index 1\nnode_ref_lists=0\nkey_elements=1\nlen=0\n\n",
+            b"Bazaar Graph Index 1\nnode_ref_lists=0\nkey_elements=1\nlen=0\n\n",
             contents)
 
     def test_build_index_empty_two_element_keys(self):
@@ -74,7 +75,7 @@
         stream = builder.finish()
         contents = stream.read()
         self.assertEqual(
-            "Bazaar Graph Index 1\nnode_ref_lists=0\nkey_elements=2\nlen=0\n\n",
+            b"Bazaar Graph Index 1\nnode_ref_lists=0\nkey_elements=2\nlen=0\n\n",
             contents)
 
     def test_build_index_one_reference_list_empty(self):
@@ -82,7 +83,7 @@
         stream = builder.finish()
         contents = stream.read()
         self.assertEqual(
-            "Bazaar Graph Index 1\nnode_ref_lists=1\nkey_elements=1\nlen=0\n\n",
+            b"Bazaar Graph Index 1\nnode_ref_lists=1\nkey_elements=1\nlen=0\n\n",
             contents)
 
     def test_build_index_two_reference_list_empty(self):
@@ -90,47 +91,47 @@
         stream = builder.finish()
         contents = stream.read()
         self.assertEqual(
-            "Bazaar Graph Index 1\nnode_ref_lists=2\nkey_elements=1\nlen=0\n\n",
+            b"Bazaar Graph Index 1\nnode_ref_lists=2\nkey_elements=1\nlen=0\n\n",
             contents)
 
     def test_build_index_one_node_no_refs(self):
         builder = _mod_index.GraphIndexBuilder()
-        builder.add_node(('akey', ), 'data')
+        builder.add_node((b'akey', ), b'data')
         stream = builder.finish()
         contents = stream.read()
         self.assertEqual(
-            "Bazaar Graph Index 1\nnode_ref_lists=0\nkey_elements=1\nlen=1\n"
-            "akey\x00\x00\x00data\n\n", contents)
+            b"Bazaar Graph Index 1\nnode_ref_lists=0\nkey_elements=1\nlen=1\n"
+            b"akey\x00\x00\x00data\n\n", contents)
 
     def test_build_index_one_node_no_refs_accepts_empty_reflist(self):
         builder = _mod_index.GraphIndexBuilder()
-        builder.add_node(('akey', ), 'data', ())
+        builder.add_node((b'akey', ), b'data', ())
         stream = builder.finish()
         contents = stream.read()
         self.assertEqual(
-            "Bazaar Graph Index 1\nnode_ref_lists=0\nkey_elements=1\nlen=1\n"
-            "akey\x00\x00\x00data\n\n", contents)
+            b"Bazaar Graph Index 1\nnode_ref_lists=0\nkey_elements=1\nlen=1\n"
+            b"akey\x00\x00\x00data\n\n", contents)
 
     def test_build_index_one_node_2_element_keys(self):
         # multipart keys are separated by \x00 - because they are fixed length,
         # not variable this does not cause any issues, and seems clearer to the
         # author.
         builder = _mod_index.GraphIndexBuilder(key_elements=2)
-        builder.add_node(('akey', 'secondpart'), 'data')
+        builder.add_node((b'akey', b'secondpart'), b'data')
         stream = builder.finish()
         contents = stream.read()
         self.assertEqual(
-            "Bazaar Graph Index 1\nnode_ref_lists=0\nkey_elements=2\nlen=1\n"
-            "akey\x00secondpart\x00\x00\x00data\n\n", contents)
+            b"Bazaar Graph Index 1\nnode_ref_lists=0\nkey_elements=2\nlen=1\n"
+            b"akey\x00secondpart\x00\x00\x00data\n\n", contents)
 
     def test_add_node_empty_value(self):
         builder = _mod_index.GraphIndexBuilder()
-        builder.add_node(('akey', ), '')
+        builder.add_node((b'akey', ), b'')
         stream = builder.finish()
         contents = stream.read()
         self.assertEqual(
-            "Bazaar Graph Index 1\nnode_ref_lists=0\nkey_elements=1\nlen=1\n"
-            "akey\x00\x00\x00\n\n", contents)
+            b"Bazaar Graph Index 1\nnode_ref_lists=0\nkey_elements=1\nlen=1\n"
+            b"akey\x00\x00\x00\n\n", contents)
 
     def test_build_index_nodes_sorted(self):
         # the highest sorted node comes first.
@@ -138,17 +139,17 @@
         # use three to have a good chance of glitching dictionary hash
         # lookups etc. Insert in randomish order that is not correct
         # and not the reverse of the correct order.
-        builder.add_node(('2002', ), 'data')
-        builder.add_node(('2000', ), 'data')
-        builder.add_node(('2001', ), 'data')
+        builder.add_node((b'2002', ), b'data')
+        builder.add_node((b'2000', ), b'data')
+        builder.add_node((b'2001', ), b'data')
         stream = builder.finish()
         contents = stream.read()
         self.assertEqual(
-            "Bazaar Graph Index 1\nnode_ref_lists=0\nkey_elements=1\nlen=3\n"
-            "2000\x00\x00\x00data\n"
-            "2001\x00\x00\x00data\n"
-            "2002\x00\x00\x00data\n"
-            "\n", contents)
+            b"Bazaar Graph Index 1\nnode_ref_lists=0\nkey_elements=1\nlen=3\n"
+            b"2000\x00\x00\x00data\n"
+            b"2001\x00\x00\x00data\n"
+            b"2002\x00\x00\x00data\n"
+            b"\n", contents)
 
     def test_build_index_2_element_key_nodes_sorted(self):
         # multiple element keys are sorted first-key, second-key.
@@ -156,59 +157,59 @@
         # use three values of each key element, to have a good chance of
         # glitching dictionary hash lookups etc. Insert in randomish order that
         # is not correct and not the reverse of the correct order.
-        builder.add_node(('2002', '2002'), 'data')
-        builder.add_node(('2002', '2000'), 'data')
-        builder.add_node(('2002', '2001'), 'data')
-        builder.add_node(('2000', '2002'), 'data')
-        builder.add_node(('2000', '2000'), 'data')
-        builder.add_node(('2000', '2001'), 'data')
-        builder.add_node(('2001', '2002'), 'data')
-        builder.add_node(('2001', '2000'), 'data')
-        builder.add_node(('2001', '2001'), 'data')
+        builder.add_node((b'2002', b'2002'), b'data')
+        builder.add_node((b'2002', b'2000'), b'data')
+        builder.add_node((b'2002', b'2001'), b'data')
+        builder.add_node((b'2000', b'2002'), b'data')
+        builder.add_node((b'2000', b'2000'), b'data')
+        builder.add_node((b'2000', b'2001'), b'data')
+        builder.add_node((b'2001', b'2002'), b'data')
+        builder.add_node((b'2001', b'2000'), b'data')
+        builder.add_node((b'2001', b'2001'), b'data')
         stream = builder.finish()
         contents = stream.read()
         self.assertEqual(
-            "Bazaar Graph Index 1\nnode_ref_lists=0\nkey_elements=2\nlen=9\n"
-            "2000\x002000\x00\x00\x00data\n"
-            "2000\x002001\x00\x00\x00data\n"
-            "2000\x002002\x00\x00\x00data\n"
-            "2001\x002000\x00\x00\x00data\n"
-            "2001\x002001\x00\x00\x00data\n"
-            "2001\x002002\x00\x00\x00data\n"
-            "2002\x002000\x00\x00\x00data\n"
-            "2002\x002001\x00\x00\x00data\n"
-            "2002\x002002\x00\x00\x00data\n"
-            "\n", contents)
+            b"Bazaar Graph Index 1\nnode_ref_lists=0\nkey_elements=2\nlen=9\n"
+            b"2000\x002000\x00\x00\x00data\n"
+            b"2000\x002001\x00\x00\x00data\n"
+            b"2000\x002002\x00\x00\x00data\n"
+            b"2001\x002000\x00\x00\x00data\n"
+            b"2001\x002001\x00\x00\x00data\n"
+            b"2001\x002002\x00\x00\x00data\n"
+            b"2002\x002000\x00\x00\x00data\n"
+            b"2002\x002001\x00\x00\x00data\n"
+            b"2002\x002002\x00\x00\x00data\n"
+            b"\n", contents)
 
     def test_build_index_reference_lists_are_included_one(self):
         builder = _mod_index.GraphIndexBuilder(reference_lists=1)
-        builder.add_node(('key', ), 'data', ([], ))
+        builder.add_node((b'key', ), b'data', ([], ))
         stream = builder.finish()
         contents = stream.read()
         self.assertEqual(
-            "Bazaar Graph Index 1\nnode_ref_lists=1\nkey_elements=1\nlen=1\n"
-            "key\x00\x00\x00data\n"
-            "\n", contents)
+            b"Bazaar Graph Index 1\nnode_ref_lists=1\nkey_elements=1\nlen=1\n"
+            b"key\x00\x00\x00data\n"
+            b"\n", contents)
 
     def test_build_index_reference_lists_with_2_element_keys(self):
         builder = _mod_index.GraphIndexBuilder(reference_lists=1, key_elements=2)
-        builder.add_node(('key', 'key2'), 'data', ([], ))
+        builder.add_node((b'key', b'key2'), b'data', ([], ))
         stream = builder.finish()
         contents = stream.read()
         self.assertEqual(
-            "Bazaar Graph Index 1\nnode_ref_lists=1\nkey_elements=2\nlen=1\n"
-            "key\x00key2\x00\x00\x00data\n"
-            "\n", contents)
+            b"Bazaar Graph Index 1\nnode_ref_lists=1\nkey_elements=2\nlen=1\n"
+            b"key\x00key2\x00\x00\x00data\n"
+            b"\n", contents)
 
     def test_build_index_reference_lists_are_included_two(self):
         builder = _mod_index.GraphIndexBuilder(reference_lists=2)
-        builder.add_node(('key', ), 'data', ([], []))
+        builder.add_node((b'key', ), b'data', ([], []))
         stream = builder.finish()
         contents = stream.read()
         self.assertEqual(
-            "Bazaar Graph Index 1\nnode_ref_lists=2\nkey_elements=1\nlen=1\n"
-            "key\x00\x00\t\x00data\n"
-            "\n", contents)
+            b"Bazaar Graph Index 1\nnode_ref_lists=2\nkey_elements=1\nlen=1\n"
+            b"key\x00\x00\t\x00data\n"
+            b"\n", contents)
 
     def test_clear_cache(self):
         builder = _mod_index.GraphIndexBuilder(reference_lists=2)
@@ -217,183 +218,183 @@
 
     def test_node_references_are_byte_offsets(self):
         builder = _mod_index.GraphIndexBuilder(reference_lists=1)
-        builder.add_node(('reference', ), 'data', ([], ))
-        builder.add_node(('key', ), 'data', ([('reference', )], ))
+        builder.add_node((b'reference', ), b'data', ([], ))
+        builder.add_node((b'key', ), b'data', ([(b'reference', )], ))
         stream = builder.finish()
         contents = stream.read()
         self.assertEqual(
-            "Bazaar Graph Index 1\nnode_ref_lists=1\nkey_elements=1\nlen=2\n"
-            "key\x00\x0072\x00data\n"
-            "reference\x00\x00\x00data\n"
-            "\n", contents)
+            b"Bazaar Graph Index 1\nnode_ref_lists=1\nkey_elements=1\nlen=2\n"
+            b"key\x00\x0072\x00data\n"
+            b"reference\x00\x00\x00data\n"
+            b"\n", contents)
 
     def test_node_references_are_cr_delimited(self):
         builder = _mod_index.GraphIndexBuilder(reference_lists=1)
-        builder.add_node(('reference', ), 'data', ([], ))
-        builder.add_node(('reference2', ), 'data', ([], ))
-        builder.add_node(('key', ), 'data',
-                         ([('reference', ), ('reference2', )], ))
+        builder.add_node((b'reference', ), b'data', ([], ))
+        builder.add_node((b'reference2', ), b'data', ([], ))
+        builder.add_node((b'key', ), b'data',
+                         ([(b'reference', ), (b'reference2', )], ))
         stream = builder.finish()
         contents = stream.read()
         self.assertEqual(
-            "Bazaar Graph Index 1\nnode_ref_lists=1\nkey_elements=1\nlen=3\n"
-            "key\x00\x00077\r094\x00data\n"
-            "reference\x00\x00\x00data\n"
-            "reference2\x00\x00\x00data\n"
-            "\n", contents)
+            b"Bazaar Graph Index 1\nnode_ref_lists=1\nkey_elements=1\nlen=3\n"
+            b"key\x00\x00077\r094\x00data\n"
+            b"reference\x00\x00\x00data\n"
+            b"reference2\x00\x00\x00data\n"
+            b"\n", contents)
 
     def test_multiple_reference_lists_are_tab_delimited(self):
         builder = _mod_index.GraphIndexBuilder(reference_lists=2)
-        builder.add_node(('keference', ), 'data', ([], []))
-        builder.add_node(('rey', ), 'data',
-                         ([('keference', )], [('keference', )]))
+        builder.add_node((b'keference', ), b'data', ([], []))
+        builder.add_node((b'rey', ), b'data',
+                         ([(b'keference', )], [(b'keference', )]))
         stream = builder.finish()
         contents = stream.read()
         self.assertEqual(
-            "Bazaar Graph Index 1\nnode_ref_lists=2\nkey_elements=1\nlen=2\n"
-            "keference\x00\x00\t\x00data\n"
-            "rey\x00\x0059\t59\x00data\n"
-            "\n", contents)
+            b"Bazaar Graph Index 1\nnode_ref_lists=2\nkey_elements=1\nlen=2\n"
+            b"keference\x00\x00\t\x00data\n"
+            b"rey\x00\x0059\t59\x00data\n"
+            b"\n", contents)
 
     def test_add_node_referencing_missing_key_makes_absent(self):
         builder = _mod_index.GraphIndexBuilder(reference_lists=1)
-        builder.add_node(('rey', ), 'data',
-                         ([('beference', ), ('aeference2', )], ))
+        builder.add_node((b'rey', ), b'data',
+                         ([(b'beference', ), (b'aeference2', )], ))
         stream = builder.finish()
         contents = stream.read()
         self.assertEqual(
-            "Bazaar Graph Index 1\nnode_ref_lists=1\nkey_elements=1\nlen=1\n"
-            "aeference2\x00a\x00\x00\n"
-            "beference\x00a\x00\x00\n"
-            "rey\x00\x00074\r059\x00data\n"
-            "\n", contents)
+            b"Bazaar Graph Index 1\nnode_ref_lists=1\nkey_elements=1\nlen=1\n"
+            b"aeference2\x00a\x00\x00\n"
+            b"beference\x00a\x00\x00\n"
+            b"rey\x00\x00074\r059\x00data\n"
+            b"\n", contents)
 
     def test_node_references_three_digits(self):
         # test the node digit expands as needed.
         builder = _mod_index.GraphIndexBuilder(reference_lists=1)
-        references = [(str(val), ) for val in range(8, -1, -1)]
-        builder.add_node(('2-key', ), '', (references, ))
+        references = [((b"%d" % val), ) for val in range(8, -1, -1)]
+        builder.add_node((b'2-key', ), b'', (references, ))
         stream = builder.finish()
         contents = stream.read()
         self.assertEqualDiff(
-            "Bazaar Graph Index 1\nnode_ref_lists=1\nkey_elements=1\nlen=1\n"
-            "0\x00a\x00\x00\n"
-            "1\x00a\x00\x00\n"
-            "2\x00a\x00\x00\n"
-            "2-key\x00\x00151\r145\r139\r133\r127\r121\r071\r065\r059\x00\n"
-            "3\x00a\x00\x00\n"
-            "4\x00a\x00\x00\n"
-            "5\x00a\x00\x00\n"
-            "6\x00a\x00\x00\n"
-            "7\x00a\x00\x00\n"
-            "8\x00a\x00\x00\n"
-            "\n", contents)
+            b"Bazaar Graph Index 1\nnode_ref_lists=1\nkey_elements=1\nlen=1\n"
+            b"0\x00a\x00\x00\n"
+            b"1\x00a\x00\x00\n"
+            b"2\x00a\x00\x00\n"
+            b"2-key\x00\x00151\r145\r139\r133\r127\r121\r071\r065\r059\x00\n"
+            b"3\x00a\x00\x00\n"
+            b"4\x00a\x00\x00\n"
+            b"5\x00a\x00\x00\n"
+            b"6\x00a\x00\x00\n"
+            b"7\x00a\x00\x00\n"
+            b"8\x00a\x00\x00\n"
+            b"\n", contents)
 
     def test_absent_has_no_reference_overhead(self):
         # the offsets after an absent record should be correct when there are
         # >1 reference lists.
         builder = _mod_index.GraphIndexBuilder(reference_lists=2)
-        builder.add_node(('parent', ), '', ([('aail', ), ('zther', )], []))
+        builder.add_node((b'parent', ), b'', ([(b'aail', ), (b'zther', )], []))
         stream = builder.finish()
         contents = stream.read()
         self.assertEqual(
-            "Bazaar Graph Index 1\nnode_ref_lists=2\nkey_elements=1\nlen=1\n"
-            "aail\x00a\x00\x00\n"
-            "parent\x00\x0059\r84\t\x00\n"
-            "zther\x00a\x00\x00\n"
-            "\n", contents)
+            b"Bazaar Graph Index 1\nnode_ref_lists=2\nkey_elements=1\nlen=1\n"
+            b"aail\x00a\x00\x00\n"
+            b"parent\x00\x0059\r84\t\x00\n"
+            b"zther\x00a\x00\x00\n"
+            b"\n", contents)
 
     def test_add_node_bad_key(self):
         builder = _mod_index.GraphIndexBuilder()
-        for bad_char in '\t\n\x0b\x0c\r\x00 ':
+        for bad_char in bytearray(b'\t\n\x0b\x0c\r\x00 '):
             self.assertRaises(_mod_index.BadIndexKey, builder.add_node,
-                ('a%skey' % bad_char, ), 'data')
-        self.assertRaises(_mod_index.BadIndexKey, builder.add_node,
-                ('', ), 'data')
-        self.assertRaises(_mod_index.BadIndexKey, builder.add_node,
-                'not-a-tuple', 'data')
+                (b'a%skey' % int2byte(bad_char), ), b'data')
+        self.assertRaises(_mod_index.BadIndexKey, builder.add_node,
+                (b'', ), b'data')
+        self.assertRaises(_mod_index.BadIndexKey, builder.add_node,
+                b'not-a-tuple', b'data')
         # not enough length
         self.assertRaises(_mod_index.BadIndexKey, builder.add_node,
-                (), 'data')
+                (), b'data')
         # too long
         self.assertRaises(_mod_index.BadIndexKey, builder.add_node,
-                ('primary', 'secondary'), 'data')
+                (b'primary', b'secondary'), b'data')
         # secondary key elements get checked too:
         builder = _mod_index.GraphIndexBuilder(key_elements=2)
-        for bad_char in '\t\n\x0b\x0c\r\x00 ':
+        for bad_char in bytearray(b'\t\n\x0b\x0c\r\x00 '):
             self.assertRaises(_mod_index.BadIndexKey, builder.add_node,
-                ('prefix', 'a%skey' % bad_char), 'data')
+                (b'prefix', b'a%skey' % int2byte(bad_char)), b'data')
 
     def test_add_node_bad_data(self):
         builder = _mod_index.GraphIndexBuilder()
-        self.assertRaises(_mod_index.BadIndexValue, builder.add_node, ('akey', ),
-            'data\naa')
-        self.assertRaises(_mod_index.BadIndexValue, builder.add_node, ('akey', ),
-            'data\x00aa')
+        self.assertRaises(_mod_index.BadIndexValue, builder.add_node, (b'akey', ),
+            b'data\naa')
+        self.assertRaises(_mod_index.BadIndexValue, builder.add_node, (b'akey', ),
+            b'data\x00aa')
 
     def test_add_node_bad_mismatched_ref_lists_length(self):
         builder = _mod_index.GraphIndexBuilder()
-        self.assertRaises(_mod_index.BadIndexValue, builder.add_node, ('akey', ),
-            'data aa', ([], ))
+        self.assertRaises(_mod_index.BadIndexValue, builder.add_node, (b'akey', ),
+            b'data aa', ([], ))
         builder = _mod_index.GraphIndexBuilder(reference_lists=1)
-        self.assertRaises(_mod_index.BadIndexValue, builder.add_node, ('akey', ),
-            'data aa')
-        self.assertRaises(_mod_index.BadIndexValue, builder.add_node, ('akey', ),
-            'data aa', (), )
-        self.assertRaises(_mod_index.BadIndexValue, builder.add_node, ('akey', ),
-            'data aa', ([], []))
+        self.assertRaises(_mod_index.BadIndexValue, builder.add_node, (b'akey', ),
+            b'data aa')
+        self.assertRaises(_mod_index.BadIndexValue, builder.add_node, (b'akey', ),
+            b'data aa', (), )
+        self.assertRaises(_mod_index.BadIndexValue, builder.add_node, (b'akey', ),
+            b'data aa', ([], []))
         builder = _mod_index.GraphIndexBuilder(reference_lists=2)
-        self.assertRaises(_mod_index.BadIndexValue, builder.add_node, ('akey', ),
-            'data aa')
-        self.assertRaises(_mod_index.BadIndexValue, builder.add_node, ('akey', ),
-            'data aa', ([], ))
-        self.assertRaises(_mod_index.BadIndexValue, builder.add_node, ('akey', ),
-            'data aa', ([], [], []))
+        self.assertRaises(_mod_index.BadIndexValue, builder.add_node, (b'akey', ),
+            b'data aa')
+        self.assertRaises(_mod_index.BadIndexValue, builder.add_node, (b'akey', ),
+            b'data aa', ([], ))
+        self.assertRaises(_mod_index.BadIndexValue, builder.add_node, (b'akey', ),
+            b'data aa', ([], [], []))
 
     def test_add_node_bad_key_in_reference_lists(self):
         # first list, first key - trivial
         builder = _mod_index.GraphIndexBuilder(reference_lists=1)
-        self.assertRaises(_mod_index.BadIndexKey, builder.add_node, ('akey', ),
-            'data aa', ([('a key', )], ))
+        self.assertRaises(_mod_index.BadIndexKey, builder.add_node, (b'akey', ),
+            b'data aa', ([(b'a key', )], ))
         # references keys must be tuples too
-        self.assertRaises(_mod_index.BadIndexKey, builder.add_node, ('akey', ),
-            'data aa', (['not-a-tuple'], ))
+        self.assertRaises(_mod_index.BadIndexKey, builder.add_node, (b'akey', ),
+            b'data aa', (['not-a-tuple'], ))
         # not enough length
-        self.assertRaises(_mod_index.BadIndexKey, builder.add_node, ('akey', ),
-            'data aa', ([()], ))
+        self.assertRaises(_mod_index.BadIndexKey, builder.add_node, (b'akey', ),
+            b'data aa', ([()], ))
         # too long
-        self.assertRaises(_mod_index.BadIndexKey, builder.add_node, ('akey', ),
-            'data aa', ([('primary', 'secondary')], ))
+        self.assertRaises(_mod_index.BadIndexKey, builder.add_node, (b'akey', ),
+            b'data aa', ([(b'primary', b'secondary')], ))
         # need to check more than the first key in the list
-        self.assertRaises(_mod_index.BadIndexKey, builder.add_node, ('akey', ),
-            'data aa', ([('agoodkey', ), ('that is a bad key', )], ))
+        self.assertRaises(_mod_index.BadIndexKey, builder.add_node, (b'akey', ),
+            b'data aa', ([(b'agoodkey', ), (b'that is a bad key', )], ))
         # and if there is more than one list it should be getting checked
         # too
         builder = _mod_index.GraphIndexBuilder(reference_lists=2)
-        self.assertRaises(_mod_index.BadIndexKey, builder.add_node, ('akey', ),
-            'data aa', ([], ['a bad key']))
+        self.assertRaises(_mod_index.BadIndexKey, builder.add_node, (b'akey', ),
+            b'data aa', ([], ['a bad key']))
 
     def test_add_duplicate_key(self):
         builder = _mod_index.GraphIndexBuilder()
-        builder.add_node(('key', ), 'data')
+        builder.add_node((b'key', ), b'data')
         self.assertRaises(_mod_index.BadIndexDuplicateKey,
-                          builder.add_node, ('key', ), 'data')
+                          builder.add_node, (b'key', ), b'data')
 
     def test_add_duplicate_key_2_elements(self):
         builder = _mod_index.GraphIndexBuilder(key_elements=2)
-        builder.add_node(('key', 'key'), 'data')
+        builder.add_node((b'key', b'key'), b'data')
         self.assertRaises(_mod_index.BadIndexDuplicateKey, builder.add_node,
-            ('key', 'key'), 'data')
+            (b'key', b'key'), b'data')
 
     def test_add_key_after_referencing_key(self):
         builder = _mod_index.GraphIndexBuilder(reference_lists=1)
-        builder.add_node(('key', ), 'data', ([('reference', )], ))
-        builder.add_node(('reference', ), 'data', ([],))
+        builder.add_node((b'key', ), b'data', ([(b'reference', )], ))
+        builder.add_node((b'reference', ), b'data', ([],))
 
     def test_add_key_after_referencing_key_2_elements(self):
         builder = _mod_index.GraphIndexBuilder(reference_lists=1, key_elements=2)
-        builder.add_node(('k', 'ey'), 'data', ([('reference', 'tokey')], ))
-        builder.add_node(('reference', 'tokey'), 'data', ([],))
+        builder.add_node((b'k', b'ey'), b'data', ([(b'reference', b'tokey')], ))
+        builder.add_node((b'reference', b'tokey'), b'data', ([],))
 
     def test_set_optimize(self):
         builder = _mod_index.GraphIndexBuilder(reference_lists=1, key_elements=2)
@@ -406,10 +407,10 @@
 class TestGraphIndex(tests.TestCaseWithMemoryTransport):
 
     def make_key(self, number):
-        return (str(number) + 'X'*100,)
+        return ((b'%d' % number) + b'X'*100,)
 
     def make_value(self, number):
-            return str(number) + 'Y'*100
+        return (b'%d' % number) + b'Y'*100
 
     def make_nodes(self, count=64):
         # generate a big enough index that we only read some of it on a typical
@@ -436,7 +437,7 @@
         content = builder.finish().read()
         size = len(content)
         trans = self.get_transport()
-        trans.put_bytes('index', (' '*offset) + content)
+        trans.put_bytes('index', (b' '*offset) + content)
         return _mod_index.GraphIndex(trans, 'index', size, offset=offset)
 
     def test_clear_cache(self):
@@ -447,7 +448,7 @@
 
     def test_open_bad_index_no_error(self):
         trans = self.get_transport()
-        trans.put_bytes('name', "not an index\n")
+        trans.put_bytes('name', b"not an index\n")
         idx = _mod_index.GraphIndex(trans, 'name', 13)
 
     def test_with_offset(self):
@@ -496,7 +497,7 @@
         # do a _lookup_keys_via_location call for the middle of the file, which
         # is what bisection uses.
         result = index._lookup_keys_via_location(
-            [(index._size // 2, ('missing', ))])
+            [(index._size // 2, (b'missing', ))])
         # this should have asked for a readv request, with adjust_for_latency,
         # and two regions: the header, and half-way into the file.
         self.assertEqual([
@@ -505,7 +506,7 @@
             index._transport._activity)
         # and the result should be that the key cannot be present, because this
         # is a trivial index.
-        self.assertEqual([((index._size // 2, ('missing', )), False)],
+        self.assertEqual([((index._size // 2, (b'missing', )), False)],
             result)
         # And this should have caused the file to be fully buffered
         self.assertIsNot(None, index._nodes)
@@ -526,7 +527,7 @@
         # is what bisection uses.
         start_lookup = index._size // 2
         result = index._lookup_keys_via_location(
-            [(start_lookup, ('40missing', ))])
+            [(start_lookup, (b'40missing', ))])
         # this should have asked for a readv request, with adjust_for_latency,
         # and two regions: the header, and half-way into the file.
         self.assertEqual([
@@ -536,7 +537,7 @@
             index._transport._activity)
         # and the result should be that the key cannot be present, because this
         # is a trivial index.
-        self.assertEqual([((start_lookup, ('40missing', )), False)],
+        self.assertEqual([((start_lookup, (b'40missing', )), False)],
             result)
         # And this should not have caused the file to be fully buffered
         self.assertIs(None, index._nodes)
@@ -550,11 +551,11 @@
     def test_parsing_non_adjacent_data_trims(self):
         index = self.make_index(nodes=self.make_nodes(64))
         result = index._lookup_keys_via_location(
-            [(index._size // 2, ('40', ))])
+            [(index._size // 2, (b'40', ))])
         # and the result should be that the key cannot be present, because key is
         # in the middle of the observed data from a 4K read - the smallest transport
         # will do today with this api.
-        self.assertEqual([((index._size // 2, ('40', )), False)],
+        self.assertEqual([((index._size // 2, (b'40', )), False)],
             result)
         # and we should have a parse map that includes the header and the
         # region that was parsed after trimming.
@@ -579,7 +580,7 @@
         # locations of both keys.
         index = self.make_index(nodes=self.make_nodes(128))
         result = index._lookup_keys_via_location(
-            [(index._size // 2, ('40', ))])
+            [(index._size // 2, (b'40', ))])
         # and we should have a parse map that includes the header and the
         # region that was parsed after trimming.
         self.assertEqual([(0, 4045), (11759, 15707)], index._parsed_byte_map)
@@ -604,7 +605,7 @@
         index = self.make_index(nodes=self.make_nodes(64))
         # lookup the keys in the middle of the file
         result =index._lookup_keys_via_location(
-            [(index._size // 2, ('40', ))])
+            [(index._size // 2, (b'40', ))])
         # check the parse map, this determines the test validity
         self.assertEqual([(0, 4008), (5046, 8996)], index._parsed_byte_map)
         self.assertEqual([(None, self.make_key(26)),
@@ -617,8 +618,8 @@
         # be in the index) - even when the byte location we ask for is outside
         # the parsed region
         result = index._lookup_keys_via_location(
-            [(4000, ('40', ))])
-        self.assertEqual([((4000, ('40', )), False)],
+            [(4000, (b'40', ))])
+        self.assertEqual([((4000, (b'40', )), False)],
             result)
         self.assertEqual([], index._transport._activity)
 
@@ -628,7 +629,7 @@
         index = self.make_index(nodes=self.make_nodes(64))
         # lookup the keys in the middle of the file
         result =index._lookup_keys_via_location(
-            [(index._size // 2, ('40', ))])
+            [(index._size // 2, (b'40', ))])
         # check the parse map, this determines the test validity
         self.assertEqual([(0, 4008), (5046, 8996)], index._parsed_byte_map)
         self.assertEqual([(None, self.make_key(26)),
@@ -655,7 +656,7 @@
         # ask for the key in the middle, but a key that is located in the
         # unparsed region before the middle.
         result =index._lookup_keys_via_location(
-            [(index._size // 2, ('30', ))])
+            [(index._size // 2, (b'30', ))])
         # check the parse map, this determines the test validity
         self.assertEqual([(0, 4008), (5046, 8996)], index._parsed_byte_map)
         self.assertEqual([(None, self.make_key(26)),
@@ -671,13 +672,13 @@
         # ask for the key in the middle, but a key that is located in the
         # unparsed region after the middle.
         result =index._lookup_keys_via_location(
-            [(index._size // 2, ('50', ))])
+            [(index._size // 2, (b'50', ))])
         # check the parse map, this determines the test validity
         self.assertEqual([(0, 4008), (5046, 8996)], index._parsed_byte_map)
         self.assertEqual([(None, self.make_key(26)),
                           (self.make_key(31), self.make_key(48))],
             index._parsed_key_map)
-        self.assertEqual([((index._size // 2, ('50', )), +1)],
+        self.assertEqual([((index._size // 2, (b'50', )), +1)],
             result)
 
     def test_lookup_key_resolves_references(self):
@@ -693,7 +694,7 @@
         index_size = index._size
         index_center = index_size // 2
         result = index._lookup_keys_via_location(
-            [(index_center, ('40', ))])
+            [(index_center, (b'40', ))])
         # check the parse map - only the start and middle should have been
         # parsed.
         self.assertEqual([(0, 4027), (10198, 14028)], index._parsed_byte_map)
@@ -728,7 +729,7 @@
         # check that the referred-to-keys are not accessed automatically.
         index_size = index._size
         index_center = index_size // 2
-        result = index._lookup_keys_via_location([(index_center, ('40', ))])
+        result = index._lookup_keys_via_location([(index_center, (b'40', ))])
         # check the parse map - only the start and middle should have been
         # parsed.
         self.assertEqual([(0, 3890), (6444, 10274)], index._parsed_byte_map)
@@ -759,22 +760,22 @@
         self.assertEqual([], list(index.iter_all_entries()))
 
     def test_iter_all_entries_simple(self):
-        index = self.make_index(nodes=[(('name', ), 'data', ())])
-        self.assertEqual([(index, ('name', ), 'data')],
+        index = self.make_index(nodes=[((b'name', ), b'data', ())])
+        self.assertEqual([(index, (b'name', ), b'data')],
             list(index.iter_all_entries()))
 
     def test_iter_all_entries_simple_2_elements(self):
         index = self.make_index(key_elements=2,
-            nodes=[(('name', 'surname'), 'data', ())])
-        self.assertEqual([(index, ('name', 'surname'), 'data')],
+            nodes=[((b'name', b'surname'), b'data', ())])
+        self.assertEqual([(index, (b'name', b'surname'), b'data')],
             list(index.iter_all_entries()))
 
     def test_iter_all_entries_references_resolved(self):
         index = self.make_index(1, nodes=[
-            (('name', ), 'data', ([('ref', )], )),
-            (('ref', ), 'refdata', ([], ))])
-        self.assertEqual({(index, ('name', ), 'data', ((('ref',),),)),
-            (index, ('ref', ), 'refdata', ((), ))},
+            ((b'name', ), b'data', ([(b'ref', )], )),
+            ((b'ref', ), b'refdata', ([], ))])
+        self.assertEqual({(index, (b'name', ), b'data', (((b'ref',),),)),
+            (index, (b'ref', ), b'refdata', ((), ))},
             set(index.iter_all_entries()))
 
     def test_iter_entries_buffers_once(self):
@@ -821,45 +822,45 @@
 
     def test_iter_entries_references_resolved(self):
         index = self.make_index(1, nodes=[
-            (('name', ), 'data', ([('ref', ), ('ref', )], )),
-            (('ref', ), 'refdata', ([], ))])
-        self.assertEqual({(index, ('name', ), 'data', ((('ref',), ('ref',)),)),
-            (index, ('ref', ), 'refdata', ((), ))},
-            set(index.iter_entries([('name',), ('ref',)])))
+            ((b'name', ), b'data', ([(b'ref', ), (b'ref', )], )),
+            ((b'ref', ), b'refdata', ([], ))])
+        self.assertEqual({(index, (b'name', ), b'data', (((b'ref',), (b'ref',)),)),
+            (index, (b'ref', ), b'refdata', ((), ))},
+            set(index.iter_entries([(b'name',), (b'ref',)])))
 
     def test_iter_entries_references_2_refs_resolved(self):
         index = self.make_index(2, nodes=[
-            (('name', ), 'data', ([('ref', )], [('ref', )])),
-            (('ref', ), 'refdata', ([], []))])
-        self.assertEqual({(index, ('name', ), 'data', ((('ref',),), (('ref',),))),
-            (index, ('ref', ), 'refdata', ((), ()))},
-            set(index.iter_entries([('name',), ('ref',)])))
+            ((b'name', ), b'data', ([(b'ref', )], [(b'ref', )])),
+            ((b'ref', ), b'refdata', ([], []))])
+        self.assertEqual({(index, (b'name', ), b'data', (((b'ref',),), ((b'ref',),))),
+            (index, (b'ref', ), b'refdata', ((), ()))},
+            set(index.iter_entries([(b'name',), (b'ref',)])))
 
     def test_iteration_absent_skipped(self):
         index = self.make_index(1, nodes=[
-            (('name', ), 'data', ([('ref', )], ))])
-        self.assertEqual({(index, ('name', ), 'data', ((('ref',),),))},
+            ((b'name', ), b'data', ([(b'ref', )], ))])
+        self.assertEqual({(index, (b'name', ), b'data', (((b'ref',),),))},
             set(index.iter_all_entries()))
-        self.assertEqual({(index, ('name', ), 'data', ((('ref',),),))},
-            set(index.iter_entries([('name', )])))
-        self.assertEqual([], list(index.iter_entries([('ref', )])))
+        self.assertEqual({(index, (b'name', ), b'data', (((b'ref',),),))},
+            set(index.iter_entries([(b'name', )])))
+        self.assertEqual([], list(index.iter_entries([(b'ref', )])))
 
     def test_iteration_absent_skipped_2_element_keys(self):
         index = self.make_index(1, key_elements=2, nodes=[
-            (('name', 'fin'), 'data', ([('ref', 'erence')], ))])
-        self.assertEqual({(index, ('name', 'fin'), 'data', ((('ref', 'erence'),),))},
-            set(index.iter_all_entries()))
-        self.assertEqual({(index, ('name', 'fin'), 'data', ((('ref', 'erence'),),))},
-            set(index.iter_entries([('name', 'fin')])))
-        self.assertEqual([], list(index.iter_entries([('ref', 'erence')])))
+            ((b'name', b'fin'), b'data', ([(b'ref', b'erence')], ))])
+        self.assertEqual([(index, (b'name', b'fin'), b'data', (((b'ref', b'erence'),),))],
+            list(index.iter_all_entries()))
+        self.assertEqual([(index, (b'name', b'fin'), b'data', (((b'ref', b'erence'),),))],
+            list(index.iter_entries([(b'name', b'fin')])))
+        self.assertEqual([], list(index.iter_entries([(b'ref', b'erence')])))
 
     def test_iter_all_keys(self):
         index = self.make_index(1, nodes=[
-            (('name', ), 'data', ([('ref', )], )),
-            (('ref', ), 'refdata', ([], ))])
-        self.assertEqual({(index, ('name', ), 'data', ((('ref',),),)),
-            (index, ('ref', ), 'refdata', ((), ))},
-            set(index.iter_entries([('name', ), ('ref', )])))
+            ((b'name', ), b'data', ([(b'ref', )], )),
+            ((b'ref', ), b'refdata', ([], ))])
+        self.assertEqual({(index, (b'name', ), b'data', (((b'ref',),),)),
+            (index, (b'ref', ), b'refdata', ((), ))},
+            set(index.iter_entries([(b'name', ), (b'ref', )])))
 
     def test_iter_nothing_empty(self):
         index = self.make_index()
@@ -867,12 +868,12 @@
 
     def test_iter_missing_entry_empty(self):
         index = self.make_index()
-        self.assertEqual([], list(index.iter_entries([('a', )])))
+        self.assertEqual([], list(index.iter_entries([(b'a', )])))
 
     def test_iter_missing_entry_empty_no_size(self):
         idx = self.make_index()
-        idx = _mod_index.GraphIndex(idx._transport, 'index', None)
-        self.assertEqual([], list(idx.iter_entries([('a', )])))
+        idx = _mod_index.GraphIndex(idx._transport, b'index', None)
+        self.assertEqual([], list(idx.iter_entries([(b'a', )])))
 
     def test_iter_key_prefix_1_element_key_None(self):
         index = self.make_index()
@@ -882,64 +883,64 @@
     def test_iter_key_prefix_wrong_length(self):
         index = self.make_index()
         self.assertRaises(_mod_index.BadIndexKey, list,
-            index.iter_entries_prefix([('foo', None)]))
+            index.iter_entries_prefix([(b'foo', None)]))
         index = self.make_index(key_elements=2)
         self.assertRaises(_mod_index.BadIndexKey, list,
-            index.iter_entries_prefix([('foo', )]))
+            index.iter_entries_prefix([(b'foo', )]))
         self.assertRaises(_mod_index.BadIndexKey, list,
-            index.iter_entries_prefix([('foo', None, None)]))
+            index.iter_entries_prefix([(b'foo', None, None)]))
 
     def test_iter_key_prefix_1_key_element_no_refs(self):
         index = self.make_index( nodes=[
-            (('name', ), 'data', ()),
-            (('ref', ), 'refdata', ())])
-        self.assertEqual({(index, ('name', ), 'data'),
-            (index, ('ref', ), 'refdata')},
-            set(index.iter_entries_prefix([('name', ), ('ref', )])))
+            ((b'name', ), b'data', ()),
+            ((b'ref', ), b'refdata', ())])
+        self.assertEqual({(index, (b'name', ), b'data'),
+            (index, (b'ref', ), b'refdata')},
+            set(index.iter_entries_prefix([(b'name', ), (b'ref', )])))
 
     def test_iter_key_prefix_1_key_element_refs(self):
         index = self.make_index(1, nodes=[
-            (('name', ), 'data', ([('ref', )], )),
-            (('ref', ), 'refdata', ([], ))])
-        self.assertEqual({(index, ('name', ), 'data', ((('ref',),),)),
-            (index, ('ref', ), 'refdata', ((), ))},
-            set(index.iter_entries_prefix([('name', ), ('ref', )])))
+            ((b'name', ), b'data', ([(b'ref', )], )),
+            ((b'ref', ), b'refdata', ([], ))])
+        self.assertEqual({(index, (b'name', ), b'data', (((b'ref',),),)),
+            (index, (b'ref', ), b'refdata', ((), ))},
+            set(index.iter_entries_prefix([(b'name', ), (b'ref', )])))
 
     def test_iter_key_prefix_2_key_element_no_refs(self):
         index = self.make_index(key_elements=2, nodes=[
-            (('name', 'fin1'), 'data', ()),
-            (('name', 'fin2'), 'beta', ()),
-            (('ref', 'erence'), 'refdata', ())])
-        self.assertEqual({(index, ('name', 'fin1'), 'data'),
-            (index, ('ref', 'erence'), 'refdata')},
-            set(index.iter_entries_prefix([('name', 'fin1'), ('ref', 'erence')])))
-        self.assertEqual({(index, ('name', 'fin1'), 'data'),
-            (index, ('name', 'fin2'), 'beta')},
-            set(index.iter_entries_prefix([('name', None)])))
+            ((b'name', b'fin1'), b'data', ()),
+            ((b'name', b'fin2'), b'beta', ()),
+            ((b'ref', b'erence'), b'refdata', ())])
+        self.assertEqual({(index, (b'name', b'fin1'), b'data'),
+            (index, (b'ref', b'erence'), b'refdata')},
+            set(index.iter_entries_prefix([(b'name', b'fin1'), (b'ref', b'erence')])))
+        self.assertEqual({(index, (b'name', b'fin1'), b'data'),
+            (index, (b'name', b'fin2'), b'beta')},
+            set(index.iter_entries_prefix([(b'name', None)])))
 
     def test_iter_key_prefix_2_key_element_refs(self):
         index = self.make_index(1, key_elements=2, nodes=[
-            (('name', 'fin1'), 'data', ([('ref', 'erence')], )),
-            (('name', 'fin2'), 'beta', ([], )),
-            (('ref', 'erence'), 'refdata', ([], ))])
-        self.assertEqual({(index, ('name', 'fin1'), 'data', ((('ref', 'erence'),),)),
-            (index, ('ref', 'erence'), 'refdata', ((), ))},
-            set(index.iter_entries_prefix([('name', 'fin1'), ('ref', 'erence')])))
-        self.assertEqual({(index, ('name', 'fin1'), 'data', ((('ref', 'erence'),),)),
-            (index, ('name', 'fin2'), 'beta', ((), ))},
-            set(index.iter_entries_prefix([('name', None)])))
+            ((b'name', b'fin1'), b'data', ([(b'ref', b'erence')], )),
+            ((b'name', b'fin2'), b'beta', ([], )),
+            ((b'ref', b'erence'), b'refdata', ([], ))])
+        self.assertEqual({(index, (b'name', b'fin1'), b'data', (((b'ref', b'erence'),),)),
+            (index, (b'ref', b'erence'), b'refdata', ((), ))},
+            set(index.iter_entries_prefix([(b'name', b'fin1'), (b'ref', b'erence')])))
+        self.assertEqual({(index, (b'name', b'fin1'), b'data', (((b'ref', b'erence'),),)),
+            (index, (b'name', b'fin2'), b'beta', ((), ))},
+            set(index.iter_entries_prefix([(b'name', None)])))
 
     def test_key_count_empty(self):
         index = self.make_index()
         self.assertEqual(0, index.key_count())
 
     def test_key_count_one(self):
-        index = self.make_index(nodes=[(('name', ), '', ())])
+        index = self.make_index(nodes=[((b'name', ), b'', ())])
         self.assertEqual(1, index.key_count())
 
     def test_key_count_two(self):
         index = self.make_index(nodes=[
-            (('name', ), '', ()), (('foo', ), '', ())])
+            ((b'name', ), b'', ()), ((b'foo', ), b'', ())])
         self.assertEqual(2, index.key_count())
 
     def test_read_and_parse_tracks_real_read_value(self):
@@ -957,9 +958,9 @@
 
     def test_read_and_parse_triggers_buffer_all(self):
         index = self.make_index(key_elements=2, nodes=[
-            (('name', 'fin1'), 'data', ()),
-            (('name', 'fin2'), 'beta', ()),
-            (('ref', 'erence'), 'refdata', ())])
+            ((b'name', b'fin1'), b'data', ()),
+            ((b'name', b'fin2'), b'beta', ()),
+            ((b'ref', b'erence'), b'refdata', ())])
         self.assertTrue(index._size > 0)
         self.assertIs(None, index._nodes)
         index._read_and_parse([(0, index._size)])
@@ -967,7 +968,7 @@
 
     def test_validate_bad_index_errors(self):
         trans = self.get_transport()
-        trans.put_bytes('name', "not an index\n")
+        trans.put_bytes('name', b"not an index\n")
         idx = _mod_index.GraphIndex(trans, 'name', 13)
         self.assertRaises(_mod_index.BadIndexFormatSignature, idx.validate)
 
@@ -976,7 +977,7 @@
         trans = self.get_transport()
         content = trans.get_bytes('index')
         # change the options line to end with a rather than a parseable number
-        new_content = content[:-2] + 'a\n\n'
+        new_content = content[:-2] + b'a\n\n'
         trans.put_bytes('index', new_content)
         self.assertRaises(_mod_index.BadIndexOptions, idx.validate)
 
@@ -989,7 +990,7 @@
         self.assertRaises(_mod_index.BadIndexData, index.validate)
 
     def test_validate_missing_end_line_nonempty(self):
-        index = self.make_index(2, nodes=[(('key', ), '', ([], []))])
+        index = self.make_index(2, nodes=[((b'key', ), b'', ([], []))])
         trans = self.get_transport()
         content = trans.get_bytes('index')
         # truncate the last byte
@@ -1001,7 +1002,7 @@
         index.validate()
 
     def test_validate_no_refs_content(self):
-        index = self.make_index(nodes=[(('key', ), 'value', ())])
+        index = self.make_index(nodes=[((b'key', ), b'value', ())])
         index.validate()
 
     # XXX: external_references tests are duplicated in test_btree_index.  We
@@ -1012,35 +1013,35 @@
 
     def test_external_references_no_results(self):
         index = self.make_index(ref_lists=1, nodes=[
-            (('key',), 'value', ([],))])
+            ((b'key',), b'value', ([],))])
         self.assertEqual(set(), index.external_references(0))
 
     def test_external_references_missing_ref(self):
-        missing_key = ('missing',)
+        missing_key = (b'missing',)
         index = self.make_index(ref_lists=1, nodes=[
-            (('key',), 'value', ([missing_key],))])
+            ((b'key',), b'value', ([missing_key],))])
         self.assertEqual({missing_key}, index.external_references(0))
 
     def test_external_references_multiple_ref_lists(self):
-        missing_key = ('missing',)
+        missing_key = (b'missing',)
         index = self.make_index(ref_lists=2, nodes=[
-            (('key',), 'value', ([], [missing_key]))])
+            ((b'key',), b'value', ([], [missing_key]))])
         self.assertEqual(set([]), index.external_references(0))
         self.assertEqual({missing_key}, index.external_references(1))
 
     def test_external_references_two_records(self):
         index = self.make_index(ref_lists=1, nodes=[
-            (('key-1',), 'value', ([('key-2',)],)),
-            (('key-2',), 'value', ([],)),
+            ((b'key-1',), b'value', ([(b'key-2',)],)),
+            ((b'key-2',), b'value', ([],)),
             ])
         self.assertEqual(set([]), index.external_references(0))
 
     def test__find_ancestors(self):
-        key1 = ('key-1',)
-        key2 = ('key-2',)
+        key1 = (b'key-1',)
+        key2 = (b'key-2',)
         index = self.make_index(ref_lists=1, key_elements=1, nodes=[
-            (key1, 'value', ([key2],)),
-            (key2, 'value', ([],)),
+            (key1, b'value', ([key2],)),
+            (key2, b'value', ([],)),
             ])
         parent_map = {}
         missing_keys = set()
@@ -1055,12 +1056,12 @@
         self.assertEqual(set(), search_keys)
 
     def test__find_ancestors_w_missing(self):
-        key1 = ('key-1',)
-        key2 = ('key-2',)
-        key3 = ('key-3',)
+        key1 = (b'key-1',)
+        key2 = (b'key-2',)
+        key3 = (b'key-3',)
         index = self.make_index(ref_lists=1, key_elements=1, nodes=[
-            (key1, 'value', ([key2],)),
-            (key2, 'value', ([],)),
+            (key1, b'value', ([key2],)),
+            (key2, b'value', ([],)),
             ])
         parent_map = {}
         missing_keys = set()
@@ -1071,13 +1072,13 @@
         self.assertEqual(set(), search_keys)
 
     def test__find_ancestors_dont_search_known(self):
-        key1 = ('key-1',)
-        key2 = ('key-2',)
-        key3 = ('key-3',)
+        key1 = (b'key-1',)
+        key2 = (b'key-2',)
+        key3 = (b'key-3',)
         index = self.make_index(ref_lists=1, key_elements=1, nodes=[
-            (key1, 'value', ([key2],)),
-            (key2, 'value', ([key3],)),
-            (key3, 'value', ([],)),
+            (key1, b'value', ([key2],)),
+            (key2, b'value', ([key3],)),
+            (key3, b'value', ([],)),
             ])
         # We already know about key2, so we won't try to search for key3
         parent_map = {key2: (key3,)}
@@ -1109,7 +1110,7 @@
         size = trans.put_file(name, stream)
         return _mod_index.GraphIndex(trans, name, size)
 
-    def make_combined_index_with_missing(self, missing=['1', '2']):
+    def make_combined_index_with_missing(self, missing=[b'1', b'2']):
         """Create a CombinedGraphIndex which will have missing indexes.
 
         This creates a CGI which thinks it has 2 indexes, however they have
@@ -1119,11 +1120,11 @@
         :param missing: The underlying indexes to delete
         :return: (CombinedGraphIndex, reload_counter)
         """
-        idx1 = self.make_index('1', nodes=[(('1',), '', ())])
-        idx2 = self.make_index('2', nodes=[(('2',), '', ())])
+        idx1 = self.make_index('1', nodes=[((b'1',), b'', ())])
+        idx2 = self.make_index('2', nodes=[((b'2',), b'', ())])
         idx3 = self.make_index('3', nodes=[
-            (('1',), '', ()),
-            (('2',), '', ())])
+            ((b'1',), b'', ()),
+            ((b'2',), b'', ())])
 
         # total_reloads, num_changed, num_unchanged
         reload_counter = [0, 0, 0]
@@ -1149,9 +1150,9 @@
 
     def test_add_index(self):
         idx = _mod_index.CombinedGraphIndex([])
-        idx1 = self.make_index('name', 0, nodes=[(('key', ), '', ())])
+        idx1 = self.make_index('name', 0, nodes=[((b'key', ), b'', ())])
         idx.insert_index(0, idx1)
-        self.assertEqual([(idx1, ('key', ), '')],
+        self.assertEqual([(idx1, (b'key', ), b'')],
                          list(idx.iter_all_entries()))
 
     def test_clear_cache(self):
@@ -1170,9 +1171,9 @@
                 return self._index.clear_cache()
 
         idx = _mod_index.CombinedGraphIndex([])
-        idx1 = self.make_index('name', 0, nodes=[(('key', ), '', ())])
+        idx1 = self.make_index('name', 0, nodes=[((b'key', ), b'', ())])
         idx.insert_index(0, ClearCacheProxy(idx1))
-        idx2 = self.make_index('name', 0, nodes=[(('key', ), '', ())])
+        idx2 = self.make_index('name', 0, nodes=[((b'key', ), b'', ())])
         idx.insert_index(1, ClearCacheProxy(idx2))
         # CombinedGraphIndex should call 'clear_cache()' on all children
         idx.clear_cache()
@@ -1188,49 +1189,49 @@
         self.assertEqual([], list(idx.iter_all_entries()))
 
     def test_iter_all_entries_simple(self):
-        idx1 = self.make_index('name', nodes=[(('name', ), 'data', ())])
+        idx1 = self.make_index('name', nodes=[((b'name', ), b'data', ())])
         idx = _mod_index.CombinedGraphIndex([idx1])
-        self.assertEqual([(idx1, ('name', ), 'data')],
+        self.assertEqual([(idx1, (b'name', ), b'data')],
             list(idx.iter_all_entries()))
 
     def test_iter_all_entries_two_indices(self):
-        idx1 = self.make_index('name1', nodes=[(('name', ), 'data', ())])
-        idx2 = self.make_index('name2', nodes=[(('2', ), '', ())])
+        idx1 = self.make_index('name1', nodes=[((b'name', ), b'data', ())])
+        idx2 = self.make_index('name2', nodes=[((b'2', ), b'', ())])
         idx = _mod_index.CombinedGraphIndex([idx1, idx2])
-        self.assertEqual([(idx1, ('name', ), 'data'),
-                          (idx2, ('2', ), '')],
+        self.assertEqual([(idx1, (b'name', ), b'data'),
+                          (idx2, (b'2', ), b'')],
                          list(idx.iter_all_entries()))
 
     def test_iter_entries_two_indices_dup_key(self):
-        idx1 = self.make_index('name1', nodes=[(('name', ), 'data', ())])
-        idx2 = self.make_index('name2', nodes=[(('name', ), 'data', ())])
+        idx1 = self.make_index('name1', nodes=[((b'name', ), b'data', ())])
+        idx2 = self.make_index('name2', nodes=[((b'name', ), b'data', ())])
         idx = _mod_index.CombinedGraphIndex([idx1, idx2])
-        self.assertEqual([(idx1, ('name', ), 'data')],
-                         list(idx.iter_entries([('name', )])))
+        self.assertEqual([(idx1, (b'name', ), b'data')],
+                         list(idx.iter_entries([(b'name', )])))
 
     def test_iter_all_entries_two_indices_dup_key(self):
-        idx1 = self.make_index('name1', nodes=[(('name', ), 'data', ())])
-        idx2 = self.make_index('name2', nodes=[(('name', ), 'data', ())])
+        idx1 = self.make_index('name1', nodes=[((b'name', ), b'data', ())])
+        idx2 = self.make_index('name2', nodes=[((b'name', ), b'data', ())])
         idx = _mod_index.CombinedGraphIndex([idx1, idx2])
-        self.assertEqual([(idx1, ('name', ), 'data')],
+        self.assertEqual([(idx1, (b'name', ), b'data')],
                          list(idx.iter_all_entries()))
 
     def test_iter_key_prefix_2_key_element_refs(self):
         idx1 = self.make_index('1', 1, key_elements=2, nodes=[
-                (('name', 'fin1'), 'data', ([('ref', 'erence')], ))])
-        idx2 = self.make_index('2', 1, key_elements=2, nodes=[
-                (('name', 'fin2'), 'beta', ([], )),
-                (('ref', 'erence'), 'refdata', ([], ))])
+                ((b'name', b'fin1'), b'data', ([(b'ref', b'erence')], ))])
+        idx2 = self.make_index(b'2', 1, key_elements=2, nodes=[
+                ((b'name', b'fin2'), b'beta', ([], )),
+                ((b'ref', b'erence'), b'refdata', ([], ))])
         idx = _mod_index.CombinedGraphIndex([idx1, idx2])
-        self.assertEqual({(idx1, ('name', 'fin1'), 'data',
-                               ((('ref', 'erence'),),)),
-                              (idx2, ('ref', 'erence'), 'refdata', ((), ))},
-                         set(idx.iter_entries_prefix([('name', 'fin1'),
-                                                        ('ref', 'erence')])))
-        self.assertEqual({(idx1, ('name', 'fin1'), 'data',
-                               ((('ref', 'erence'),),)),
-                              (idx2, ('name', 'fin2'), 'beta', ((), ))},
-                         set(idx.iter_entries_prefix([('name', None)])))
+        self.assertEqual({(idx1, (b'name', b'fin1'), b'data',
+                               (((b'ref', b'erence'),),)),
+                              (idx2, (b'ref', b'erence'), b'refdata', ((), ))},
+                         set(idx.iter_entries_prefix([(b'name', b'fin1'),
+                                                        (b'ref', b'erence')])))
+        self.assertEqual({(idx1, (b'name', b'fin1'), b'data',
+                               (((b'ref', b'erence'),),)),
+                              (idx2, (b'name', b'fin2'), b'beta', ((), ))},
+                         set(idx.iter_entries_prefix([(b'name', None)])))
 
     def test_iter_nothing_empty(self):
         idx = _mod_index.CombinedGraphIndex([])
@@ -1242,23 +1243,23 @@
         self.assertEqual([], list(idx.iter_entries([])))
 
     def test_iter_all_keys(self):
-        idx1 = self.make_index('1', 1, nodes=[(('name', ), 'data',
-                                               ([('ref', )], ))])
-        idx2 = self.make_index('2', 1, nodes=[(('ref', ), 'refdata', ((), ))])
+        idx1 = self.make_index('1', 1, nodes=[((b'name', ), b'data',
+                                               ([(b'ref', )], ))])
+        idx2 = self.make_index('2', 1, nodes=[((b'ref', ), b'refdata', ((), ))])
         idx = _mod_index.CombinedGraphIndex([idx1, idx2])
-        self.assertEqual({(idx1, ('name', ), 'data', ((('ref', ), ), )),
-                              (idx2, ('ref', ), 'refdata', ((), ))},
-                         set(idx.iter_entries([('name', ), ('ref', )])))
+        self.assertEqual({(idx1, (b'name', ), b'data', (((b'ref', ), ), )),
+                              (idx2, (b'ref', ), b'refdata', ((), ))},
+                         set(idx.iter_entries([(b'name', ), (b'ref', )])))
 
     def test_iter_all_keys_dup_entry(self):
-        idx1 = self.make_index('1', 1, nodes=[(('name', ), 'data',
-                                                 ([('ref', )], )),
-                                                (('ref', ), 'refdata', ([], ))])
-        idx2 = self.make_index('2', 1, nodes=[(('ref', ), 'refdata', ([], ))])
+        idx1 = self.make_index('1', 1, nodes=[((b'name', ), b'data',
+                                                 ([(b'ref', )], )),
+                                                ((b'ref', ), b'refdata', ([], ))])
+        idx2 = self.make_index('2', 1, nodes=[((b'ref', ), b'refdata', ([], ))])
         idx = _mod_index.CombinedGraphIndex([idx1, idx2])
-        self.assertEqual({(idx1, ('name', ), 'data', ((('ref',),),)),
-                              (idx1, ('ref', ), 'refdata', ((), ))},
-                         set(idx.iter_entries([('name', ), ('ref', )])))
+        self.assertEqual({(idx1, (b'name', ), b'data', (((b'ref',),),)),
+                              (idx1, (b'ref', ), b'refdata', ((), ))},
+                         set(idx.iter_entries([(b'name', ), (b'ref', )])))
 
     def test_iter_missing_entry_empty(self):
         idx = _mod_index.CombinedGraphIndex([])
@@ -1267,7 +1268,7 @@
     def test_iter_missing_entry_one_index(self):
         idx1 = self.make_index('1')
         idx = _mod_index.CombinedGraphIndex([idx1])
-        self.assertEqual([], list(idx.iter_entries([('a', )])))
+        self.assertEqual([], list(idx.iter_entries([(b'a', )])))
 
     def test_iter_missing_entry_two_index(self):
         idx1 = self.make_index('1')
@@ -1276,15 +1277,15 @@
         self.assertEqual([], list(idx.iter_entries([('a', )])))
 
     def test_iter_entry_present_one_index_only(self):
-        idx1 = self.make_index('1', nodes=[(('key', ), '', ())])
+        idx1 = self.make_index('1', nodes=[((b'key', ), b'', ())])
         idx2 = self.make_index('2', nodes=[])
         idx = _mod_index.CombinedGraphIndex([idx1, idx2])
-        self.assertEqual([(idx1, ('key', ), '')],
-                         list(idx.iter_entries([('key', )])))
+        self.assertEqual([(idx1, (b'key', ), b'')],
+                         list(idx.iter_entries([(b'key', )])))
         # and in the other direction
         idx = _mod_index.CombinedGraphIndex([idx2, idx1])
-        self.assertEqual([(idx1, ('key', ), '')],
-                         list(idx.iter_entries([('key', )])))
+        self.assertEqual([(idx1, (b'key', ), b'')],
+                         list(idx.iter_entries([(b'key', )])))
 
     def test_key_count_empty(self):
         idx1 = self.make_index('1', nodes=[])
@@ -1294,15 +1295,15 @@
 
     def test_key_count_sums_index_keys(self):
         idx1 = self.make_index('1', nodes=[
-            (('1',), '', ()),
-            (('2',), '', ())])
-        idx2 = self.make_index('2', nodes=[(('1',), '', ())])
+            ((b'1',), b'', ()),
+            ((b'2',), b'', ())])
+        idx2 = self.make_index('2', nodes=[((b'1',), b'', ())])
         idx = _mod_index.CombinedGraphIndex([idx1, idx2])
         self.assertEqual(3, idx.key_count())
 
     def test_validate_bad_child_index_errors(self):
         trans = self.get_transport()
-        trans.put_bytes('name', "not an index\n")
+        trans.put_bytes('name', b"not an index\n")
         idx1 = _mod_index.GraphIndex(trans, 'name', 13)
         idx = _mod_index.CombinedGraphIndex([idx1])
         self.assertRaises(_mod_index.BadIndexFormatSignature, idx.validate)
@@ -1327,15 +1328,15 @@
         # still fail. This is mostly to test we don't get stuck in an infinite
         # loop trying to reload
         idx, reload_counter = self.make_combined_index_with_missing(
-            ['1', '2', '3'])
+            [b'1', b'2', b'3'])
         self.assertRaises(errors.NoSuchFile, idx.key_count)
         self.assertEqual([2, 1, 1], reload_counter)
 
     def test_iter_entries_reloads(self):
         index, reload_counter = self.make_combined_index_with_missing()
-        result = list(index.iter_entries([('1',), ('2',), ('3',)]))
+        result = list(index.iter_entries([(b'1',), (b'2',), (b'3',)]))
         index3 = index._indices[0]
-        self.assertEqual([(index3, ('1',), ''), (index3, ('2',), '')],
+        self.assertEqual([(index3, (b'1',), b''), (index3, (b'2',), b'')],
                          result)
         self.assertEqual([1, 1, 0], reload_counter)
 
@@ -1344,11 +1345,11 @@
         # through
         index, reload_counter = self.make_combined_index_with_missing(['2'])
         index1, index2 = index._indices
-        result = list(index.iter_entries([('1',), ('2',), ('3',)]))
+        result = list(index.iter_entries([(b'1',), (b'2',), (b'3',)]))
         index3 = index._indices[0]
-        # We had already yielded '1', so we just go on to the next, we should
-        # not yield '1' twice.
-        self.assertEqual([(index1, ('1',), ''), (index3, ('2',), '')],
+        # We had already yielded b'1', so we just go on to the next, we should
+        # not yield b'1' twice.
+        self.assertEqual([(index1, (b'1',), b''), (index3, (b'2',), b'')],
                          result)
         self.assertEqual([1, 1, 0], reload_counter)
 
@@ -1368,7 +1369,7 @@
         index, reload_counter = self.make_combined_index_with_missing()
         result = list(index.iter_all_entries())
         index3 = index._indices[0]
-        self.assertEqual([(index3, ('1',), ''), (index3, ('2',), '')],
+        self.assertEqual([(index3, (b'1',), b''), (index3, (b'2',), b'')],
                          result)
         self.assertEqual([1, 1, 0], reload_counter)
 
@@ -1379,7 +1380,7 @@
         index3 = index._indices[0]
         # We had already yielded '1', so we just go on to the next, we should
         # not yield '1' twice.
-        self.assertEqual([(index1, ('1',), ''), (index3, ('2',), '')],
+        self.assertEqual([(index1, (b'1',), b''), (index3, (b'2',), b'')],
                          result)
         self.assertEqual([1, 1, 0], reload_counter)
 
@@ -1390,37 +1391,37 @@
 
     def test_iter_all_entries_reloads_and_fails(self):
         index, reload_counter = self.make_combined_index_with_missing(
-                                    ['1', '2', '3'])
+                                    [b'1', b'2', b'3'])
         self.assertListRaises(errors.NoSuchFile, index.iter_all_entries)
 
     def test_iter_entries_prefix_reloads(self):
         index, reload_counter = self.make_combined_index_with_missing()
-        result = list(index.iter_entries_prefix([('1',)]))
+        result = list(index.iter_entries_prefix([(b'1',)]))
         index3 = index._indices[0]
-        self.assertEqual([(index3, ('1',), '')], result)
+        self.assertEqual([(index3, (b'1',), b'')], result)
         self.assertEqual([1, 1, 0], reload_counter)
 
     def test_iter_entries_prefix_reloads_midway(self):
-        index, reload_counter = self.make_combined_index_with_missing(['2'])
+        index, reload_counter = self.make_combined_index_with_missing([b'2'])
         index1, index2 = index._indices
-        result = list(index.iter_entries_prefix([('1',)]))
+        result = list(index.iter_entries_prefix([(b'1',)]))
         index3 = index._indices[0]
-        # We had already yielded '1', so we just go on to the next, we should
-        # not yield '1' twice.
-        self.assertEqual([(index1, ('1',), '')], result)
+        # We had already yielded b'1', so we just go on to the next, we should
+        # not yield b'1' twice.
+        self.assertEqual([(index1, (b'1',), b'')], result)
         self.assertEqual([1, 1, 0], reload_counter)
 
     def test_iter_entries_prefix_no_reload(self):
         index, reload_counter = self.make_combined_index_with_missing()
         index._reload_func = None
         self.assertListRaises(errors.NoSuchFile, index.iter_entries_prefix,
-                                                 [('1',)])
+                                                 [(b'1',)])
 
     def test_iter_entries_prefix_reloads_and_fails(self):
         index, reload_counter = self.make_combined_index_with_missing(
-                                    ['1', '2', '3'])
+                                    [b'1', b'2', b'3'])
         self.assertListRaises(errors.NoSuchFile, index.iter_entries_prefix,
-                                                 [('1',)])
+                                                 [(b'1',)])
 
 
     def make_index_with_simple_nodes(self, name, num_nodes=1):
@@ -1429,7 +1430,7 @@
         Nodes will have a value of '' and no references.
         """
         nodes = [
-            (('index-%s-key-%s' % (name, n),), '', ())
+            ((('index-%s-key-%s' % (name, n)).encode('ascii'),), b'', ())
             for n in range(1, num_nodes+1)]
         return self.make_index('index-%s' % name, 0, nodes=nodes)
 
@@ -1437,18 +1438,18 @@
         # Four indices: [key1] in idx1, [key2,key3] in idx2, [] in idx3,
         # [key4] in idx4.
         idx = _mod_index.CombinedGraphIndex([])
-        idx.insert_index(0, self.make_index_with_simple_nodes('1'), '1')
-        idx.insert_index(1, self.make_index_with_simple_nodes('2'), '2')
-        idx.insert_index(2, self.make_index_with_simple_nodes('3'), '3')
-        idx.insert_index(3, self.make_index_with_simple_nodes('4'), '4')
+        idx.insert_index(0, self.make_index_with_simple_nodes('1'), b'1')
+        idx.insert_index(1, self.make_index_with_simple_nodes('2'), b'2')
+        idx.insert_index(2, self.make_index_with_simple_nodes('3'), b'3')
+        idx.insert_index(3, self.make_index_with_simple_nodes('4'), b'4')
         idx1, idx2, idx3, idx4 = idx._indices
         # Query a key from idx4 and idx2.
         self.assertLength(2, list(idx.iter_entries(
-            [('index-4-key-1',), ('index-2-key-1',)])))
+            [(b'index-4-key-1',), (b'index-2-key-1',)])))
         # Now idx2 and idx4 should be moved to the front (and idx1 should
         # still be before idx3).
         self.assertEqual([idx2, idx4, idx1, idx3], idx._indices)
-        self.assertEqual(['2', '4', '1', '3'], idx._index_names)
+        self.assertEqual([b'2', b'4', b'1', b'3'], idx._index_names)
 
     def test_reorder_propagates_to_siblings(self):
         # Two CombinedGraphIndex objects, with the same number of indicies with
@@ -1486,17 +1487,17 @@
         self.assertRaises(errors.NoSuchFile, idx.validate)
 
     def test_find_ancestors_across_indexes(self):
-        key1 = ('key-1',)
-        key2 = ('key-2',)
-        key3 = ('key-3',)
-        key4 = ('key-4',)
+        key1 = (b'key-1',)
+        key2 = (b'key-2',)
+        key3 = (b'key-3',)
+        key4 = (b'key-4',)
         index1 = self.make_index('12', ref_lists=1, nodes=[
-            (key1, 'value', ([],)),
-            (key2, 'value', ([key1],)),
+            (key1, b'value', ([],)),
+            (key2, b'value', ([key1],)),
             ])
         index2 = self.make_index('34', ref_lists=1, nodes=[
-            (key3, 'value', ([key2],)),
-            (key4, 'value', ([key3],)),
+            (key3, b'value', ([key2],)),
+            (key4, b'value', ([key3],)),
             ])
         c_index = _mod_index.CombinedGraphIndex([index1, index2])
         parent_map, missing_keys = c_index.find_ancestry([key1], 0)
@@ -1510,16 +1511,16 @@
         self.assertEqual(set(), missing_keys)
 
     def test_find_ancestors_missing_keys(self):
-        key1 = ('key-1',)
-        key2 = ('key-2',)
-        key3 = ('key-3',)
-        key4 = ('key-4',)
+        key1 = (b'key-1',)
+        key2 = (b'key-2',)
+        key3 = (b'key-3',)
+        key4 = (b'key-4',)
         index1 = self.make_index('12', ref_lists=1, nodes=[
-            (key1, 'value', ([],)),
-            (key2, 'value', ([key1],)),
+            (key1, b'value', ([],)),
+            (key2, b'value', ([key1],)),
             ])
         index2 = self.make_index('34', ref_lists=1, nodes=[
-            (key3, 'value', ([key2],)),
+            (key3, b'value', ([key2],)),
             ])
         c_index = _mod_index.CombinedGraphIndex([index1, index2])
         # Searching for a key which is actually not present at all should
@@ -1530,22 +1531,22 @@
 
     def test_find_ancestors_no_indexes(self):
         c_index = _mod_index.CombinedGraphIndex([])
-        key1 = ('key-1',)
+        key1 = (b'key-1',)
         parent_map, missing_keys = c_index.find_ancestry([key1], 0)
         self.assertEqual({}, parent_map)
         self.assertEqual({key1}, missing_keys)
 
     def test_find_ancestors_ghost_parent(self):
-        key1 = ('key-1',)
-        key2 = ('key-2',)
-        key3 = ('key-3',)
-        key4 = ('key-4',)
+        key1 = (b'key-1',)
+        key2 = (b'key-2',)
+        key3 = (b'key-3',)
+        key4 = (b'key-4',)
         index1 = self.make_index('12', ref_lists=1, nodes=[
-            (key1, 'value', ([],)),
-            (key2, 'value', ([key1],)),
+            (key1, b'value', ([],)),
+            (key2, b'value', ([key1],)),
             ])
         index2 = self.make_index('34', ref_lists=1, nodes=[
-            (key4, 'value', ([key2, key3],)),
+            (key4, b'value', ([key2, key3],)),
             ])
         c_index = _mod_index.CombinedGraphIndex([index1, index2])
         # Searching for a key which is actually not present at all should
@@ -1559,11 +1560,11 @@
         idx = self.make_index('test', ref_lists=1, key_elements=1, nodes=[])
         parent_map = {}
         missing_keys = set()
-        search_keys = idx._find_ancestors([('one',), ('two',)], 0, parent_map,
+        search_keys = idx._find_ancestors([(b'one',), (b'two',)], 0, parent_map,
                                           missing_keys)
         self.assertEqual(set(), search_keys)
         self.assertEqual({}, parent_map)
-        self.assertEqual({('one',), ('two',)}, missing_keys)
+        self.assertEqual({(b'one',), (b'two',)}, missing_keys)
 
 
 class TestInMemoryGraphIndex(tests.TestCaseWithMemoryTransport):
@@ -1575,22 +1576,22 @@
 
     def test_add_nodes_no_refs(self):
         index = self.make_index(0)
-        index.add_nodes([(('name', ), 'data')])
-        index.add_nodes([(('name2', ), ''), (('name3', ), '')])
+        index.add_nodes([((b'name', ), b'data')])
+        index.add_nodes([((b'name2', ), b''), ((b'name3', ), b'')])
         self.assertEqual({
-            (index, ('name', ), 'data'),
-            (index, ('name2', ), ''),
-            (index, ('name3', ), ''),
+            (index, (b'name', ), b'data'),
+            (index, (b'name2', ), b''),
+            (index, (b'name3', ), b''),
             }, set(index.iter_all_entries()))
 
     def test_add_nodes(self):
         index = self.make_index(1)
-        index.add_nodes([(('name', ), 'data', ([],))])
-        index.add_nodes([(('name2', ), '', ([],)), (('name3', ), '', ([('r', )],))])
+        index.add_nodes([((b'name', ), b'data', ([],))])
+        index.add_nodes([((b'name2', ), b'', ([],)), ((b'name3', ), b'', ([(b'r', )],))])
         self.assertEqual({
-            (index, ('name', ), 'data', ((),)),
-            (index, ('name2', ), '', ((),)),
-            (index, ('name3', ), '', ((('r', ), ), )),
+            (index, (b'name', ), b'data', ((),)),
+            (index, (b'name2', ), b'', ((),)),
+            (index, (b'name3', ), b'', (((b'r', ), ), )),
             }, set(index.iter_all_entries()))
 
     def test_iter_all_entries_empty(self):
@@ -1598,74 +1599,74 @@
         self.assertEqual([], list(index.iter_all_entries()))
 
     def test_iter_all_entries_simple(self):
-        index = self.make_index(nodes=[(('name', ), 'data')])
-        self.assertEqual([(index, ('name', ), 'data')],
+        index = self.make_index(nodes=[((b'name', ), b'data')])
+        self.assertEqual([(index, (b'name', ), b'data')],
             list(index.iter_all_entries()))
 
     def test_iter_all_entries_references(self):
         index = self.make_index(1, nodes=[
-            (('name', ), 'data', ([('ref', )], )),
-            (('ref', ), 'refdata', ([], ))])
-        self.assertEqual({(index, ('name', ), 'data', ((('ref', ),),)),
-            (index, ('ref', ), 'refdata', ((), ))},
+            ((b'name', ), b'data', ([(b'ref', )], )),
+            ((b'ref', ), b'refdata', ([], ))])
+        self.assertEqual({(index, (b'name', ), b'data', (((b'ref', ),),)),
+            (index, (b'ref', ), b'refdata', ((), ))},
             set(index.iter_all_entries()))
 
     def test_iteration_absent_skipped(self):
         index = self.make_index(1, nodes=[
-            (('name', ), 'data', ([('ref', )], ))])
-        self.assertEqual({(index, ('name', ), 'data', ((('ref',),),))},
+            ((b'name', ), b'data', ([(b'ref', )], ))])
+        self.assertEqual({(index, (b'name', ), b'data', (((b'ref',),),))},
             set(index.iter_all_entries()))
-        self.assertEqual({(index, ('name', ), 'data', ((('ref',),),))},
-            set(index.iter_entries([('name', )])))
-        self.assertEqual([], list(index.iter_entries([('ref', )])))
+        self.assertEqual({(index, (b'name', ), b'data', (((b'ref',),),))},
+            set(index.iter_entries([(b'name', )])))
+        self.assertEqual([], list(index.iter_entries([(b'ref', )])))
 
     def test_iter_all_keys(self):
         index = self.make_index(1, nodes=[
-            (('name', ), 'data', ([('ref', )], )),
-            (('ref', ), 'refdata', ([], ))])
-        self.assertEqual({(index, ('name', ), 'data', ((('ref',),),)),
-            (index, ('ref', ), 'refdata', ((), ))},
-            set(index.iter_entries([('name', ), ('ref', )])))
+            ((b'name', ), b'data', ([(b'ref', )], )),
+            ((b'ref', ), b'refdata', ([], ))])
+        self.assertEqual({(index, (b'name', ), b'data', (((b'ref',),),)),
+            (index, (b'ref', ), b'refdata', ((), ))},
+            set(index.iter_entries([(b'name', ), (b'ref', )])))
 
     def test_iter_key_prefix_1_key_element_no_refs(self):
         index = self.make_index( nodes=[
-            (('name', ), 'data'),
-            (('ref', ), 'refdata')])
-        self.assertEqual({(index, ('name', ), 'data'),
-            (index, ('ref', ), 'refdata')},
-            set(index.iter_entries_prefix([('name', ), ('ref', )])))
+            ((b'name', ), b'data'),
+            ((b'ref', ), b'refdata')])
+        self.assertEqual({(index, (b'name', ), b'data'),
+            (index, (b'ref', ), b'refdata')},
+            set(index.iter_entries_prefix([(b'name', ), (b'ref', )])))
 
     def test_iter_key_prefix_1_key_element_refs(self):
         index = self.make_index(1, nodes=[
-            (('name', ), 'data', ([('ref', )], )),
-            (('ref', ), 'refdata', ([], ))])
-        self.assertEqual({(index, ('name', ), 'data', ((('ref',),),)),
-            (index, ('ref', ), 'refdata', ((), ))},
-            set(index.iter_entries_prefix([('name', ), ('ref', )])))
+            ((b'name', ), b'data', ([(b'ref', )], )),
+            ((b'ref', ), b'refdata', ([], ))])
+        self.assertEqual({(index, (b'name', ), b'data', (((b'ref',),),)),
+            (index, (b'ref', ), b'refdata', ((), ))},
+            set(index.iter_entries_prefix([(b'name', ), (b'ref', )])))
 
     def test_iter_key_prefix_2_key_element_no_refs(self):
         index = self.make_index(key_elements=2, nodes=[
-            (('name', 'fin1'), 'data'),
-            (('name', 'fin2'), 'beta'),
-            (('ref', 'erence'), 'refdata')])
-        self.assertEqual({(index, ('name', 'fin1'), 'data'),
-            (index, ('ref', 'erence'), 'refdata')},
-            set(index.iter_entries_prefix([('name', 'fin1'), ('ref', 'erence')])))
-        self.assertEqual({(index, ('name', 'fin1'), 'data'),
-            (index, ('name', 'fin2'), 'beta')},
-            set(index.iter_entries_prefix([('name', None)])))
+            ((b'name', b'fin1'), b'data'),
+            ((b'name', b'fin2'), b'beta'),
+            ((b'ref', b'erence'), b'refdata')])
+        self.assertEqual({(index, (b'name', b'fin1'), b'data'),
+            (index, (b'ref', b'erence'), b'refdata')},
+            set(index.iter_entries_prefix([(b'name', b'fin1'), (b'ref', b'erence')])))
+        self.assertEqual({(index, (b'name', b'fin1'), b'data'),
+            (index, (b'name', b'fin2'), b'beta')},
+            set(index.iter_entries_prefix([(b'name', None)])))
 
     def test_iter_key_prefix_2_key_element_refs(self):
         index = self.make_index(1, key_elements=2, nodes=[
-            (('name', 'fin1'), 'data', ([('ref', 'erence')], )),
-            (('name', 'fin2'), 'beta', ([], )),
-            (('ref', 'erence'), 'refdata', ([], ))])
-        self.assertEqual({(index, ('name', 'fin1'), 'data', ((('ref', 'erence'),),)),
-            (index, ('ref', 'erence'), 'refdata', ((), ))},
-            set(index.iter_entries_prefix([('name', 'fin1'), ('ref', 'erence')])))
-        self.assertEqual({(index, ('name', 'fin1'), 'data', ((('ref', 'erence'),),)),
-            (index, ('name', 'fin2'), 'beta', ((), ))},
-            set(index.iter_entries_prefix([('name', None)])))
+            ((b'name', b'fin1'), b'data', ([(b'ref', b'erence')], )),
+            ((b'name', b'fin2'), b'beta', ([], )),
+            ((b'ref', b'erence'), b'refdata', ([], ))])
+        self.assertEqual({(index, (b'name', b'fin1'), b'data', (((b'ref', b'erence'),),)),
+            (index, (b'ref', b'erence'), b'refdata', ((), ))},
+            set(index.iter_entries_prefix([(b'name', b'fin1'), (b'ref', b'erence')])))
+        self.assertEqual({(index, (b'name', b'fin1'), b'data', (((b'ref', b'erence'),),)),
+            (index, (b'name', b'fin2'), b'beta', ((), ))},
+            set(index.iter_entries_prefix([(b'name', None)])))
 
     def test_iter_nothing_empty(self):
         index = self.make_index()
@@ -1673,18 +1674,18 @@
 
     def test_iter_missing_entry_empty(self):
         index = self.make_index()
-        self.assertEqual([], list(index.iter_entries(['a'])))
+        self.assertEqual([], list(index.iter_entries([b'a'])))
 
     def test_key_count_empty(self):
         index = self.make_index()
         self.assertEqual(0, index.key_count())
 
     def test_key_count_one(self):
-        index = self.make_index(nodes=[(('name', ), '')])
+        index = self.make_index(nodes=[((b'name', ), b'')])
         self.assertEqual(1, index.key_count())
 
     def test_key_count_two(self):
-        index = self.make_index(nodes=[(('name', ), ''), (('foo', ), '')])
+        index = self.make_index(nodes=[((b'name', ), b''), ((b'foo', ), b'')])
         self.assertEqual(2, index.key_count())
 
     def test_validate_empty(self):
@@ -1692,7 +1693,7 @@
         index.validate()
 
     def test_validate_no_refs_content(self):
-        index = self.make_index(nodes=[(('key', ), 'value')])
+        index = self.make_index(nodes=[((b'key', ), b'value')])
         index.validate()
 
 
@@ -1707,88 +1708,88 @@
         else:
             add_nodes_callback = None
         adapter = _mod_index.GraphIndexPrefixAdapter(
-            result, ('prefix', ), key_elements - 1,
+            result, (b'prefix', ), key_elements - 1,
             add_nodes_callback=add_nodes_callback)
         return result, adapter
 
     def test_add_node(self):
         index, adapter = self.make_index(add_callback=True)
-        adapter.add_node(('key',), 'value', ((('ref',),),))
-        self.assertEqual({(index, ('prefix', 'key'), 'value',
-                               ((('prefix', 'ref'),),))},
+        adapter.add_node((b'key',), b'value', (((b'ref',),),))
+        self.assertEqual({(index, (b'prefix', b'key'), b'value',
+                               (((b'prefix', b'ref'),),))},
             set(index.iter_all_entries()))
 
     def test_add_nodes(self):
         index, adapter = self.make_index(add_callback=True)
         adapter.add_nodes((
-            (('key',), 'value', ((('ref',),),)),
-            (('key2',), 'value2', ((),)),
+            ((b'key',), b'value', (((b'ref',),),)),
+            ((b'key2',), b'value2', ((),)),
             ))
         self.assertEqual({
-            (index, ('prefix', 'key2'), 'value2', ((),)),
-            (index, ('prefix', 'key'), 'value', ((('prefix', 'ref'),),))
+            (index, (b'prefix', b'key2'), b'value2', ((),)),
+            (index, (b'prefix', b'key'), b'value', (((b'prefix', b'ref'),),))
             },
             set(index.iter_all_entries()))
 
     def test_construct(self):
         idx = _mod_index.InMemoryGraphIndex()
-        adapter = _mod_index.GraphIndexPrefixAdapter(idx, ('prefix', ), 1)
+        adapter = _mod_index.GraphIndexPrefixAdapter(idx, (b'prefix', ), 1)
 
     def test_construct_with_callback(self):
         idx = _mod_index.InMemoryGraphIndex()
-        adapter = _mod_index.GraphIndexPrefixAdapter(idx, ('prefix', ), 1,
+        adapter = _mod_index.GraphIndexPrefixAdapter(idx, (b'prefix', ), 1,
                                                 idx.add_nodes)
 
     def test_iter_all_entries_cross_prefix_map_errors(self):
         index, adapter = self.make_index(nodes=[
-            (('prefix', 'key1'), 'data1', ((('prefixaltered', 'key2'),),))])
+            ((b'prefix', b'key1'), b'data1', (((b'prefixaltered', b'key2'),),))])
         self.assertRaises(_mod_index.BadIndexData, list, adapter.iter_all_entries())
 
     def test_iter_all_entries(self):
         index, adapter = self.make_index(nodes=[
-            (('notprefix', 'key1'), 'data', ((), )),
-            (('prefix', 'key1'), 'data1', ((), )),
-            (('prefix', 'key2'), 'data2', ((('prefix', 'key1'),),))])
-        self.assertEqual({(index, ('key1', ), 'data1', ((),)),
-            (index, ('key2', ), 'data2', ((('key1',),),))},
+            ((b'notprefix', b'key1'), b'data', ((), )),
+            ((b'prefix', b'key1'), b'data1', ((), )),
+            ((b'prefix', b'key2'), b'data2', (((b'prefix', b'key1'),),))])
+        self.assertEqual({(index, (b'key1', ), b'data1', ((),)),
+            (index, (b'key2', ), b'data2', (((b'key1',),),))},
             set(adapter.iter_all_entries()))
 
     def test_iter_entries(self):
         index, adapter = self.make_index(nodes=[
-            (('notprefix', 'key1'), 'data', ((), )),
-            (('prefix', 'key1'), 'data1', ((), )),
-            (('prefix', 'key2'), 'data2', ((('prefix', 'key1'),),))])
+            ((b'notprefix', b'key1'), b'data', ((), )),
+            ((b'prefix', b'key1'), b'data1', ((), )),
+            ((b'prefix', b'key2'), b'data2', (((b'prefix', b'key1'),),))])
         # ask for many - get all
-        self.assertEqual({(index, ('key1', ), 'data1', ((),)),
-            (index, ('key2', ), 'data2', ((('key1', ),),))},
-            set(adapter.iter_entries([('key1', ), ('key2', )])))
+        self.assertEqual({(index, (b'key1', ), b'data1', ((),)),
+            (index, (b'key2', ), b'data2', (((b'key1', ),),))},
+            set(adapter.iter_entries([(b'key1', ), (b'key2', )])))
         # ask for one, get one
-        self.assertEqual({(index, ('key1', ), 'data1', ((),))},
-            set(adapter.iter_entries([('key1', )])))
+        self.assertEqual({(index, (b'key1', ), b'data1', ((),))},
+            set(adapter.iter_entries([(b'key1', )])))
         # ask for missing, get none
         self.assertEqual(set(),
-            set(adapter.iter_entries([('key3', )])))
+            set(adapter.iter_entries([(b'key3', )])))
 
     def test_iter_entries_prefix(self):
         index, adapter = self.make_index(key_elements=3, nodes=[
-            (('notprefix', 'foo', 'key1'), 'data', ((), )),
-            (('prefix', 'prefix2', 'key1'), 'data1', ((), )),
-            (('prefix', 'prefix2', 'key2'), 'data2', ((('prefix', 'prefix2', 'key1'),),))])
+            ((b'notprefix', b'foo', b'key1'), b'data', ((), )),
+            ((b'prefix', b'prefix2', b'key1'), b'data1', ((), )),
+            ((b'prefix', b'prefix2', b'key2'), b'data2', (((b'prefix', b'prefix2', b'key1'),),))])
         # ask for a prefix, get the results for just that prefix, adjusted.
-        self.assertEqual({(index, ('prefix2', 'key1', ), 'data1', ((),)),
-            (index, ('prefix2', 'key2', ), 'data2', ((('prefix2', 'key1', ),),))},
-            set(adapter.iter_entries_prefix([('prefix2', None)])))
+        self.assertEqual({(index, (b'prefix2', b'key1', ), b'data1', ((),)),
+            (index, (b'prefix2', b'key2', ), b'data2', (((b'prefix2', b'key1', ),),))},
+            set(adapter.iter_entries_prefix([(b'prefix2', None)])))
 
     def test_key_count_no_matching_keys(self):
         index, adapter = self.make_index(nodes=[
-            (('notprefix', 'key1'), 'data', ((), ))])
+            ((b'notprefix', b'key1'), b'data', ((), ))])
         self.assertEqual(0, adapter.key_count())
 
     def test_key_count_some_keys(self):
         index, adapter = self.make_index(nodes=[
-            (('notprefix', 'key1'), 'data', ((), )),
-            (('prefix', 'key1'), 'data1', ((), )),
-            (('prefix', 'key2'), 'data2', ((('prefix', 'key1'),),))])
+            ((b'notprefix', b'key1'), b'data', ((), )),
+            ((b'prefix', b'key1'), b'data1', ((), )),
+            ((b'prefix', b'key2'), b'data2', (((b'prefix', b'key1'),),))])
         self.assertEqual(2, adapter.key_count())
 
     def test_validate(self):

=== modified file 'breezy/tests/test_inv.py'
--- breezy/tests/test_inv.py	2018-06-30 14:29:46 +0000
+++ breezy/tests/test_inv.py	2018-06-30 17:35:22 +0000
@@ -88,7 +88,7 @@
 def create_texts_for_inv(repo, inv):
     for path, ie in inv.iter_entries():
         if ie.text_size:
-            lines = ['a' * ie.text_size]
+            lines = [b'a' * ie.text_size]
         else:
             lines = []
         repo.texts.add_lines((ie.file_id, ie.revision), [], lines)
@@ -142,11 +142,11 @@
 def _create_repo_revisions(repo, basis, delta, invalid_delta):
     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)
         if invalid_delta:
             # We don't want to apply the delta to the basis, because we expect
             # the delta is invalid.
@@ -154,12 +154,12 @@
             result_inv.revision_id = b'result'
             target_entries = None
         else:
-            result_inv = basis.create_by_apply_delta(delta, 'result')
+            result_inv = basis.create_by_apply_delta(delta, b'result')
             create_texts_for_inv(repo, result_inv)
             target_entries = list(result_inv.iter_entries_by_dir())
-        rev = revision.Revision('result', timestamp=0, timezone=None,
+        rev = revision.Revision(b'result', timestamp=0, timezone=None,
             message="", committer="[e-mail]")
-        repo.add_revision('result', rev, result_inv)
+        repo.add_revision(b'result', rev, result_inv)
         repo.commit_write_group()
     except:
         repo.abort_write_group()
@@ -222,7 +222,7 @@
         tree.unlock()
     # Fresh lock, reads disk again.
     with tree.lock_write():
-        tree.update_basis_by_delta('result', delta)
+        tree.update_basis_by_delta(b'result', delta)
         if not invalid_delta:
             tree._validate()
     # reload tree - ensure we get what was written.
@@ -251,8 +251,7 @@
     format = self.format()
     control = self.make_controldir('tree', format=format._matchingcontroldir)
     repo = format.initialize(control)
-    repo.lock_write()
-    try:
+    with repo.lock_write():
         repo.start_write_group()
         try:
             rev = revision.Revision(b'basis', timestamp=0, timezone=None,
@@ -264,10 +263,7 @@
         except:
             repo.abort_write_group()
             raise
-    finally:
-        repo.unlock()
-    repo.lock_write()
-    try:
+    with repo.lock_write():
         repo.start_write_group()
         try:
             inv_sha1 = repo.add_inventory_by_delta(b'basis', delta,
@@ -277,8 +273,6 @@
             raise
         else:
             repo.commit_write_group()
-    finally:
-        repo.unlock()
     # Fresh lock, reads disk again.
     repo = repo.controldir.open_repository()
     repo.lock_read()
@@ -345,7 +339,7 @@
         inv.add(InventoryFile(b'a-id', u'\u1234', b'tree-root'))
         e = self.assertRaises(errors.InconsistentDelta, inv.add,
             InventoryFile(b'b-id', u'\u1234', b'tree-root'))
-        self.assertContainsRe(str(e), r'\\u1234')
+        self.assertContainsRe(str(e), '\\u1234')
 
     def test_add_recursive(self):
         parent = InventoryDirectory(b'src-id', 'src', b'tree-root')
@@ -377,14 +371,14 @@
         if reference_inv is not None:
             inv.root.revision = reference_inv.root.revision
         else:
-            inv.root.revision = 'basis'
+            inv.root.revision = b'basis'
         return inv
 
     def make_file_ie(self, file_id=b'file-id', name='name', parent_id=None):
         ie_file = inventory.InventoryFile(file_id, name, parent_id)
         ie_file.revision = b'result'
         ie_file.text_size = 0
-        ie_file.text_sha1 = ''
+        ie_file.text_sha1 = b''
         return ie_file
 
     def test_empty_delta(self):
@@ -396,7 +390,8 @@
 
     def test_None_file_id(self):
         inv = self.get_empty_inventory()
-        dir1 = inventory.InventoryDirectory(None, 'dir1', inv.root.file_id)
+        dir1 = inventory.InventoryDirectory(b'dirid', 'dir1', inv.root.file_id)
+        dir1.file_id = None
         dir1.revision = b'result'
         delta = [(None, u'dir1', None, dir1)]
         self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,
@@ -404,7 +399,8 @@
 
     def test_unicode_file_id(self):
         inv = self.get_empty_inventory()
-        dir1 = inventory.InventoryDirectory(u'dirid', 'dir1', inv.root.file_id)
+        dir1 = inventory.InventoryDirectory(b'dirid', 'dir1', inv.root.file_id)
+        dir1.file_id = u'dirid'
         dir1.revision = b'result'
         delta = [(None, u'dir1', dir1.file_id, dir1)]
         self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,
@@ -412,152 +408,152 @@
 
     def test_repeated_file_id(self):
         inv = self.get_empty_inventory()
-        file1 = inventory.InventoryFile('id', 'path1', inv.root.file_id)
+        file1 = inventory.InventoryFile(b'id', 'path1', inv.root.file_id)
         file1.revision = b'result'
         file1.text_size = 0
-        file1.text_sha1 = ""
+        file1.text_sha1 = b""
         file2 = file1.copy()
         file2.name = 'path2'
-        delta = [(None, u'path1', 'id', file1), (None, u'path2', 'id', file2)]
+        delta = [(None, u'path1', b'id', file1), (None, u'path2', b'id', file2)]
         self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,
             inv, delta)
 
     def test_repeated_new_path(self):
         inv = self.get_empty_inventory()
-        file1 = inventory.InventoryFile('id1', 'path', inv.root.file_id)
+        file1 = inventory.InventoryFile(b'id1', 'path', inv.root.file_id)
         file1.revision = b'result'
         file1.text_size = 0
-        file1.text_sha1 = ""
+        file1.text_sha1 = b""
         file2 = file1.copy()
-        file2.file_id = 'id2'
-        delta = [(None, u'path', 'id1', file1), (None, u'path', 'id2', file2)]
+        file2.file_id = b'id2'
+        delta = [(None, u'path', b'id1', file1), (None, u'path', b'id2', file2)]
         self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,
             inv, delta)
 
     def test_repeated_old_path(self):
         inv = self.get_empty_inventory()
-        file1 = inventory.InventoryFile('id1', 'path', inv.root.file_id)
+        file1 = inventory.InventoryFile(b'id1', 'path', inv.root.file_id)
         file1.revision = b'result'
         file1.text_size = 0
-        file1.text_sha1 = ""
+        file1.text_sha1 = b""
         # We can't *create* a source inventory with the same path, but
         # a badly generated partial delta might claim the same source twice.
         # This would be buggy in two ways: the path is repeated in the delta,
         # And the path for one of the file ids doesn't match the source
         # location. Alternatively, we could have a repeated fileid, but that
         # is separately checked for.
-        file2 = inventory.InventoryFile('id2', 'path2', inv.root.file_id)
+        file2 = inventory.InventoryFile(b'id2', 'path2', inv.root.file_id)
         file2.revision = b'result'
         file2.text_size = 0
-        file2.text_sha1 = ""
+        file2.text_sha1 = b""
         inv.add(file1)
         inv.add(file2)
-        delta = [(u'path', None, 'id1', None), (u'path', None, 'id2', None)]
+        delta = [(u'path', None, b'id1', None), (u'path', None, b'id2', None)]
         self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,
             inv, delta)
 
     def test_mismatched_id_entry_id(self):
         inv = self.get_empty_inventory()
-        file1 = inventory.InventoryFile('id1', 'path', inv.root.file_id)
+        file1 = inventory.InventoryFile(b'id1', 'path', inv.root.file_id)
         file1.revision = b'result'
         file1.text_size = 0
-        file1.text_sha1 = ""
-        delta = [(None, u'path', 'id', file1)]
+        file1.text_sha1 = b""
+        delta = [(None, u'path', b'id', file1)]
         self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,
             inv, delta)
 
     def test_mismatched_new_path_entry_None(self):
         inv = self.get_empty_inventory()
-        delta = [(None, u'path', 'id', None)]
+        delta = [(None, u'path', b'id', None)]
         self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,
             inv, delta)
 
     def test_mismatched_new_path_None_entry(self):
         inv = self.get_empty_inventory()
-        file1 = inventory.InventoryFile('id1', 'path', inv.root.file_id)
+        file1 = inventory.InventoryFile(b'id1', 'path', inv.root.file_id)
         file1.revision = b'result'
         file1.text_size = 0
-        file1.text_sha1 = ""
-        delta = [(u"path", None, 'id1', file1)]
+        file1.text_sha1 = b""
+        delta = [(u"path", None, b'id1', file1)]
         self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,
             inv, delta)
 
     def test_parent_is_not_directory(self):
         inv = self.get_empty_inventory()
-        file1 = inventory.InventoryFile('id1', 'path', inv.root.file_id)
+        file1 = inventory.InventoryFile(b'id1', 'path', inv.root.file_id)
         file1.revision = b'result'
         file1.text_size = 0
-        file1.text_sha1 = ""
-        file2 = inventory.InventoryFile('id2', 'path2', 'id1')
+        file1.text_sha1 = b""
+        file2 = inventory.InventoryFile(b'id2', 'path2', b'id1')
         file2.revision = b'result'
         file2.text_size = 0
-        file2.text_sha1 = ""
+        file2.text_sha1 = b""
         inv.add(file1)
-        delta = [(None, u'path/path2', 'id2', file2)]
+        delta = [(None, u'path/path2', b'id2', file2)]
         self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,
             inv, delta)
 
     def test_parent_is_missing(self):
         inv = self.get_empty_inventory()
-        file2 = inventory.InventoryFile('id2', 'path2', 'missingparent')
+        file2 = inventory.InventoryFile(b'id2', 'path2', 'missingparent')
         file2.revision = b'result'
         file2.text_size = 0
-        file2.text_sha1 = ""
-        delta = [(None, u'path/path2', 'id2', file2)]
+        file2.text_sha1 = b""
+        delta = [(None, u'path/path2', b'id2', file2)]
         self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,
             inv, delta)
 
     def test_new_parent_path_has_wrong_id(self):
         inv = self.get_empty_inventory()
-        parent1 = inventory.InventoryDirectory('p-1', 'dir', inv.root.file_id)
+        parent1 = inventory.InventoryDirectory(b'p-1', 'dir', inv.root.file_id)
         parent1.revision = b'result'
-        parent2 = inventory.InventoryDirectory('p-2', 'dir2', inv.root.file_id)
+        parent2 = inventory.InventoryDirectory(b'p-2', 'dir2', inv.root.file_id)
         parent2.revision = b'result'
-        file1 = inventory.InventoryFile('id', 'path', 'p-2')
+        file1 = inventory.InventoryFile(b'id', 'path', b'p-2')
         file1.revision = b'result'
         file1.text_size = 0
-        file1.text_sha1 = ""
+        file1.text_sha1 = b""
         inv.add(parent1)
         inv.add(parent2)
         # This delta claims that file1 is at dir/path, but actually its at
         # dir2/path if you follow the inventory parent structure.
-        delta = [(None, u'dir/path', 'id', file1)]
+        delta = [(None, u'dir/path', b'id', file1)]
         self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,
             inv, delta)
 
     def test_old_parent_path_is_wrong(self):
         inv = self.get_empty_inventory()
-        parent1 = inventory.InventoryDirectory('p-1', 'dir', inv.root.file_id)
+        parent1 = inventory.InventoryDirectory(b'p-1', 'dir', inv.root.file_id)
         parent1.revision = b'result'
-        parent2 = inventory.InventoryDirectory('p-2', 'dir2', inv.root.file_id)
+        parent2 = inventory.InventoryDirectory(b'p-2', 'dir2', inv.root.file_id)
         parent2.revision = b'result'
-        file1 = inventory.InventoryFile('id', 'path', 'p-2')
+        file1 = inventory.InventoryFile(b'id', 'path', b'p-2')
         file1.revision = b'result'
         file1.text_size = 0
-        file1.text_sha1 = ""
+        file1.text_sha1 = b""
         inv.add(parent1)
         inv.add(parent2)
         inv.add(file1)
         # This delta claims that file1 was at dir/path, but actually it was at
         # dir2/path if you follow the inventory parent structure.
-        delta = [(u'dir/path', None, 'id', None)]
+        delta = [(u'dir/path', None, b'id', None)]
         self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,
             inv, delta)
 
     def test_old_parent_path_is_for_other_id(self):
         inv = self.get_empty_inventory()
-        parent1 = inventory.InventoryDirectory('p-1', 'dir', inv.root.file_id)
+        parent1 = inventory.InventoryDirectory(b'p-1', 'dir', inv.root.file_id)
         parent1.revision = b'result'
-        parent2 = inventory.InventoryDirectory('p-2', 'dir2', inv.root.file_id)
+        parent2 = inventory.InventoryDirectory(b'p-2', 'dir2', inv.root.file_id)
         parent2.revision = b'result'
-        file1 = inventory.InventoryFile('id', 'path', 'p-2')
+        file1 = inventory.InventoryFile(b'id', 'path', b'p-2')
         file1.revision = b'result'
         file1.text_size = 0
-        file1.text_sha1 = ""
-        file2 = inventory.InventoryFile('id2', 'path', 'p-1')
+        file1.text_sha1 = b""
+        file2 = inventory.InventoryFile(b'id2', 'path', b'p-1')
         file2.revision = b'result'
         file2.text_size = 0
-        file2.text_sha1 = ""
+        file2.text_sha1 = b""
         inv.add(parent1)
         inv.add(parent2)
         inv.add(file1)
@@ -565,45 +561,45 @@
         # This delta claims that file1 was at dir/path, but actually it was at
         # dir2/path if you follow the inventory parent structure. At dir/path
         # is another entry we should not delete.
-        delta = [(u'dir/path', None, 'id', None)]
+        delta = [(u'dir/path', None, b'id', None)]
         self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,
             inv, delta)
 
     def test_add_existing_id_new_path(self):
         inv = self.get_empty_inventory()
-        parent1 = inventory.InventoryDirectory('p-1', 'dir1', inv.root.file_id)
+        parent1 = inventory.InventoryDirectory(b'p-1', 'dir1', inv.root.file_id)
         parent1.revision = b'result'
-        parent2 = inventory.InventoryDirectory('p-1', 'dir2', inv.root.file_id)
+        parent2 = inventory.InventoryDirectory(b'p-1', 'dir2', inv.root.file_id)
         parent2.revision = b'result'
         inv.add(parent1)
-        delta = [(None, u'dir2', 'p-1', parent2)]
+        delta = [(None, u'dir2', b'p-1', parent2)]
         self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,
             inv, delta)
 
     def test_add_new_id_existing_path(self):
         inv = self.get_empty_inventory()
-        parent1 = inventory.InventoryDirectory('p-1', 'dir1', inv.root.file_id)
+        parent1 = inventory.InventoryDirectory(b'p-1', 'dir1', inv.root.file_id)
         parent1.revision = b'result'
-        parent2 = inventory.InventoryDirectory('p-2', 'dir1', inv.root.file_id)
+        parent2 = inventory.InventoryDirectory(b'p-2', 'dir1', inv.root.file_id)
         parent2.revision = b'result'
         inv.add(parent1)
-        delta = [(None, u'dir1', 'p-2', parent2)]
+        delta = [(None, u'dir1', b'p-2', parent2)]
         self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,
             inv, delta)
 
     def test_remove_dir_leaving_dangling_child(self):
         inv = self.get_empty_inventory()
-        dir1 = inventory.InventoryDirectory('p-1', 'dir1', inv.root.file_id)
+        dir1 = inventory.InventoryDirectory(b'p-1', 'dir1', inv.root.file_id)
         dir1.revision = b'result'
-        dir2 = inventory.InventoryDirectory('p-2', 'child1', 'p-1')
+        dir2 = inventory.InventoryDirectory(b'p-2', 'child1', b'p-1')
         dir2.revision = b'result'
-        dir3 = inventory.InventoryDirectory('p-3', 'child2', 'p-1')
+        dir3 = inventory.InventoryDirectory(b'p-3', 'child2', b'p-1')
         dir3.revision = b'result'
         inv.add(dir1)
         inv.add(dir2)
         inv.add(dir3)
-        delta = [(u'dir1', None, 'p-1', None),
-            (u'dir1/child2', None, 'p-3', None)]
+        delta = [(u'dir1', None, b'p-1', None),
+            (u'dir1/child2', None, b'p-3', None)]
         self.assertRaises(errors.InconsistentDelta, self.apply_delta, self,
             inv, delta)
 
@@ -612,7 +608,7 @@
         file1 = inventory.InventoryFile(b'file-id', 'path', inv.root.file_id)
         file1.revision = b'result'
         file1.text_size = 0
-        file1.text_sha1 = ''
+        file1.text_sha1 = b''
         delta = [(None, u'path', b'file-id', file1)]
         res_inv = self.apply_delta(self, inv, delta, invalid_delta=False)
         self.assertEqual(b'file-id', res_inv.get_entry(b'file-id').file_id)
@@ -622,7 +618,7 @@
         file1 = inventory.InventoryFile(b'file-id', 'path', inv.root.file_id)
         file1.revision = b'result'
         file1.text_size = 0
-        file1.text_sha1 = ''
+        file1.text_sha1 = b''
         inv.add(file1)
         delta = [(u'path', None, b'file-id', None)]
         res_inv = self.apply_delta(self, inv, delta, invalid_delta=False)
@@ -685,16 +681,16 @@
 
     def test_is_root(self):
         """Ensure our root-checking code is accurate."""
-        inv = inventory.Inventory('TREE_ROOT')
-        self.assertTrue(inv.is_root('TREE_ROOT'))
-        self.assertFalse(inv.is_root('booga'))
-        inv.root.file_id = 'booga'
-        self.assertFalse(inv.is_root('TREE_ROOT'))
-        self.assertTrue(inv.is_root('booga'))
+        inv = inventory.Inventory(b'TREE_ROOT')
+        self.assertTrue(inv.is_root(b'TREE_ROOT'))
+        self.assertFalse(inv.is_root(b'booga'))
+        inv.root.file_id = b'booga'
+        self.assertFalse(inv.is_root(b'TREE_ROOT'))
+        self.assertTrue(inv.is_root(b'booga'))
         # works properly even if no root is set
         inv.root = None
-        self.assertFalse(inv.is_root('TREE_ROOT'))
-        self.assertFalse(inv.is_root('booga'))
+        self.assertFalse(inv.is_root(b'TREE_ROOT'))
+        self.assertFalse(inv.is_root(b'booga'))
 
     def test_entries_for_empty_inventory(self):
         """Test that entries() will not fail for an empty inventory"""
@@ -706,34 +702,34 @@
 
     def test_file_invalid_entry_name(self):
         self.assertRaises(errors.InvalidEntryName, inventory.InventoryFile,
-            '123', 'a/hello.c', ROOT_ID)
+            b'123', 'a/hello.c', ROOT_ID)
 
     def test_file_backslash(self):
-        file = inventory.InventoryFile('123', 'h\\ello.c', ROOT_ID)
+        file = inventory.InventoryFile(b'123', 'h\\ello.c', ROOT_ID)
         self.assertEquals(file.name, 'h\\ello.c')
 
     def test_file_kind_character(self):
-        file = inventory.InventoryFile('123', 'hello.c', ROOT_ID)
+        file = inventory.InventoryFile(b'123', 'hello.c', ROOT_ID)
         self.assertEqual(file.kind_character(), '')
 
     def test_dir_kind_character(self):
-        dir = inventory.InventoryDirectory('123', 'hello.c', ROOT_ID)
+        dir = inventory.InventoryDirectory(b'123', 'hello.c', ROOT_ID)
         self.assertEqual(dir.kind_character(), '/')
 
     def test_link_kind_character(self):
-        dir = inventory.InventoryLink('123', 'hello.c', ROOT_ID)
+        dir = inventory.InventoryLink(b'123', 'hello.c', ROOT_ID)
         self.assertEqual(dir.kind_character(), '')
 
     def test_dir_detect_changes(self):
-        left = inventory.InventoryDirectory('123', 'hello.c', ROOT_ID)
-        right = inventory.InventoryDirectory('123', 'hello.c', ROOT_ID)
+        left = inventory.InventoryDirectory(b'123', 'hello.c', ROOT_ID)
+        right = inventory.InventoryDirectory(b'123', 'hello.c', ROOT_ID)
         self.assertEqual((False, False), left.detect_changes(right))
         self.assertEqual((False, False), right.detect_changes(left))
 
     def test_file_detect_changes(self):
-        left = inventory.InventoryFile('123', 'hello.c', ROOT_ID)
+        left = inventory.InventoryFile(b'123', 'hello.c', ROOT_ID)
         left.text_sha1 = 123
-        right = inventory.InventoryFile('123', 'hello.c', ROOT_ID)
+        right = inventory.InventoryFile(b'123', 'hello.c', ROOT_ID)
         right.text_sha1 = 123
         self.assertEqual((False, False), left.detect_changes(right))
         self.assertEqual((False, False), right.detect_changes(left))
@@ -745,9 +741,9 @@
         self.assertEqual((True, True), right.detect_changes(left))
 
     def test_symlink_detect_changes(self):
-        left = inventory.InventoryLink('123', 'hello.c', ROOT_ID)
+        left = inventory.InventoryLink(b'123', 'hello.c', ROOT_ID)
         left.symlink_target='foo'
-        right = inventory.InventoryLink('123', 'hello.c', ROOT_ID)
+        right = inventory.InventoryLink(b'123', 'hello.c', ROOT_ID)
         right.symlink_target='foo'
         self.assertEqual((False, False), left.detect_changes(right))
         self.assertEqual((False, False), right.detect_changes(left))
@@ -756,15 +752,15 @@
         self.assertEqual((True, False), right.detect_changes(left))
 
     def test_file_has_text(self):
-        file = inventory.InventoryFile('123', 'hello.c', ROOT_ID)
+        file = inventory.InventoryFile(b'123', 'hello.c', ROOT_ID)
         self.assertTrue(file.has_text())
 
     def test_directory_has_text(self):
-        dir = inventory.InventoryDirectory('123', 'hello.c', ROOT_ID)
+        dir = inventory.InventoryDirectory(b'123', 'hello.c', ROOT_ID)
         self.assertFalse(dir.has_text())
 
     def test_link_has_text(self):
-        link = inventory.InventoryLink('123', 'hello.c', ROOT_ID)
+        link = inventory.InventoryLink(b'123', 'hello.c', ROOT_ID)
         self.assertFalse(link.has_text())
 
     def test_make_entry(self):
@@ -803,17 +799,17 @@
         # renamed/reparented and modified
         # change kind (perhaps can't be done yet?)
         # also, merged in combination with all of these?
-        old_a = InventoryFile('a-id', 'a_file', ROOT_ID)
-        old_a.text_sha1 = '123132'
+        old_a = InventoryFile(b'a-id', 'a_file', ROOT_ID)
+        old_a.text_sha1 = b'123132'
         old_a.text_size = 0
-        new_a = InventoryFile('a-id', 'a_file', ROOT_ID)
-        new_a.text_sha1 = '123132'
+        new_a = InventoryFile(b'a-id', 'a_file', ROOT_ID)
+        new_a.text_sha1 = b'123132'
         new_a.text_size = 0
 
         self.assertChangeDescription('unchanged', old_a, new_a)
 
         new_a.text_size = 10
-        new_a.text_sha1 = 'abcabc'
+        new_a.text_sha1 = b'abcabc'
         self.assertChangeDescription('modified', old_a, new_a)