Merge lp:~gz/brz/py3_bootstrap2 into lp:brz

[Martin Packman]

More progress towards Python 3 support

Another somewhat large branch mostly sorting out string semantics across a range of modules.

Also includes some test fixes for Python 3 to start passing, particularly bt.test_inventory_delta and the start of bt.test_inv as well.

[Jelmer Vernooij (jelmer)]

review: Approve

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

Running landing tests failed
http://10.242.247.184:8080/job/brz-dev/119/

=== modified file 'breezy/_chk_map_py.py'
--- breezy/_chk_map_py.py	2017-05-22 00:56:52 +0000
+++ breezy/_chk_map_py.py	2017-06-11 01:47:17 +0000
@@ -21,6 +21,7 @@
 import zlib
 import struct
 
+from .sixish import bytesintern
 from .static_tuple import StaticTuple
 
 _LeafNode = None
@@ -44,7 +45,7 @@
 
 def _search_key_16(key):
     """Map the key tuple into a search key string which has 16-way fan out."""
-    return '\x00'.join(['%08X' % _crc32(bit) for bit in key])
+    return b'\x00'.join([b'%08X' % _crc32(bit) for bit in key])
 
 
 def _search_key_255(key):
@@ -53,11 +54,11 @@
     We use 255-way because '\n' is used as a delimiter, and causes problems
     while parsing.
     """
-    bytes = '\x00'.join([struct.pack('>L', _crc32(bit)) for bit in key])
-    return bytes.replace('\n', '_')
-
-
-def _deserialise_leaf_node(bytes, key, search_key_func=None):
+    data = b'\x00'.join([struct.pack('>L', _crc32(bit)) for bit in key])
+    return data.replace(b'\n', b'_')
+
+
+def _deserialise_leaf_node(data, key, search_key_func=None):
     """Deserialise bytes, with key key, into a LeafNode.
 
     :param bytes: The bytes of the node.
@@ -72,13 +73,13 @@
     result = _LeafNode(search_key_func=search_key_func)
     # Splitlines can split on '\r' so don't use it, split('\n') adds an
     # extra '' if the bytes ends in a final newline.
-    lines = bytes.split('\n')
+    lines = data.split(b'\n')
     trailing = lines.pop()
-    if trailing != '':
+    if trailing != b'':
         raise AssertionError('We did not have a final newline for %s'
                              % (key,))
     items = {}
-    if lines[0] != 'chkleaf:':
+    if lines[0] != b'chkleaf:':
         raise ValueError("not a serialised leaf node: %r" % bytes)
     maximum_size = int(lines[1])
     width = int(lines[2])
@@ -87,7 +88,7 @@
     pos = 5
     while pos < len(lines):
         line = prefix + lines[pos]
-        elements = line.split('\x00')
+        elements = line.split(b'\x00')
         pos += 1
         if len(elements) != width + 1:
             raise AssertionError(
@@ -96,7 +97,7 @@
         num_value_lines = int(elements[-1])
         value_lines = lines[pos:pos+num_value_lines]
         pos += num_value_lines
-        value = '\n'.join(value_lines)
+        value = b'\n'.join(value_lines)
         items[StaticTuple.from_sequence(elements[:-1])] = value
     if len(items) != length:
         raise AssertionError("item count (%d) mismatch for key %s,"
@@ -115,12 +116,12 @@
     else:
         result._search_prefix = _unknown
         result._common_serialised_prefix = prefix
-    if len(bytes) != result._current_size():
+    if len(data) != result._current_size():
         raise AssertionError('_current_size computed incorrectly')
     return result
 
 
-def _deserialise_internal_node(bytes, key, search_key_func=None):
+def _deserialise_internal_node(data, key, search_key_func=None):
     global _unknown, _LeafNode, _InternalNode
     if _InternalNode is None:
         from breezy import chk_map
@@ -131,12 +132,12 @@
     # Splitlines can split on '\r' so don't use it, remove the extra ''
     # from the result of split('\n') because we should have a trailing
     # newline
-    lines = bytes.split('\n')
-    if lines[-1] != '':
+    lines = data.split(b'\n')
+    if lines[-1] != b'':
         raise ValueError("last line must be ''")
     lines.pop(-1)
     items = {}
-    if lines[0] != 'chknode:':
+    if lines[0] != b'chknode:':
         raise ValueError("not a serialised internal node: %r" % bytes)
     maximum_size = int(lines[1])
     width = int(lines[2])
@@ -144,7 +145,7 @@
     common_prefix = lines[4]
     for line in lines[5:]:
         line = common_prefix + line
-        prefix, flat_key = line.rsplit('\x00', 1)
+        prefix, flat_key = line.rsplit(b'\x00', 1)
         items[prefix] = StaticTuple(flat_key,)
     if len(items) == 0:
         raise AssertionError("We didn't find any item for %s" % key)
@@ -161,9 +162,9 @@
     return result
 
 
-def _bytes_to_text_key(bytes):
+def _bytes_to_text_key(data):
     """Take a CHKInventory value string and return a (file_id, rev_id) tuple"""
-    sections = bytes.split('\n')
-    kind, file_id = sections[0].split(': ')
-    return (intern(file_id), intern(sections[3]))
+    sections = data.split(b'\n')
+    kind, file_id = sections[0].split(b': ')
+    return (bytesintern(file_id), bytesintern(sections[3]))
 
 
=== modified file 'breezy/_chunks_to_lines_py.py'
--- breezy/_chunks_to_lines_py.py	2017-05-21 18:10:28 +0000
+++ breezy/_chunks_to_lines_py.py	2017-06-11 01:47:17 +0000
@@ -41,10 +41,10 @@
         if not chunk:
             # Empty strings are never valid lines
             break
-        elif '\n' in chunk[:-1]:
+        elif b'\n' in chunk[:-1]:
             # This chunk has an extra '\n', so we will have to split it
             break
-        elif chunk[-1] != '\n':
+        elif chunk[-1:] != b'\n':
             # This chunk does not have a trailing newline
             last_no_newline = True
     else:
@@ -56,4 +56,4 @@
 
     # These aren't simple lines, just join and split again.
     from breezy import osutils
-    return osutils._split_lines(''.join(chunks))
+    return osutils._split_lines(b''.join(chunks))
 
=== modified file 'breezy/_dirstate_helpers_py.py'
--- breezy/_dirstate_helpers_py.py	2017-06-10 01:57:23 +0000
+++ breezy/_dirstate_helpers_py.py	2017-06-11 01:47:17 +0000
@@ -184,7 +184,7 @@
     if not isinstance(path2, bytes):
         raise TypeError("'path2' must be a plain string, not %s: %r"
                         % (type(path2), path2))
-    return path1.split('/') < path2.split('/')
+    return path1.split(b'/') < path2.split(b'/')
 
 
 def _lt_path_by_dirblock(path1, path2):
@@ -207,7 +207,7 @@
     dirname1, basename1 = os.path.split(path1)
     key1 = (dirname1.split(b'/'), basename1)
     dirname2, basename2 = os.path.split(path2)
-    key2 = (dirname2.split('/'), basename2)
+    key2 = (dirname2.split(b'/'), basename2)
     return key1 < key2
 
 
 
=== modified file 'breezy/_groupcompress_py.py'
--- breezy/_groupcompress_py.py	2017-06-04 18:09:30 +0000
+++ breezy/_groupcompress_py.py	2017-06-11 01:47:17 +0000
@@ -290,7 +290,7 @@
         if bytes_length is None:
             bytes_length = sum(map(len, new_lines))
         # reserved for content type, content length
-        out_lines = ['', '', encode_base128_int(bytes_length)]
+        out_lines = [b'', b'', encode_base128_int(bytes_length)]
         index_lines = [False, False, False]
         output_handler = _OutputHandler(out_lines, index_lines,
                                         self._MIN_MATCH_BYTES)
@@ -316,26 +316,26 @@
 
 def encode_base128_int(val):
     """Convert an integer into a 7-bit lsb encoding."""
-    bytes = []
+    data = bytearray()
     count = 0
     while val >= 0x80:
-        bytes.append(chr((val | 0x80) & 0xFF))
+        data.append((val | 0x80) & 0xFF)
         val >>= 7
-    bytes.append(chr(val))
-    return ''.join(bytes)
-
-
-def decode_base128_int(bytes):
+    data.append(val)
+    return bytes(data)
+
+
+def decode_base128_int(data):
     """Decode an integer from a 7-bit lsb encoding."""
     offset = 0
     val = 0
     shift = 0
-    bval = ord(bytes[offset])
+    bval = ord(data[offset])
     while bval >= 0x80:
         val |= (bval & 0x7F) << shift
         shift += 7
         offset += 1
-        bval = ord(bytes[offset])
+        bval = ord(data[offset])
     val |= bval << shift
     offset += 1
     return val, offset
 
=== modified file 'breezy/bzrworkingtree.py'
--- breezy/bzrworkingtree.py	2017-06-10 18:44:23 +0000
+++ breezy/bzrworkingtree.py	2017-06-11 01:47:17 +0000
@@ -78,11 +78,11 @@
     )
 
 
-MERGE_MODIFIED_HEADER_1 = "BZR merge-modified list format 1"
+MERGE_MODIFIED_HEADER_1 = b"BZR merge-modified list format 1"
 # TODO: Modifying the conflict objects or their type is currently nearly
 # impossible as there is no clear relationship between the working tree format
 # and the conflict list file format.
-CONFLICT_HEADER_1 = "BZR conflict list format 1"
+CONFLICT_HEADER_1 = b"BZR conflict list format 1"
 
 
 class InventoryWorkingTree(WorkingTree,MutableInventoryTree):
@@ -382,7 +382,7 @@
             return _mod_conflicts.ConflictList()
         try:
             try:
-                if next(confile) != CONFLICT_HEADER_1 + '\n':
+                if next(confile) != CONFLICT_HEADER_1 + b'\n':
                     raise errors.ConflictFormatError()
             except StopIteration:
                 raise errors.ConflictFormatError()
@@ -650,7 +650,7 @@
 
     def _put_rio(self, filename, stanzas, header):
         self._must_be_locked()
-        my_file = _mod_rio.rio_file(stanzas, header.encode('ascii'))
+        my_file = _mod_rio.rio_file(stanzas, header)
         self._transport.put_file(filename, my_file,
             mode=self.controldir._get_file_mode())
 
@@ -680,7 +680,7 @@
         try:
             merge_hashes = {}
             try:
-                if next(hashfile) != MERGE_MODIFIED_HEADER_1 + '\n':
+                if next(hashfile) != MERGE_MODIFIED_HEADER_1 + b'\n':
                     raise errors.MergeModifiedFormatError()
             except StopIteration:
                 raise errors.MergeModifiedFormatError()
 
=== modified file 'breezy/chk_map.py'
--- breezy/chk_map.py	2017-06-05 20:48:31 +0000
+++ breezy/chk_map.py	2017-06-11 01:47:17 +0000
@@ -100,7 +100,7 @@
 
 def _search_key_plain(key):
     """Map the key tuple into a search string that just uses the key bytes."""
-    return '\x00'.join(key)
+    return b'\x00'.join(key)
 
 
 search_key_registry = registry.Registry()
@@ -197,8 +197,8 @@
         self._ensure_root()
         res = self._dump_tree_node(self._root_node, prefix='', indent='',
                                    include_keys=include_keys)
-        res.append('') # Give a trailing '\n'
-        return '\n'.join(res)
+        res.append(b'') # Give a trailing '\n'
+        return b'\n'.join(res)
 
     def _dump_tree_node(self, node, prefix, indent, include_keys=True):
         """For this node and all children, generate a string representation."""
@@ -208,11 +208,11 @@
         else:
             node_key = node.key()
             if node_key is not None:
-                key_str = ' %s' % (node_key[0],)
+                key_str = b' %s' % (node_key[0],)
             else:
-                key_str = ' None'
-        result.append('%s%r %s%s' % (indent, prefix, node.__class__.__name__,
-                                     key_str))
+                key_str = b' None'
+        result.append(b'%s%r %s%s' % (indent, prefix, node.__class__.__name__,
+                                      key_str))
         if isinstance(node, InternalNode):
             # Trigger all child nodes to get loaded
             list(node._iter_nodes(self._store))
@@ -223,7 +223,7 @@
             for key, value in sorted(viewitems(node._items)):
                 # Don't use prefix nor indent here to line up when used in
                 # tests in conjunction with assertEqualDiff
-                result.append('      %r %r' % (tuple(key), value))
+                result.append(b'      %r %r' % (tuple(key), value))
         return result
 
     @classmethod
@@ -680,7 +680,7 @@
             if not common_prefix:
                 # if common_prefix is the empty string, then we know it won't
                 # change further
-                return ''
+                return b''
         return common_prefix
 
 
@@ -786,7 +786,7 @@
         # TODO: Should probably be done without actually joining the key, but
         #       then that can be done via the C extension
         return (len(self._serialise_key(key)) + 1
-                + len(str(value.count('\n'))) + 1
+                + len(str(value.count(b'\n'))) + 1
                 + len(value) + 1)
 
     def _search_key(self, key):
@@ -853,7 +853,7 @@
             #       may get a '\00' node anywhere, but won't have keys of
             #       different lengths.
             if len(prefix) < split_at:
-                prefix += '\x00'*(split_at - len(prefix))
+                prefix += b'\x00'*(split_at - len(prefix))
             if prefix not in result:
                 node = LeafNode(search_key_func=self._search_key_func)
                 node.set_maximum_size(self._maximum_size)
@@ -889,7 +889,7 @@
                 raise AssertionError('%r must be known' % self._search_prefix)
             return self._search_prefix, [("", self)]
 
-    _serialise_key = '\x00'.join
+    _serialise_key = b'\x00'.join
 
     def serialise(self, store):
         """Serialise the LeafNode to store.
@@ -897,22 +897,22 @@
         :param store: A VersionedFiles honouring the CHK extensions.
         :return: An iterable of the keys inserted by this operation.
         """
-        lines = ["chkleaf:\n"]
-        lines.append("%d\n" % self._maximum_size)
-        lines.append("%d\n" % self._key_width)
-        lines.append("%d\n" % self._len)
+        lines = [b"chkleaf:\n"]
+        lines.append(b"%d\n" % self._maximum_size)
+        lines.append(b"%d\n" % self._key_width)
+        lines.append(b"%d\n" % self._len)
         if self._common_serialised_prefix is None:
-            lines.append('\n')
+            lines.append(b'\n')
             if len(self._items) != 0:
                 raise AssertionError('If _common_serialised_prefix is None'
                     ' we should have no items')
         else:
-            lines.append('%s\n' % (self._common_serialised_prefix,))
+            lines.append(b'%s\n' % (self._common_serialised_prefix,))
             prefix_len = len(self._common_serialised_prefix)
         for key, value in sorted(viewitems(self._items)):
             # Always add a final newline
-            value_lines = osutils.chunks_to_lines([value + '\n'])
-            serialized = "%s\x00%s\n" % (self._serialise_key(key),
+            value_lines = osutils.chunks_to_lines([value + b'\n'])
+            serialized = b"%s\x00%d\n" % (self._serialise_key(key),
                                          len(value_lines))
             if not serialized.startswith(self._common_serialised_prefix):
                 raise AssertionError('We thought the common prefix was %r'
@@ -921,11 +921,11 @@
             lines.append(serialized[prefix_len:])
             lines.extend(value_lines)
         sha1, _, _ = store.add_lines((None,), (), lines)
-        self._key = StaticTuple("sha1:" + sha1,).intern()
-        bytes = ''.join(lines)
-        if len(bytes) != self._current_size():
+        self._key = StaticTuple(b"sha1:" + sha1,).intern()
+        data = b''.join(lines)
+        if len(data) != self._current_size():
             raise AssertionError('Invalid _current_size')
-        _get_cache()[self._key] = bytes
+        _get_cache()[self._key] = data
         return [self._key]
 
     def refs(self):
@@ -1304,34 +1304,34 @@
                 continue
             for key in node.serialise(store):
                 yield key
-        lines = ["chknode:\n"]
-        lines.append("%d\n" % self._maximum_size)
-        lines.append("%d\n" % self._key_width)
-        lines.append("%d\n" % self._len)
+        lines = [b"chknode:\n"]
+        lines.append(b"%d\n" % self._maximum_size)
+        lines.append(b"%d\n" % self._key_width)
+        lines.append(b"%d\n" % self._len)
         if self._search_prefix is None:
             raise AssertionError("_search_prefix should not be None")
-        lines.append('%s\n' % (self._search_prefix,))
+        lines.append(b'%s\n' % (self._search_prefix,))
         prefix_len = len(self._search_prefix)
         for prefix, node in sorted(viewitems(self._items)):
             if isinstance(node, StaticTuple):
                 key = node[0]
             else:
                 key = node._key[0]
-            serialised = "%s\x00%s\n" % (prefix, key)
+            serialised = b"%s\x00%s\n" % (prefix, key)
             if not serialised.startswith(self._search_prefix):
                 raise AssertionError("prefixes mismatch: %s must start with %s"
                     % (serialised, self._search_prefix))
             lines.append(serialised[prefix_len:])
         sha1, _, _ = store.add_lines((None,), (), lines)
-        self._key = StaticTuple("sha1:" + sha1,).intern()
-        _get_cache()[self._key] = ''.join(lines)
+        self._key = StaticTuple(b"sha1:" + sha1,).intern()
+        _get_cache()[self._key] = b''.join(lines)
         yield self._key
 
     def _search_key(self, key):
         """Return the serialised key for key in this node."""
         # search keys are fixed width. All will be self._node_width wide, so we
         # pad as necessary.
-        return (self._search_key_func(key) + '\x00'*self._node_width)[:self._node_width]
+        return (self._search_key_func(key) + b'\x00'*self._node_width)[:self._node_width]
 
     def _search_prefix_filter(self, key):
         """Serialise key for use as a prefix filter in iteritems."""
@@ -1450,12 +1450,12 @@
         return new_leaf
 
 
-def _deserialise(bytes, key, search_key_func):
+def _deserialise(data, key, search_key_func):
     """Helper for repositorydetails - convert bytes to a node."""
-    if bytes.startswith("chkleaf:\n"):
-        node = LeafNode.deserialise(bytes, key, search_key_func=search_key_func)
-    elif bytes.startswith("chknode:\n"):
-        node = InternalNode.deserialise(bytes, key,
+    if data.startswith(b"chkleaf:\n"):
+        node = LeafNode.deserialise(data, key, search_key_func=search_key_func)
+    elif data.startswith(b"chknode:\n"):
+        node = InternalNode.deserialise(data, key,
             search_key_func=search_key_func)
     else:
         raise AssertionError("Unknown node type.")
 
=== modified file 'breezy/commit.py'
--- breezy/commit.py	2017-05-30 20:17:23 +0000
+++ breezy/commit.py	2017-06-11 01:47:17 +0000
@@ -280,7 +280,7 @@
                     raise errors.RootNotRich()
         if message_callback is None:
             if message is not None:
-                if isinstance(message, str):
+                if isinstance(message, bytes):
                     message = message.decode(get_user_encoding())
                 message_callback = lambda x: message
             else:
@@ -657,7 +657,7 @@
         """
         exclude = self.exclude
         specific_files = self.specific_files
-        mutter("Selecting files for commit with filter %s", specific_files)
+        mutter("Selecting files for commit with filter %r", specific_files)
 
         self._check_strict()
         if self.use_record_iter_changes:
 
=== modified file 'breezy/config.py'
--- breezy/config.py	2017-06-10 12:56:18 +0000
+++ breezy/config.py	2017-06-11 01:47:17 +0000
@@ -477,10 +477,12 @@
         If no username can be found, errors.NoWhoami exception is raised.
         """
         v = os.environ.get('BRZ_EMAIL')
-        if v and not PY3:
-            return v.decode(osutils.get_user_encoding())
+        if v:
+            if not PY3:
+                v = v.decode(osutils.get_user_encoding())
+            return v
         v = self._get_user_id()
-        if v and not PY3:
+        if v:
             return v
         return default_email()
 
@@ -1497,11 +1499,15 @@
 
 def default_email():
     v = os.environ.get('BRZ_EMAIL')
-    if v and not PY3:
-        return v.decode(osutils.get_user_encoding())
+    if v:
+        if not PY3:
+            v = v.decode(osutils.get_user_encoding())
+        return v
     v = os.environ.get('EMAIL')
-    if v and not PY3:
-        return v.decode(osutils.get_user_encoding())
+    if v:
+        if not PY3:
+            v = v.decode(osutils.get_user_encoding())
+        return v
     name, email = _auto_user_id()
     if name and email:
         return u'%s <%s>' % (name, email)
 
=== modified file 'breezy/dirstate.py'
--- breezy/dirstate.py	2017-06-10 02:39:00 +0000
+++ breezy/dirstate.py	2017-06-11 01:47:17 +0000
@@ -3541,9 +3541,13 @@
             source_details = DirState.NULL_PARENT_DETAILS
         else:
             source_details = entry[1][self.source_index]
+        # GZ 2017-06-09: Eck, more sets.
+        _fdltr = {b'f', b'd', b'l', b't', b'r'}
+        _fdlt = {b'f', b'd', b'l', b't'}
+        _ra = (b'r', b'a')
         target_details = entry[1][self.target_index]
         target_minikind = target_details[0]
-        if path_info is not None and target_minikind in 'fdlt':
+        if path_info is not None and target_minikind in _fdlt:
             if not (self.target_index == 0):
                 raise AssertionError()
             link_or_sha1 = update_entry(self.state, entry,
@@ -3555,10 +3559,6 @@
             link_or_sha1 = None
         file_id = entry[0][2]
         source_minikind = source_details[0]
-        # GZ 2017-06-09: Eck, more sets.
-        _fdltr = {b'f', b'd', b'l', b't', b'r'}
-        _fdlt = {b'f', b'd', b'l', b't'}
-        _ra = (b'r', b'a')
         if source_minikind in _fdltr and target_minikind in _fdlt:
             # claimed content in both: diff
             #   r    | fdlt   |      | add source to search, add id path move and perform
 
=== modified file 'breezy/groupcompress.py'
--- breezy/groupcompress.py	2017-06-05 20:48:31 +0000
+++ breezy/groupcompress.py	2017-06-11 01:47:17 +0000
@@ -61,7 +61,7 @@
 BATCH_SIZE = 2**16
 
 # osutils.sha_string('')
-_null_sha1 = 'da39a3ee5e6b4b0d3255bfef95601890afd80709'
+_null_sha1 = b'da39a3ee5e6b4b0d3255bfef95601890afd80709'
 
 def sort_gc_optimal(parent_map):
     """Sort and group the keys in parent_map into groupcompress order.
@@ -75,8 +75,8 @@
     # properly grouped by file-id.
     per_prefix_map = {}
     for key, value in viewitems(parent_map):
-        if isinstance(key, str) or len(key) == 1:
-            prefix = ''
+        if isinstance(key, bytes) or len(key) == 1:
+            prefix = b''
         else:
             prefix = key[0]
         try:
@@ -102,9 +102,9 @@
     """
 
     # Group Compress Block v1 Zlib
-    GCB_HEADER = 'gcb1z\n'
+    GCB_HEADER = b'gcb1z\n'
     # Group Compress Block v1 Lzma
-    GCB_LZ_HEADER = 'gcb1l\n'
+    GCB_LZ_HEADER = b'gcb1l\n'
     GCB_KNOWN_HEADERS = (GCB_HEADER, GCB_LZ_HEADER)
 
     def __init__(self):
@@ -141,7 +141,7 @@
         # Expand the content if required
         if self._content is None:
             if self._content_chunks is not None:
-                self._content = ''.join(self._content_chunks)
+                self._content = b''.join(self._content_chunks)
                 self._content_chunks = None
         if self._content is None:
             # We join self._z_content_chunks here, because if we are
@@ -149,9 +149,9 @@
             # chunk
             if self._z_content_chunks is None:
                 raise AssertionError('No content to decompress')
-            z_content = ''.join(self._z_content_chunks)
-            if z_content == '':
-                self._content = ''
+            z_content = b''.join(self._z_content_chunks)
+            if z_content == b'':
+                self._content = b''
             elif self._compressor_name == 'lzma':
                 # We don't do partial lzma decomp yet
                 import pylzma
@@ -201,7 +201,7 @@
             # The stream is finished
             self._z_content_decompressor = None
 
-    def _parse_bytes(self, bytes, pos):
+    def _parse_bytes(self, data, pos):
         """Read the various lengths from the header.
 
         This also populates the various 'compressed' buffers.
@@ -211,17 +211,17 @@
         # At present, we have 2 integers for the compressed and uncompressed
         # content. In base10 (ascii) 14 bytes can represent > 1TB, so to avoid
         # checking too far, cap the search to 14 bytes.
-        pos2 = bytes.index('\n', pos, pos + 14)
-        self._z_content_length = int(bytes[pos:pos2])
-        pos = pos2 + 1
-        pos2 = bytes.index('\n', pos, pos + 14)
-        self._content_length = int(bytes[pos:pos2])
-        pos = pos2 + 1
-        if len(bytes) != (pos + self._z_content_length):
+        pos2 = data.index(b'\n', pos, pos + 14)
+        self._z_content_length = int(data[pos:pos2])
+        pos = pos2 + 1
+        pos2 = data.index(b'\n', pos, pos + 14)
+        self._content_length = int(data[pos:pos2])
+        pos = pos2 + 1
+        if len(data) != (pos + self._z_content_length):
             # XXX: Define some GCCorrupt error ?
             raise AssertionError('Invalid bytes: (%d) != %d + %d' %
-                                 (len(bytes), pos, self._z_content_length))
-        self._z_content_chunks = (bytes[pos:],)
+                                 (len(data), pos, self._z_content_length))
+        self._z_content_chunks = (data[pos:],)
 
     @property
     def _z_content(self):
@@ -230,7 +230,7 @@
         Meant only to be used by the test suite.
         """
         if self._z_content_chunks is not None:
-            return ''.join(self._z_content_chunks)
+            return b''.join(self._z_content_chunks)
         return None
 
     @classmethod
@@ -257,17 +257,17 @@
         :return: The bytes for the content
         """
         if start == end == 0:
-            return ''
+            return b''
         self._ensure_content(end)
         # The bytes are 'f' or 'd' for the type, then a variable-length
         # base128 integer for the content size, then the actual content
         # We know that the variable-length integer won't be longer than 5
         # bytes (it takes 5 bytes to encode 2^32)
         c = self._content[start]
-        if c == 'f':
+        if c == b'f':
             type = 'fulltext'
         else:
-            if c != 'd':
+            if c != b'd':
                 raise ValueError('Unknown content control code: %s'
                                  % (c,))
             type = 'delta'
@@ -277,11 +277,10 @@
         if end != content_start + content_len:
             raise ValueError('end != len according to field header'
                 ' %s != %s' % (end, content_start + content_len))
-        if c == 'f':
-            bytes = self._content[content_start:end]
-        elif c == 'd':
-            bytes = apply_delta_to_source(self._content, content_start, end)
-        return bytes
+        if c == b'f':
+            return self._content[content_start:end]
+        # Must be type delta as checked above
+        return apply_delta_to_source(self._content, content_start, end)
 
     def set_chunked_content(self, content_chunks, length):
         """Set the content of this block to the given chunks."""
@@ -324,7 +323,7 @@
         """Create the byte stream as a series of 'chunks'"""
         self._create_z_content()
         header = self.GCB_HEADER
-        chunks = ['%s%d\n%d\n'
+        chunks = [b'%s%d\n%d\n'
                   % (header, self._z_content_length, self._content_length),
                  ]
         chunks.extend(self._z_content_chunks)
@@ -334,7 +333,7 @@
     def to_bytes(self):
         """Encode the information into a byte stream."""
         total_len, chunks = self.to_chunks()
-        return ''.join(chunks)
+        return b''.join(chunks)
 
     def _dump(self, include_text=False):
         """Take this block, and spit out a human-readable structure.
@@ -352,7 +351,7 @@
         while pos < self._content_length:
             kind = self._content[pos]
             pos += 1
-            if kind not in ('f', 'd'):
+            if kind not in (b'f', b'd'):
                 raise ValueError('invalid kind character: %r' % (kind,))
             content_len, len_len = decode_base128_int(
                                 self._content[pos:pos + 5])
@@ -360,18 +359,18 @@
             if content_len + pos > self._content_length:
                 raise ValueError('invalid content_len %d for record @ pos %d'
                                  % (content_len, pos - len_len - 1))
-            if kind == 'f': # Fulltext
+            if kind == b'f': # Fulltext
                 if include_text:
                     text = self._content[pos:pos+content_len]
-                    result.append(('f', content_len, text))
+                    result.append((b'f', content_len, text))
                 else:
-                    result.append(('f', content_len))
-            elif kind == 'd': # Delta
+                    result.append((b'f', content_len))
+            elif kind == b'd': # Delta
                 delta_content = self._content[pos:pos+content_len]
                 delta_info = []
                 # The first entry in a delta is the decompressed length
                 decomp_len, delta_pos = decode_base128_int(delta_content)
-                result.append(('d', content_len, decomp_len, delta_info))
+                result.append((b'd', content_len, decomp_len, delta_info))
                 measured_len = 0
                 while delta_pos < content_len:
                     c = ord(delta_content[delta_pos])
@@ -382,16 +381,16 @@
                                                               delta_pos)
                         if include_text:
                             text = self._content[offset:offset+length]
-                            delta_info.append(('c', offset, length, text))
+                            delta_info.append((b'c', offset, length, text))
                         else:
-                            delta_info.append(('c', offset, length))
+                            delta_info.append((b'c', offset, length))
                         measured_len += length
                     else: # Insert
                         if include_text:
                             txt = delta_content[delta_pos:delta_pos+c]
                         else:
                             txt = ''
-                        delta_info.append(('i', c, txt))
+                        delta_info.append((b'i', c, txt))
                         measured_len += c
                         delta_pos += c
                 if delta_pos != content_len:
@@ -447,7 +446,7 @@
                 # wire bytes, something...
                 return self._manager._wire_bytes()
             else:
-                return ''
+                return b''
         if storage_kind in ('fulltext', 'chunked'):
             if self._bytes is None:
                 # Grab and cache the raw bytes for this entry
@@ -842,7 +841,9 @@
             if sha1 == nostore_sha:
                 raise errors.ExistingContent()
         if key[-1] is None:
-            key = key[:-1] + ('sha1:' + sha1,)
+            # GZ 2017-06-10: Seems perverse to have to encode here.
+            sha1 = sha1.encode('ascii')
+            key = key[:-1] + (b'sha1:' + sha1,)
 
         start, end, type = self._compress(key, bytes, len(bytes) / 2, soft)
         return sha1, start, end, type
@@ -875,7 +876,7 @@
         (start_byte, start_chunk, end_byte, end_chunk) = self.labels_deltas[key]
         delta_chunks = self.chunks[start_chunk:end_chunk]
         stored_bytes = ''.join(delta_chunks)
-        if stored_bytes[0] == 'f':
+        if stored_bytes[0] == b'f':
             fulltext_len, offset = decode_base128_int(stored_bytes[1:10])
             data_len = fulltext_len + 1 + offset
             if  data_len != len(stored_bytes):
@@ -947,14 +948,14 @@
         if delta_length > max_delta_size:
             # The delta is longer than the fulltext, insert a fulltext
             type = 'fulltext'
-            out_lines = ['f', encode_base128_int(input_len)]
+            out_lines = [b'f', encode_base128_int(input_len)]
             out_lines.extend(new_lines)
             index_lines = [False, False]
             index_lines.extend([True] * len(new_lines))
         else:
             # this is a worthy delta, output it
             type = 'delta'
-            out_lines[0] = 'd'
+            out_lines[0] = b'd'
             # Update the delta_length to include those two encoded integers
             out_lines[1] = encode_base128_int(delta_length)
         # Before insertion
@@ -1014,12 +1015,12 @@
             enc_length = encode_base128_int(len(bytes))
             len_mini_header = 1 + len(enc_length)
             self._delta_index.add_source(bytes, len_mini_header)
-            new_chunks = ['f', enc_length, bytes]
+            new_chunks = [b'f', enc_length, bytes]
         else:
             type = 'delta'
             enc_length = encode_base128_int(len(delta))
             len_mini_header = 1 + len(enc_length)
-            new_chunks = ['d', enc_length, delta]
+            new_chunks = [b'd', enc_length, delta]
             self._delta_index.add_delta_source(delta, len_mini_header)
         # Before insertion
         start = self.endpoint
@@ -1715,13 +1716,13 @@
             #       the fulltext content at this point. Note that sometimes we
             #       will want it later (streaming CHK pages), but most of the
             #       time we won't (everything else)
-            bytes = ''.join(chunks)
+            data = b''.join(chunks)
             del chunks
             index, start, length = self._access.add_raw_records(
-                [(None, len(bytes))], bytes)[0]
+                [(None, len(data))], data)[0]
             nodes = []
             for key, reads, refs in keys_to_add:
-                nodes.append((key, "%d %d %s" % (start, length, reads), refs))
+                nodes.append((key, b"%d %d %s" % (start, length, reads), refs))
             self._index.add_records(nodes, random_id=random_id)
             self._unadded_refs = {}
             del keys_to_add[:]
@@ -1777,7 +1778,7 @@
                             ' the current record, we cannot be positive'
                             ' that the appropriate content was inserted.'
                             )
-                    value = "%d %d %d %d" % (block_start, block_length,
+                    value = b"%d %d %d %d" % (block_start, block_length,
                                              record._start, record._end)
                     nodes = [(record.key, value, (record.parents,))]
                     # TODO: Consider buffering up many nodes to be added, not
@@ -1827,7 +1828,7 @@
                  type) = self._compressor.compress(record.key, bytes,
                                                    record.sha1)
             if record.key[-1] is None:
-                key = record.key[:-1] + ('sha1:' + found_sha1,)
+                key = record.key[:-1] + (b'sha1:' + found_sha1,)
             else:
                 key = record.key
             self._unadded_refs[key] = record.parents
@@ -1838,7 +1839,8 @@
             else:
                 parents = None
             refs = static_tuple.StaticTuple(parents)
-            keys_to_add.append((key, '%d %d' % (start_point, end_point), refs))
+            keys_to_add.append(
+                (key, b'%d %d' % (start_point, end_point), refs))
         if len(keys_to_add):
             flush()
         self._compressor = None
 
=== modified file 'breezy/index.py'
--- breezy/index.py	2017-06-10 01:57:00 +0000
+++ breezy/index.py	2017-06-11 01:47:17 +0000
@@ -56,8 +56,8 @@
 _SIGNATURE = b"Bazaar Graph Index 1\n"
 
 
-_whitespace_re = re.compile('[\t\n\x0b\x0c\r\x00 ]')
-_newline_null_re = re.compile('[\n\0]')
+_whitespace_re = re.compile(b'[\t\n\x0b\x0c\r\x00 ]')
+_newline_null_re = re.compile(b'[\n\0]')
 
 
 def _has_key_from_parent_map(self, key):
 
=== modified file 'breezy/inventory.py'
--- breezy/inventory.py	2017-06-10 01:57:00 +0000
+++ breezy/inventory.py	2017-06-11 01:47:17 +0000
@@ -49,6 +49,8 @@
     trace,
     )
 from .sixish import (
+    bytesintern,
+    PY3,
     viewitems,
     viewvalues,
     )
@@ -217,7 +219,7 @@
         Traceback (most recent call last):
         InvalidEntryName: Invalid entry name: src/hello.c
         """
-        if '/' in name or '\\' in name:
+        if u'/' in name or u'\\' in name:
             raise errors.InvalidEntryName(name=name)
         self.file_id = file_id
         self.revision = None
@@ -388,8 +390,8 @@
         # to provide a per-fileid log. The hash of every directory content is
         # "da..." below (the sha1sum of '').
         checker.add_pending_item(rev_id,
-            ('texts', self.file_id, self.revision), 'text',
-             'da39a3ee5e6b4b0d3255bfef95601890afd80709')
+            (b'texts', self.file_id, self.revision), b'text',
+             b'da39a3ee5e6b4b0d3255bfef95601890afd80709')
 
     def copy(self):
         other = InventoryDirectory(self.file_id, self.name, self.parent_id)
@@ -428,7 +430,7 @@
         """See InventoryEntry._check"""
         # TODO: check size too.
         checker.add_pending_item(tree_revision_id,
-            ('texts', self.file_id, self.revision), 'text',
+            (b'texts', self.file_id, self.revision), b'text',
              self.text_sha1)
         if self.text_size is None:
             checker._report_items.append(
@@ -528,8 +530,8 @@
                     % (self.file_id, tree_revision_id))
         # Symlinks are stored as ''
         checker.add_pending_item(tree_revision_id,
-            ('texts', self.file_id, self.revision), 'text',
-             'da39a3ee5e6b4b0d3255bfef95601890afd80709')
+            (b'texts', self.file_id, self.revision), b'text',
+             b'da39a3ee5e6b4b0d3255bfef95601890afd80709')
 
     def copy(self):
         other = InventoryLink(self.file_id, self.name, self.parent_id)
@@ -1398,25 +1400,25 @@
         if entry.parent_id is not None:
             parent_str = entry.parent_id
         else:
-            parent_str = ''
+            parent_str = b''
         name_str = entry.name.encode("utf8")
         if entry.kind == 'file':
             if entry.executable:
-                exec_str = "Y"
+                exec_str = b"Y"
             else:
-                exec_str = "N"
-            return "file: %s\n%s\n%s\n%s\n%s\n%d\n%s" % (
+                exec_str = b"N"
+            return b"file: %s\n%s\n%s\n%s\n%s\n%d\n%s" % (
                 entry.file_id, parent_str, name_str, entry.revision,
                 entry.text_sha1, entry.text_size, exec_str)
         elif entry.kind == 'directory':
-            return "dir: %s\n%s\n%s\n%s" % (
+            return b"dir: %s\n%s\n%s\n%s" % (
                 entry.file_id, parent_str, name_str, entry.revision)
         elif entry.kind == 'symlink':
-            return "symlink: %s\n%s\n%s\n%s\n%s" % (
+            return b"symlink: %s\n%s\n%s\n%s\n%s" % (
                 entry.file_id, parent_str, name_str, entry.revision,
                 entry.symlink_target.encode("utf8"))
         elif entry.kind == 'tree-reference':
-            return "tree: %s\n%s\n%s\n%s\n%s" % (
+            return b"tree: %s\n%s\n%s\n%s\n%s" % (
                 entry.file_id, parent_str, name_str, entry.revision,
                 entry.reference_revision)
         else:
@@ -1534,43 +1536,43 @@
         return other
 
     @staticmethod
-    def _bytes_to_utf8name_key(bytes):
-        """Get the file_id, revision_id key out of bytes."""
+    def _bytes_to_utf8name_key(data):
+        """Get the file_id, revision_id key out of data."""
         # We don't normally care about name, except for times when we want
         # to filter out empty names because of non rich-root...
-        sections = bytes.split('\n')
-        kind, file_id = sections[0].split(': ')
-        return (sections[2], intern(file_id), intern(sections[3]))
+        sections = data.split(b'\n')
+        kind, file_id = sections[0].split(b': ')
+        return (sections[2], bytesintern(file_id), bytesintern(sections[3]))
 
     def _bytes_to_entry(self, bytes):
         """Deserialise a serialised entry."""
-        sections = bytes.split('\n')
-        if sections[0].startswith("file: "):
+        sections = bytes.split(b'\n')
+        if sections[0].startswith(b"file: "):
             result = InventoryFile(sections[0][6:],
                 sections[2].decode('utf8'),
                 sections[1])
             result.text_sha1 = sections[4]
             result.text_size = int(sections[5])
-            result.executable = sections[6] == "Y"
-        elif sections[0].startswith("dir: "):
+            result.executable = sections[6] == b"Y"
+        elif sections[0].startswith(b"dir: "):
             result = CHKInventoryDirectory(sections[0][5:],
                 sections[2].decode('utf8'),
                 sections[1], self)
-        elif sections[0].startswith("symlink: "):
+        elif sections[0].startswith(b"symlink: "):
             result = InventoryLink(sections[0][9:],
                 sections[2].decode('utf8'),
                 sections[1])
             result.symlink_target = sections[4].decode('utf8')
-        elif sections[0].startswith("tree: "):
+        elif sections[0].startswith(b"tree: "):
             result = TreeReference(sections[0][6:],
                 sections[2].decode('utf8'),
                 sections[1])
             result.reference_revision = sections[4]
         else:
             raise ValueError("Not a serialised entry %r" % bytes)
-        result.file_id = intern(result.file_id)
-        result.revision = intern(sections[3])
-        if result.parent_id == '':
+        result.file_id = bytesintern(result.file_id)
+        result.revision = bytesintern(sections[3])
+        if result.parent_id == b'':
             result.parent_id = None
         self._fileid_to_entry_cache[result.file_id] = result
         return result
@@ -1754,18 +1756,18 @@
             for.
         :return: A CHKInventory
         """
-        lines = bytes.split('\n')
-        if lines[-1] != '':
+        lines = bytes.split(b'\n')
+        if lines[-1] != b'':
             raise AssertionError('bytes to deserialize must end with an eol')
         lines.pop()
-        if lines[0] != 'chkinventory:':
+        if lines[0] != b'chkinventory:':
             raise ValueError("not a serialised CHKInventory: %r" % bytes)
         info = {}
-        allowed_keys = frozenset(['root_id', 'revision_id', 'search_key_name',
-                                  'parent_id_basename_to_file_id',
-                                  'id_to_entry'])
+        allowed_keys = frozenset((b'root_id', b'revision_id',
+                                  b'parent_id_basename_to_file_id',
+                                  b'search_key_name', b'id_to_entry'))
         for line in lines[1:]:
-            key, value = line.split(': ', 1)
+            key, value = line.split(b': ', 1)
             if key not in allowed_keys:
                 raise errors.BzrError('Unknown key in inventory: %r\n%r'
                                       % (key, bytes))
@@ -1773,16 +1775,16 @@
                 raise errors.BzrError('Duplicate key in inventory: %r\n%r'
                                       % (key, bytes))
             info[key] = value
-        revision_id = intern(info['revision_id'])
-        root_id = intern(info['root_id'])
-        search_key_name = intern(info.get('search_key_name', 'plain'))
-        parent_id_basename_to_file_id = intern(info.get(
-            'parent_id_basename_to_file_id', None))
-        if not parent_id_basename_to_file_id.startswith('sha1:'):
+        revision_id = bytesintern(info[b'revision_id'])
+        root_id = bytesintern(info[b'root_id'])
+        search_key_name = bytesintern(info.get(b'search_key_name', b'plain'))
+        parent_id_basename_to_file_id = bytesintern(info.get(
+            b'parent_id_basename_to_file_id', None))
+        if not parent_id_basename_to_file_id.startswith(b'sha1:'):
             raise ValueError('parent_id_basename_to_file_id should be a sha1'
                              ' key not %r' % (parent_id_basename_to_file_id,))
-        id_to_entry = info['id_to_entry']
-        if not id_to_entry.startswith('sha1:'):
+        id_to_entry = info[b'id_to_entry']
+        if not id_to_entry.startswith(b'sha1:'):
             raise ValueError('id_to_entry should be a sha1'
                              ' key not %r' % (id_to_entry,))
 
@@ -1790,7 +1792,7 @@
         result.revision_id = revision_id
         result.root_id = root_id
         search_key_func = chk_map.search_key_registry.get(
-                            result._search_key_name)
+            result._search_key_name.decode("ascii"))
         if parent_id_basename_to_file_id is not None:
             result.parent_id_basename_to_file_id = chk_map.CHKMap(
                 chk_store, StaticTuple(parent_id_basename_to_file_id,),
@@ -1856,7 +1858,7 @@
         if entry.parent_id is not None:
             parent_id = entry.parent_id
         else:
-            parent_id = ''
+            parent_id = b''
         return StaticTuple(parent_id, entry.name.encode('utf8')).intern()
 
     def __getitem__(self, file_id):
@@ -1868,7 +1870,7 @@
             return result
         try:
             return self._bytes_to_entry(
-                self.id_to_entry.iteritems([StaticTuple(file_id,)]).next()[1])
+                next(self.id_to_entry.iteritems([StaticTuple(file_id,)]))[1])
         except StopIteration:
             # really we're passing an inventory, not a tree...
             raise errors.NoSuchId(self, file_id)
@@ -1951,7 +1953,7 @@
         last_parent_id = last_parent_ie = None
         pid_items = self.parent_id_basename_to_file_id.iteritems()
         for key, child_file_id in pid_items:
-            if key == ('', ''): # This is the root
+            if key == (b'', b''): # This is the root
                 if child_file_id != self.root_id:
                     raise ValueError('Data inconsistency detected.'
                         ' We expected data with key ("","") to match'
@@ -2129,22 +2131,23 @@
 
     def to_lines(self):
         """Serialise the inventory to lines."""
-        lines = ["chkinventory:\n"]
+        lines = [b"chkinventory:\n"]
         if self._search_key_name != 'plain':
             # custom ordering grouping things that don't change together
-            lines.append('search_key_name: %s\n' % (self._search_key_name,))
-            lines.append("root_id: %s\n" % self.root_id)
-            lines.append('parent_id_basename_to_file_id: %s\n' %
+            lines.append(b'search_key_name: %s\n' % (
+                self._search_key_name.encode('ascii')))
+            lines.append(b"root_id: %s\n" % self.root_id)
+            lines.append(b'parent_id_basename_to_file_id: %s\n' %
                 (self.parent_id_basename_to_file_id.key()[0],))
-            lines.append("revision_id: %s\n" % self.revision_id)
-            lines.append("id_to_entry: %s\n" % (self.id_to_entry.key()[0],))
+            lines.append(b"revision_id: %s\n" % self.revision_id)
+            lines.append(b"id_to_entry: %s\n" % (self.id_to_entry.key()[0],))
         else:
-            lines.append("revision_id: %s\n" % self.revision_id)
-            lines.append("root_id: %s\n" % self.root_id)
+            lines.append(b"revision_id: %s\n" % self.revision_id)
+            lines.append(b"root_id: %s\n" % self.root_id)
             if self.parent_id_basename_to_file_id is not None:
-                lines.append('parent_id_basename_to_file_id: %s\n' %
+                lines.append(b'parent_id_basename_to_file_id: %s\n' %
                     (self.parent_id_basename_to_file_id.key()[0],))
-            lines.append("id_to_entry: %s\n" % (self.id_to_entry.key()[0],))
+            lines.append(b"id_to_entry: %s\n" % (self.id_to_entry.key()[0],))
         return lines
 
     @property
 
=== modified file 'breezy/inventory_delta.py'
--- breezy/inventory_delta.py	2017-06-09 16:31:49 +0000
+++ breezy/inventory_delta.py	2017-06-11 01:47:17 +0000
@@ -31,7 +31,7 @@
 from . import inventory
 from .revision import NULL_REVISION
 
-FORMAT_1 = 'bzr inventory delta v1 (bzr 1.14)'
+FORMAT_1 = b'bzr inventory delta v1 (bzr 1.14)'
 
 
 class InventoryDeltaError(errors.BzrError):
@@ -61,7 +61,7 @@
     
     :param entry: An InventoryDirectory.
     """
-    return "dir"
+    return b"dir"
 
 
 def _file_content(entry):
@@ -70,14 +70,14 @@
     :param entry: An InventoryFile.
     """
     if entry.executable:
-        exec_bytes = 'Y'
+        exec_bytes = b'Y'
     else:
-        exec_bytes = ''
-    size_exec_sha = (entry.text_size, exec_bytes, entry.text_sha1)
+        exec_bytes = b''
+    size_exec_sha = entry.text_size, exec_bytes, entry.text_sha1
     if None in size_exec_sha:
         raise InventoryDeltaError(
             'Missing size or sha for %(fileid)r', fileid=entry.file_id)
-    return "file\x00%d\x00%s\x00%s" % size_exec_sha
+    return b"file\x00%d\x00%s\x00%s" % size_exec_sha
 
 
 def _link_content(entry):
@@ -89,7 +89,7 @@
     if target is None:
         raise InventoryDeltaError(
             'Missing target for %(fileid)r', fileid=entry.file_id)
-    return "link\x00%s" % target.encode('utf8')
+    return b"link\x00%s" % target.encode('utf8')
 
 
 def _reference_content(entry):
@@ -101,7 +101,7 @@
     if tree_revision is None:
         raise InventoryDeltaError(
             'Missing reference revision for %(fileid)r', fileid=entry.file_id)
-    return "tree\x00%s" % tree_revision
+    return b"tree\x00%s" % tree_revision
 
 
 def _dir_to_entry(content, name, parent_id, file_id, last_modified,
@@ -179,11 +179,11 @@
             takes.
         :return: The serialized delta as lines.
         """
-        if not isinstance(old_name, str):
+        if not isinstance(old_name, bytes):
             raise TypeError('old_name should be str, got %r' % (old_name,))
-        if not isinstance(new_name, str):
+        if not isinstance(new_name, bytes):
             raise TypeError('new_name should be str, got %r' % (new_name,))
-        lines = ['', '', '', '', '']
+        lines = [b'', b'', b'', b'', b'']
         to_line = self._delta_item_to_line
         for delta_item in delta_to_new:
             line = to_line(delta_item, new_name)
@@ -193,48 +193,48 @@
                     'to_line gave non-bytes output %(line)r', line=lines[-1])
             lines.append(line)
         lines.sort()
-        lines[0] = "format: %s\n" % FORMAT_1
-        lines[1] = "parent: %s\n" % old_name
-        lines[2] = "version: %s\n" % new_name
-        lines[3] = "versioned_root: %s\n" % self._serialize_bool(
+        lines[0] = b"format: %s\n" % FORMAT_1
+        lines[1] = b"parent: %s\n" % old_name
+        lines[2] = b"version: %s\n" % new_name
+        lines[3] = b"versioned_root: %s\n" % self._serialize_bool(
             self._versioned_root)
-        lines[4] = "tree_references: %s\n" % self._serialize_bool(
+        lines[4] = b"tree_references: %s\n" % self._serialize_bool(
             self._tree_references)
         return lines
 
     def _serialize_bool(self, value):
         if value:
-            return "true"
+            return b"true"
         else:
-            return "false"
+            return b"false"
 
     def _delta_item_to_line(self, delta_item, new_version):
         """Convert delta_item to a line."""
         oldpath, newpath, file_id, entry = delta_item
         if newpath is None:
             # delete
-            oldpath_utf8 = '/' + oldpath.encode('utf8')
-            newpath_utf8 = 'None'
-            parent_id = ''
+            oldpath_utf8 = b'/' + oldpath.encode('utf8')
+            newpath_utf8 = b'None'
+            parent_id = b''
             last_modified = NULL_REVISION
-            content = 'deleted\x00\x00'
+            content = b'deleted\x00\x00'
         else:
             if oldpath is None:
-                oldpath_utf8 = 'None'
+                oldpath_utf8 = b'None'
             else:
-                oldpath_utf8 = '/' + oldpath.encode('utf8')
+                oldpath_utf8 = b'/' + oldpath.encode('utf8')
             if newpath == '/':
                 raise AssertionError(
                     "Bad inventory delta: '/' is not a valid newpath "
                     "(should be '') in delta item %r" % (delta_item,))
             # TODO: Test real-world utf8 cache hit rate. It may be a win.
-            newpath_utf8 = '/' + newpath.encode('utf8')
+            newpath_utf8 = b'/' + newpath.encode('utf8')
             # Serialize None as ''
-            parent_id = entry.parent_id or ''
+            parent_id = entry.parent_id or b''
             # Serialize unknown revisions as NULL_REVISION
             last_modified = entry.revision
             # special cases for /
-            if newpath_utf8 == '/' and not self._versioned_root:
+            if newpath_utf8 == b'/' and not self._versioned_root:
                 # This is an entry for the root, this inventory does not
                 # support versioned roots.  So this must be an unversioned
                 # root, i.e. last_modified == new revision.  Otherwise, this
@@ -251,7 +251,7 @@
                 raise InventoryDeltaError(
                     "no version for fileid %(fileid)r", fileid=file_id)
             content = self._entry_to_content[entry.kind](entry)
-        return ("%s\x00%s\x00%s\x00%s\x00%s\x00%s\n" %
+        return (b"%s\x00%s\x00%s\x00%s\x00%s\x00%s\n" %
             (oldpath_utf8, newpath_utf8, file_id, parent_id, last_modified,
                 content))
 
@@ -270,9 +270,9 @@
         self._allow_tree_references = allow_tree_references
 
     def _deserialize_bool(self, value):
-        if value == "true":
+        if value == b"true":
             return True
-        elif value == "false":
+        elif value == b"false":
             return False
         else:
             raise InventoryDeltaError("value %(val)r is not a bool", val=value)
@@ -289,24 +289,24 @@
         :return: (parent_id, new_id, versioned_root, tree_references,
             inventory_delta)
         """
-        if bytes[-1:] != '\n':
-            last_line = bytes.rsplit('\n', 1)[-1]
+        if bytes[-1:] != b'\n':
+            last_line = bytes.rsplit(b'\n', 1)[-1]
             raise InventoryDeltaError(
                 'last line not empty: %(line)r', line=last_line)
-        lines = bytes.split('\n')[:-1] # discard the last empty line
-        if not lines or lines[0] != 'format: %s' % FORMAT_1:
+        lines = bytes.split(b'\n')[:-1] # discard the last empty line
+        if not lines or lines[0] != b'format: %s' % FORMAT_1:
             raise InventoryDeltaError(
                 'unknown format %(line)r', line=lines[0:1])
-        if len(lines) < 2 or not lines[1].startswith('parent: '):
+        if len(lines) < 2 or not lines[1].startswith(b'parent: '):
             raise InventoryDeltaError('missing parent: marker')
         delta_parent_id = lines[1][8:]
-        if len(lines) < 3 or not lines[2].startswith('version: '):
+        if len(lines) < 3 or not lines[2].startswith(b'version: '):
             raise InventoryDeltaError('missing version: marker')
         delta_version_id = lines[2][9:]
-        if len(lines) < 4 or not lines[3].startswith('versioned_root: '):
+        if len(lines) < 4 or not lines[3].startswith(b'versioned_root: '):
             raise InventoryDeltaError('missing versioned_root: marker')
         delta_versioned_root = self._deserialize_bool(lines[3][16:])
-        if len(lines) < 5 or not lines[4].startswith('tree_references: '):
+        if len(lines) < 5 or not lines[4].startswith(b'tree_references: '):
             raise InventoryDeltaError('missing tree_references: marker')
         delta_tree_references = self._deserialize_bool(lines[4][17:])
         if (not self._allow_versioned_root and delta_versioned_root):
@@ -318,24 +318,24 @@
             next(line_iter)
         for line in line_iter:
             (oldpath_utf8, newpath_utf8, file_id, parent_id, last_modified,
-                content) = line.split('\x00', 5)
+                content) = line.split(b'\x00', 5)
             parent_id = parent_id or None
             if file_id in seen_ids:
                 raise InventoryDeltaError(
                     "duplicate file id %(fileid)r", fileid=file_id)
             seen_ids.add(file_id)
-            if (newpath_utf8 == '/' and not delta_versioned_root and
+            if (newpath_utf8 == b'/' and not delta_versioned_root and
                 last_modified != delta_version_id):
                     # Delta claims to be not have a versioned root, yet here's
                     # a root entry with a non-default version.
                     raise InventoryDeltaError(
                         "Versioned root found: %(line)r", line=line)
-            elif newpath_utf8 != 'None' and last_modified[-1] == ':':
+            elif newpath_utf8 != b'None' and last_modified[-1:] == b':':
                 # Deletes have a last_modified of null:, but otherwise special
                 # revision ids should not occur.
                 raise InventoryDeltaError(
                     'special revisionid found: %(line)r', line=line)
-            if content.startswith('tree\x00'):
+            if content.startswith(b'tree\x00'):
                 if delta_tree_references is False:
                     raise InventoryDeltaError(
                             "Tree reference found (but header said "
@@ -343,18 +343,18 @@
                 elif not self._allow_tree_references:
                     raise IncompatibleInventoryDelta(
                         "Tree reference not allowed")
-            if oldpath_utf8 == 'None':
+            if oldpath_utf8 == b'None':
                 oldpath = None
-            elif oldpath_utf8[:1] != '/':
+            elif oldpath_utf8[:1] != b'/':
                 raise InventoryDeltaError(
                     "oldpath invalid (does not start with /): %(path)r",
                     path=oldpath_utf8)
             else:
                 oldpath_utf8 = oldpath_utf8[1:]
                 oldpath = oldpath_utf8.decode('utf8')
-            if newpath_utf8 == 'None':
+            if newpath_utf8 == b'None':
                 newpath = None
-            elif newpath_utf8[:1] != '/':
+            elif newpath_utf8[:1] != b'/':
                 raise InventoryDeltaError(
                     "newpath invalid (does not start with /): %(path)r",
                     path=newpath_utf8)
@@ -362,8 +362,8 @@
                 # Trim leading slash
                 newpath_utf8 = newpath_utf8[1:]
                 newpath = newpath_utf8.decode('utf8')
-            content_tuple = tuple(content.split('\x00'))
-            if content_tuple[0] == 'deleted':
+            content_tuple = tuple(content.split(b'\x00'))
+            if content_tuple[0] == b'deleted':
                 entry = None
             else:
                 entry = _parse_entry(
@@ -376,10 +376,10 @@
 
 def _parse_entry(path, file_id, parent_id, last_modified, content):
     entry_factory = {
-        'dir': _dir_to_entry,
-        'file': _file_to_entry,
-        'link': _link_to_entry,
-        'tree': _tree_to_entry,
+        b'dir': _dir_to_entry,
+        b'file': _file_to_entry,
+        b'link': _link_to_entry,
+        b'tree': _tree_to_entry,
     }
     kind = content[0]
     if path.startswith('/'):
 
=== modified file 'breezy/osutils.py'
--- breezy/osutils.py	2017-06-10 01:57:00 +0000
+++ breezy/osutils.py	2017-06-11 01:47:17 +0000
@@ -1209,11 +1209,11 @@
     #    separators
     # 3) '\xa0' isn't unicode safe since it is >128.
 
-    # This should *not* be a unicode set of characters in case the source
-    # string is not a Unicode string. We can auto-up-cast the characters since
-    # they are ascii, but we don't want to auto-up-cast the string in case it
-    # is utf-8
-    for ch in ' \t\n\r\v\f':
+    if isinstance(s, str):
+        ws = ' \t\n\r\v\f'
+    else:
+        ws = (b' ', b'\t', b'\n', b'\r', b'\v', b'\f')
+    for ch in ws:
         if ch in s:
             return True
     else:
@@ -1370,7 +1370,7 @@
     If it is a str, it is returned.
     If it is Unicode, it is encoded into a utf-8 string.
     """
-    if isinstance(unicode_or_utf8_string, str):
+    if isinstance(unicode_or_utf8_string, bytes):
         # TODO: jam 20070209 This is overkill, and probably has an impact on
         #       performance if we are dealing with lots of apis that want a
         #       utf-8 revision id
@@ -1443,13 +1443,13 @@
     can be accessed by that path.
     """
 
-    return unicodedata.normalize('NFC', unicode(path)), True
+    return unicodedata.normalize('NFC', text_type(path)), True
 
 
 def _inaccessible_normalized_filename(path):
     __doc__ = _accessible_normalized_filename.__doc__
 
-    normalized = unicodedata.normalize('NFC', unicode(path))
+    normalized = unicodedata.normalize('NFC', text_type(path))
     return normalized, normalized == path
 
 
@@ -1878,10 +1878,10 @@
         _kind_from_mode = file_kind_from_stat_mode
 
         if prefix:
-            relprefix = prefix + '/'
+            relprefix = prefix + b'/'
         else:
-            relprefix = ''
-        top_slash = top + u'/'
+            relprefix = b''
+        top_slash = top + '/'
 
         dirblock = []
         append = dirblock.append
 
=== modified file 'breezy/pack.py'
--- breezy/pack.py	2017-05-25 01:35:55 +0000
+++ breezy/pack.py	2017-06-11 01:47:17 +0000
@@ -73,28 +73,28 @@
 
     def begin(self):
         """Return the bytes to begin a container."""
-        return FORMAT_ONE + "\n"
+        return FORMAT_ONE.encode("ascii") + b"\n"
 
     def end(self):
         """Return the bytes to finish a container."""
-        return "E"
+        return b"E"
 
     def bytes_header(self, length, names):
         """Return the header for a Bytes record."""
         # Kind marker
-        byte_sections = ["B"]
+        byte_sections = [b"B"]
         # Length
-        byte_sections.append(str(length) + "\n")
+        byte_sections.append(b"%d\n" % (length,))
         # Names
         for name_tuple in names:
             # Make sure we're writing valid names.  Note that we will leave a
             # half-written record if a name is bad!
             for name in name_tuple:
                 _check_name(name)
-            byte_sections.append('\x00'.join(name_tuple) + "\n")
+            byte_sections.append(b'\x00'.join(name_tuple) + b"\n")
         # End of headers
-        byte_sections.append("\n")
-        return ''.join(byte_sections)
+        byte_sections.append(b"\n")
+        return b''.join(byte_sections)
 
     def bytes_record(self, bytes, names):
         """Return the bytes for a Bytes record with the given name and
 
=== modified file 'breezy/repofmt/groupcompress_repo.py'
--- breezy/repofmt/groupcompress_repo.py	2017-06-10 00:52:37 +0000
+++ breezy/repofmt/groupcompress_repo.py	2017-06-11 01:47:17 +0000
@@ -147,15 +147,15 @@
         # robertc says- this is a closure rather than a method on the object
         # so that the variables are locals, and faster than accessing object
         # members.
-        def _write_data(bytes, flush=False, _buffer=self._buffer,
+        def _write_data(data, flush=False, _buffer=self._buffer,
             _write=self.write_stream.write, _update=self._hash.update):
-            _buffer[0].append(bytes)
-            _buffer[1] += len(bytes)
+            _buffer[0].append(data)
+            _buffer[1] += len(data)
             # buffer cap
             if _buffer[1] > self._cache_limit or flush:
-                bytes = ''.join(_buffer[0])
-                _write(bytes)
-                _update(bytes)
+                data = b''.join(_buffer[0])
+                _write(data)
+                _update(data)
                 _buffer[:] = [[], 0]
         # expose this on self, for the occasion when clients want to add data.
         self._write_data = _write_data
@@ -905,7 +905,7 @@
                                  ' no new_path %r' % (file_id,))
             if new_path == '':
                 new_inv.root_id = file_id
-                parent_id_basename_key = StaticTuple('', '').intern()
+                parent_id_basename_key = StaticTuple(b'', b'').intern()
             else:
                 utf8_entry_name = entry.name.encode('utf-8')
                 parent_id_basename_key = StaticTuple(entry.parent_id,
 
=== modified file 'breezy/repofmt/pack_repo.py'
--- breezy/repofmt/pack_repo.py	2017-06-10 12:56:18 +0000
+++ breezy/repofmt/pack_repo.py	2017-06-11 01:47:17 +0000
@@ -419,7 +419,7 @@
             _buffer[1] += len(bytes)
             # buffer cap
             if _buffer[1] > self._cache_limit or flush:
-                bytes = ''.join(_buffer[0])
+                bytes = b''.join(_buffer[0])
                 _write(bytes)
                 _update(bytes)
                 _buffer[:] = [[], 0]
@@ -524,7 +524,7 @@
     def flush(self):
         """Flush any current data."""
         if self._buffer[1]:
-            bytes = ''.join(self._buffer[0])
+            bytes = b''.join(self._buffer[0])
             self.write_stream.write(bytes)
             self._hash.update(bytes)
             self._buffer[:] = [[], 0]
@@ -1987,7 +1987,7 @@
             length), where the index field is the write_index object supplied
             to the PackAccess object.
         """
-        if not isinstance(raw_data, str):
+        if not isinstance(raw_data, bytes):
             raise AssertionError(
                 'data must be plain bytes was %s' % type(raw_data))
         result = []
 
=== modified file 'breezy/repository.py'
--- breezy/repository.py	2017-06-10 00:52:37 +0000
+++ breezy/repository.py	2017-06-11 01:47:17 +0000
@@ -46,6 +46,7 @@
 from .inter import InterObject
 from .lock import _RelockDebugMixin, LogicalLockResult
 from .sixish import (
+    text_type,
     viewitems,
     viewvalues,
     )
@@ -145,7 +146,7 @@
         for key, value in viewitems(revprops):
             # We know that the XML serializers do not round trip '\r'
             # correctly, so refuse to accept them
-            if not isinstance(value, basestring):
+            if not isinstance(value, (text_type, str)):
                 raise ValueError('revision property (%s) is not a valid'
                                  ' (unicode) string: %r' % (key, value))
             self._validate_unicode_text(value,
 
=== modified file 'breezy/revision.py'
--- breezy/revision.py	2017-06-10 01:57:00 +0000
+++ breezy/revision.py	2017-06-11 01:47:17 +0000
@@ -26,8 +26,11 @@
 """)
 from . import (
     errors,
-    )
-from .osutils import contains_whitespace
+    osutils,
+    )
+from .sixish import (
+    text_type,
+    )
 
 NULL_REVISION=b"null:"
 CURRENT_REVISION=b"current:"
@@ -86,9 +89,11 @@
     def _check_properties(self):
         """Verify that all revision properties are OK."""
         for name, value in self.properties.items():
-            if not isinstance(name, basestring) or contains_whitespace(name):
+            # GZ 2017-06-10: What sort of string are properties exactly?
+            not_text = not isinstance(name, (text_type, str))
+            if not_text or osutils.contains_whitespace(name):
                 raise ValueError("invalid property name %r" % name)
-            if not isinstance(value, basestring):
+            if not isinstance(value, (text_type, bytes)):
                 raise ValueError("invalid property value %r for %r" %
                                  (value, name))
 
@@ -205,7 +210,7 @@
 
     :return: True if the revision is reserved, False otherwise
     """
-    return isinstance(revision_id, basestring) and revision_id.endswith(':')
+    return isinstance(revision_id, bytes) and revision_id.endswith(b':')
 
 
 def check_not_reserved_id(revision_id):
 
=== modified file 'breezy/sixish.py'
--- breezy/sixish.py	2017-06-05 01:55:02 +0000
+++ breezy/sixish.py	2017-06-11 01:47:17 +0000
@@ -46,3 +46,13 @@
     from StringIO import StringIO
     from future_builtins import zip, map
     range = xrange
+
+
+# GZ 2017-06-10: Work out if interning bits of inventory is behaviour we want
+# to retain outside of StaticTuple, if so need to implement for Python 3.
+if PY3:
+    def bytesintern(b):
+        """Dummy intern() function."""
+        return b
+else:
+    bytesintern = intern
 
=== modified file 'breezy/tests/test__chk_map.py'
--- breezy/tests/test__chk_map.py	2017-05-23 14:08:03 +0000
+++ breezy/tests/test__chk_map.py	2017-06-11 01:47:17 +0000
@@ -42,18 +42,18 @@
         self.assertEqual(expected, actual, 'actual: %r' % (actual,))
 
     def test_simple_16(self):
-        self.assertSearchKey16('8C736521', stuple('foo',))
-        self.assertSearchKey16('8C736521\x008C736521', stuple('foo', 'foo'))
-        self.assertSearchKey16('8C736521\x0076FF8CAA', stuple('foo', 'bar'))
-        self.assertSearchKey16('ED82CD11', stuple('abcd',))
+        self.assertSearchKey16(b'8C736521', stuple('foo',))
+        self.assertSearchKey16(b'8C736521\x008C736521', stuple('foo', 'foo'))
+        self.assertSearchKey16(b'8C736521\x0076FF8CAA', stuple('foo', 'bar'))
+        self.assertSearchKey16(b'ED82CD11', stuple('abcd',))
 
     def test_simple_255(self):
-        self.assertSearchKey255('\x8cse!', stuple('foo',))
-        self.assertSearchKey255('\x8cse!\x00\x8cse!', stuple('foo', 'foo'))
-        self.assertSearchKey255('\x8cse!\x00v\xff\x8c\xaa', stuple('foo', 'bar'))
+        self.assertSearchKey255(b'\x8cse!', stuple('foo',))
+        self.assertSearchKey255(b'\x8cse!\x00\x8cse!', stuple('foo', 'foo'))
+        self.assertSearchKey255(b'\x8cse!\x00v\xff\x8c\xaa', stuple('foo', 'bar'))
         # The standard mapping for these would include '\n', so it should be
         # mapped to '_'
-        self.assertSearchKey255('\xfdm\x93_\x00P_\x1bL', stuple('<', 'V'))
+        self.assertSearchKey255(b'\xfdm\x93_\x00P_\x1bL', stuple('<', 'V'))
 
     def test_255_does_not_include_newline(self):
         # When mapping via _search_key_255, we should never have the '\n'
@@ -64,7 +64,7 @@
             chars_used.update(search_key)
         all_chars = {chr(x) for x in range(256)}
         unused_chars = all_chars.symmetric_difference(chars_used)
-        self.assertEqual(set('\n'), unused_chars)
+        self.assertEqual(set(b'\n'), unused_chars)
 
 
 class TestDeserialiseLeafNode(tests.TestCase):
@@ -73,94 +73,94 @@
 
     def assertDeserialiseErrors(self, text):
         self.assertRaises((ValueError, IndexError),
-            self.module._deserialise_leaf_node, text, 'not-a-real-sha')
+            self.module._deserialise_leaf_node, text, b'not-a-real-sha')
 
     def test_raises_on_non_leaf(self):
-        self.assertDeserialiseErrors('')
-        self.assertDeserialiseErrors('short\n')
-        self.assertDeserialiseErrors('chknotleaf:\n')
-        self.assertDeserialiseErrors('chkleaf:x\n')
-        self.assertDeserialiseErrors('chkleaf:\n')
-        self.assertDeserialiseErrors('chkleaf:\nnotint\n')
-        self.assertDeserialiseErrors('chkleaf:\n10\n')
-        self.assertDeserialiseErrors('chkleaf:\n10\n256\n')
-        self.assertDeserialiseErrors('chkleaf:\n10\n256\n10\n')
+        self.assertDeserialiseErrors(b'')
+        self.assertDeserialiseErrors(b'short\n')
+        self.assertDeserialiseErrors(b'chknotleaf:\n')
+        self.assertDeserialiseErrors(b'chkleaf:x\n')
+        self.assertDeserialiseErrors(b'chkleaf:\n')
+        self.assertDeserialiseErrors(b'chkleaf:\nnotint\n')
+        self.assertDeserialiseErrors(b'chkleaf:\n10\n')
+        self.assertDeserialiseErrors(b'chkleaf:\n10\n256\n')
+        self.assertDeserialiseErrors(b'chkleaf:\n10\n256\n10\n')
 
     def test_deserialise_empty(self):
         node = self.module._deserialise_leaf_node(
-            "chkleaf:\n10\n1\n0\n\n", stuple("sha1:1234",))
+            b"chkleaf:\n10\n1\n0\n\n", stuple(b"sha1:1234",))
         self.assertEqual(0, len(node))
         self.assertEqual(10, node.maximum_size)
-        self.assertEqual(("sha1:1234",), node.key())
+        self.assertEqual((b"sha1:1234",), node.key())
         self.assertIsInstance(node.key(), StaticTuple)
         self.assertIs(None, node._search_prefix)
         self.assertIs(None, node._common_serialised_prefix)
 
     def test_deserialise_items(self):
         node = self.module._deserialise_leaf_node(
-            "chkleaf:\n0\n1\n2\n\nfoo bar\x001\nbaz\nquux\x001\nblarh\n",
-            ("sha1:1234",))
+            b"chkleaf:\n0\n1\n2\n\nfoo bar\x001\nbaz\nquux\x001\nblarh\n",
+            (b"sha1:1234",))
         self.assertEqual(2, len(node))
-        self.assertEqual([(("foo bar",), "baz"), (("quux",), "blarh")],
+        self.assertEqual([((b"foo bar",), b"baz"), ((b"quux",), b"blarh")],
             sorted(node.iteritems(None)))
 
     def test_deserialise_item_with_null_width_1(self):
         node = self.module._deserialise_leaf_node(
-            "chkleaf:\n0\n1\n2\n\nfoo\x001\nbar\x00baz\nquux\x001\nblarh\n",
-            ("sha1:1234",))
+            b"chkleaf:\n0\n1\n2\n\nfoo\x001\nbar\x00baz\nquux\x001\nblarh\n",
+            (b"sha1:1234",))
         self.assertEqual(2, len(node))
-        self.assertEqual([(("foo",), "bar\x00baz"), (("quux",), "blarh")],
+        self.assertEqual([((b"foo",), b"bar\x00baz"), ((b"quux",), b"blarh")],
             sorted(node.iteritems(None)))
 
     def test_deserialise_item_with_null_width_2(self):
         node = self.module._deserialise_leaf_node(
-            "chkleaf:\n0\n2\n2\n\nfoo\x001\x001\nbar\x00baz\n"
-            "quux\x00\x001\nblarh\n",
-            ("sha1:1234",))
+            b"chkleaf:\n0\n2\n2\n\nfoo\x001\x001\nbar\x00baz\n"
+            b"quux\x00\x001\nblarh\n",
+            (b"sha1:1234",))
         self.assertEqual(2, len(node))
-        self.assertEqual([(("foo", "1"), "bar\x00baz"), (("quux", ""), "blarh")],
+        self.assertEqual([((b"foo", "1"), b"bar\x00baz"), ((b"quux", ""), b"blarh")],
             sorted(node.iteritems(None)))
 
     def test_iteritems_selected_one_of_two_items(self):
         node = self.module._deserialise_leaf_node(
-            "chkleaf:\n0\n1\n2\n\nfoo bar\x001\nbaz\nquux\x001\nblarh\n",
-            ("sha1:1234",))
+            b"chkleaf:\n0\n1\n2\n\nfoo bar\x001\nbaz\nquux\x001\nblarh\n",
+            (b"sha1:1234",))
         self.assertEqual(2, len(node))
-        self.assertEqual([(("quux",), "blarh")],
-            sorted(node.iteritems(None, [("quux",), ("qaz",)])))
+        self.assertEqual([((b"quux",), b"blarh")],
+            sorted(node.iteritems(None, [(b"quux",), (b"qaz",)])))
 
     def test_deserialise_item_with_common_prefix(self):
         node = self.module._deserialise_leaf_node(
-            "chkleaf:\n0\n2\n2\nfoo\x00\n1\x001\nbar\x00baz\n2\x001\nblarh\n",
-            ("sha1:1234",))
+            b"chkleaf:\n0\n2\n2\nfoo\x00\n1\x001\nbar\x00baz\n2\x001\nblarh\n",
+            (b"sha1:1234",))
         self.assertEqual(2, len(node))
-        self.assertEqual([(("foo", "1"), "bar\x00baz"), (("foo", "2"), "blarh")],
+        self.assertEqual([((b"foo", b"1"), b"bar\x00baz"), ((b"foo", b"2"), b"blarh")],
             sorted(node.iteritems(None)))
         self.assertIs(chk_map._unknown, node._search_prefix)
-        self.assertEqual('foo\x00', node._common_serialised_prefix)
+        self.assertEqual(b'foo\x00', node._common_serialised_prefix)
 
     def test_deserialise_multi_line(self):
         node = self.module._deserialise_leaf_node(
-            "chkleaf:\n0\n2\n2\nfoo\x00\n1\x002\nbar\nbaz\n2\x002\nblarh\n\n",
-            ("sha1:1234",))
+            b"chkleaf:\n0\n2\n2\nfoo\x00\n1\x002\nbar\nbaz\n2\x002\nblarh\n\n",
+            (b"sha1:1234",))
         self.assertEqual(2, len(node))
-        self.assertEqual([(("foo", "1"), "bar\nbaz"),
-                          (("foo", "2"), "blarh\n"),
+        self.assertEqual([((b"foo", b"1"), b"bar\nbaz"),
+                          ((b"foo", b"2"), b"blarh\n"),
                          ], sorted(node.iteritems(None)))
         self.assertIs(chk_map._unknown, node._search_prefix)
-        self.assertEqual('foo\x00', node._common_serialised_prefix)
+        self.assertEqual(b'foo\x00', node._common_serialised_prefix)
 
     def test_key_after_map(self):
         node = self.module._deserialise_leaf_node(
-            "chkleaf:\n10\n1\n0\n\n", ("sha1:1234",))
-        node.map(None, ("foo bar",), "baz quux")
+            b"chkleaf:\n10\n1\n0\n\n", (b"sha1:1234",))
+        node.map(None, (b"foo bar",), b"baz quux")
         self.assertEqual(None, node.key())
 
     def test_key_after_unmap(self):
         node = self.module._deserialise_leaf_node(
-            "chkleaf:\n0\n1\n2\n\nfoo bar\x001\nbaz\nquux\x001\nblarh\n",
-            ("sha1:1234",))
-        node.unmap(None, ("foo bar",))
+            b"chkleaf:\n0\n1\n2\n\nfoo bar\x001\nbaz\nquux\x001\nblarh\n",
+            (b"sha1:1234",))
+        node.unmap(None, (b"foo bar",))
         self.assertEqual(None, node.key())
 
 
@@ -171,71 +171,73 @@
     def assertDeserialiseErrors(self, text):
         self.assertRaises((ValueError, IndexError),
             self.module._deserialise_internal_node, text,
-                stuple('not-a-real-sha',))
+                stuple(b'not-a-real-sha',))
 
     def test_raises_on_non_internal(self):
-        self.assertDeserialiseErrors('')
-        self.assertDeserialiseErrors('short\n')
-        self.assertDeserialiseErrors('chknotnode:\n')
-        self.assertDeserialiseErrors('chknode:x\n')
-        self.assertDeserialiseErrors('chknode:\n')
-        self.assertDeserialiseErrors('chknode:\nnotint\n')
-        self.assertDeserialiseErrors('chknode:\n10\n')
-        self.assertDeserialiseErrors('chknode:\n10\n256\n')
-        self.assertDeserialiseErrors('chknode:\n10\n256\n10\n')
+        self.assertDeserialiseErrors(b'')
+        self.assertDeserialiseErrors(b'short\n')
+        self.assertDeserialiseErrors(b'chknotnode:\n')
+        self.assertDeserialiseErrors(b'chknode:x\n')
+        self.assertDeserialiseErrors(b'chknode:\n')
+        self.assertDeserialiseErrors(b'chknode:\nnotint\n')
+        self.assertDeserialiseErrors(b'chknode:\n10\n')
+        self.assertDeserialiseErrors(b'chknode:\n10\n256\n')
+        self.assertDeserialiseErrors(b'chknode:\n10\n256\n10\n')
         # no trailing newline
-        self.assertDeserialiseErrors('chknode:\n10\n256\n0\n1\nfo')
+        self.assertDeserialiseErrors(b'chknode:\n10\n256\n0\n1\nfo')
 
     def test_deserialise_one(self):
         node = self.module._deserialise_internal_node(
-            "chknode:\n10\n1\n1\n\na\x00sha1:abcd\n", stuple('sha1:1234',))
+            b"chknode:\n10\n1\n1\n\na\x00sha1:abcd\n", stuple(b'sha1:1234',))
         self.assertIsInstance(node, chk_map.InternalNode)
         self.assertEqual(1, len(node))
         self.assertEqual(10, node.maximum_size)
-        self.assertEqual(("sha1:1234",), node.key())
-        self.assertEqual('', node._search_prefix)
-        self.assertEqual({'a': ('sha1:abcd',)}, node._items)
+        self.assertEqual((b"sha1:1234",), node.key())
+        self.assertEqual(b'', node._search_prefix)
+        self.assertEqual({b'a': (b'sha1:abcd',)}, node._items)
 
     def test_deserialise_with_prefix(self):
         node = self.module._deserialise_internal_node(
-            "chknode:\n10\n1\n1\npref\na\x00sha1:abcd\n", stuple('sha1:1234',))
+            b"chknode:\n10\n1\n1\npref\na\x00sha1:abcd\n",
+            stuple(b'sha1:1234',))
         self.assertIsInstance(node, chk_map.InternalNode)
         self.assertEqual(1, len(node))
         self.assertEqual(10, node.maximum_size)
-        self.assertEqual(("sha1:1234",), node.key())
-        self.assertEqual('pref', node._search_prefix)
-        self.assertEqual({'prefa': ('sha1:abcd',)}, node._items)
+        self.assertEqual((b"sha1:1234",), node.key())
+        self.assertEqual(b'pref', node._search_prefix)
+        self.assertEqual({b'prefa': (b'sha1:abcd',)}, node._items)
 
         node = self.module._deserialise_internal_node(
-            "chknode:\n10\n1\n1\npref\n\x00sha1:abcd\n", stuple('sha1:1234',))
+            b"chknode:\n10\n1\n1\npref\n\x00sha1:abcd\n",
+            stuple(b'sha1:1234',))
         self.assertIsInstance(node, chk_map.InternalNode)
         self.assertEqual(1, len(node))
         self.assertEqual(10, node.maximum_size)
-        self.assertEqual(("sha1:1234",), node.key())
-        self.assertEqual('pref', node._search_prefix)
-        self.assertEqual({'pref': ('sha1:abcd',)}, node._items)
+        self.assertEqual((b"sha1:1234",), node.key())
+        self.assertEqual(b'pref', node._search_prefix)
+        self.assertEqual({b'pref': (b'sha1:abcd',)}, node._items)
 
     def test_deserialise_pref_with_null(self):
         node = self.module._deserialise_internal_node(
-            "chknode:\n10\n1\n1\npref\x00fo\n\x00sha1:abcd\n",
-            stuple('sha1:1234',))
+            b"chknode:\n10\n1\n1\npref\x00fo\n\x00sha1:abcd\n",
+            stuple(b'sha1:1234',))
         self.assertIsInstance(node, chk_map.InternalNode)
         self.assertEqual(1, len(node))
         self.assertEqual(10, node.maximum_size)
-        self.assertEqual(("sha1:1234",), node.key())
-        self.assertEqual('pref\x00fo', node._search_prefix)
-        self.assertEqual({'pref\x00fo': ('sha1:abcd',)}, node._items)
+        self.assertEqual((b"sha1:1234",), node.key())
+        self.assertEqual(b'pref\x00fo', node._search_prefix)
+        self.assertEqual({b'pref\x00fo': (b'sha1:abcd',)}, node._items)
 
     def test_deserialise_with_null_pref(self):
         node = self.module._deserialise_internal_node(
-            "chknode:\n10\n1\n1\npref\x00fo\n\x00\x00sha1:abcd\n",
-            stuple('sha1:1234',))
+            b"chknode:\n10\n1\n1\npref\x00fo\n\x00\x00sha1:abcd\n",
+            stuple(b'sha1:1234',))
         self.assertIsInstance(node, chk_map.InternalNode)
         self.assertEqual(1, len(node))
         self.assertEqual(10, node.maximum_size)
-        self.assertEqual(("sha1:1234",), node.key())
-        self.assertEqual('pref\x00fo', node._search_prefix)
-        self.assertEqual({'pref\x00fo\x00': ('sha1:abcd',)}, node._items)
+        self.assertEqual((b"sha1:1234",), node.key())
+        self.assertEqual(b'pref\x00fo', node._search_prefix)
+        self.assertEqual({b'pref\x00fo\x00': (b'sha1:abcd',)}, node._items)
 
 
 class Test_BytesToTextKey(tests.TestCase):
@@ -251,29 +253,29 @@
         self.assertRaises(Exception, self.module._bytes_to_text_key, bytes)
 
     def test_file(self):
-        self.assertBytesToTextKey(('file-id', 'revision-id'),
-                 'file: file-id\nparent-id\nname\nrevision-id\n'
-                 'da39a3ee5e6b4b0d3255bfef95601890afd80709\n100\nN')
+        self.assertBytesToTextKey((b'file-id', b'revision-id'),
+                 b'file: file-id\nparent-id\nname\nrevision-id\n'
+                 b'da39a3ee5e6b4b0d3255bfef95601890afd80709\n100\nN')
 
     def test_invalid_no_kind(self):
         self.assertBytesToTextKeyRaises(
-                 'file  file-id\nparent-id\nname\nrevision-id\n'
-                 'da39a3ee5e6b4b0d3255bfef95601890afd80709\n100\nN')
+                 b'file  file-id\nparent-id\nname\nrevision-id\n'
+                 b'da39a3ee5e6b4b0d3255bfef95601890afd80709\n100\nN')
 
     def test_invalid_no_space(self):
         self.assertBytesToTextKeyRaises(
-                 'file:file-id\nparent-id\nname\nrevision-id\n'
-                 'da39a3ee5e6b4b0d3255bfef95601890afd80709\n100\nN')
+                 b'file:file-id\nparent-id\nname\nrevision-id\n'
+                 b'da39a3ee5e6b4b0d3255bfef95601890afd80709\n100\nN')
 
     def test_invalid_too_short_file_id(self):
-        self.assertBytesToTextKeyRaises('file:file-id')
+        self.assertBytesToTextKeyRaises(b'file:file-id')
 
     def test_invalid_too_short_parent_id(self):
-        self.assertBytesToTextKeyRaises('file:file-id\nparent-id')
+        self.assertBytesToTextKeyRaises(b'file:file-id\nparent-id')
 
     def test_invalid_too_short_name(self):
-        self.assertBytesToTextKeyRaises('file:file-id\nparent-id\nname')
+        self.assertBytesToTextKeyRaises(b'file:file-id\nparent-id\nname')
 
     def test_dir(self):
-        self.assertBytesToTextKey(('dir-id', 'revision-id'),
-                 'dir: dir-id\nparent-id\nname\nrevision-id')
+        self.assertBytesToTextKey((b'dir-id', b'revision-id'),
+                 b'dir: dir-id\nparent-id\nname\nrevision-id')
 
=== modified file 'breezy/tests/test__chunks_to_lines.py'
--- breezy/tests/test__chunks_to_lines.py	2017-05-23 14:08:03 +0000
+++ breezy/tests/test__chunks_to_lines.py	2017-06-11 01:47:17 +0000
@@ -47,58 +47,60 @@
             self.assertIs(chunks, result)
 
     def test_fulltext_chunk_to_lines(self):
-        self.assertChunksToLines(['foo\n', 'bar\r\n', 'ba\rz\n'],
-                                 ['foo\nbar\r\nba\rz\n'])
-        self.assertChunksToLines(['foobarbaz\n'], ['foobarbaz\n'],
-                                 alreadly_lines=True)
-        self.assertChunksToLines(['foo\n', 'bar\n', '\n', 'baz\n', '\n', '\n'],
-                                 ['foo\nbar\n\nbaz\n\n\n'])
-        self.assertChunksToLines(['foobarbaz'], ['foobarbaz'],
-                                 alreadly_lines=True)
-        self.assertChunksToLines(['foobarbaz'], ['foo', 'bar', 'baz'])
+        self.assertChunksToLines(
+            [b'foo\n', b'bar\r\n', b'ba\rz\n'],
+            [b'foo\nbar\r\nba\rz\n'])
+        self.assertChunksToLines(
+            [b'foobarbaz\n'], [b'foobarbaz\n'], alreadly_lines=True)
+        self.assertChunksToLines(
+            [b'foo\n', b'bar\n', b'\n', b'baz\n', b'\n', b'\n'],
+            [b'foo\nbar\n\nbaz\n\n\n'])
+        self.assertChunksToLines(
+            [b'foobarbaz'], [b'foobarbaz'], alreadly_lines=True)
+        self.assertChunksToLines([b'foobarbaz'], [b'foo', b'bar', b'baz'])
 
     def test_newlines(self):
-        self.assertChunksToLines(['\n'], ['\n'], alreadly_lines=True)
-        self.assertChunksToLines(['\n'], ['', '\n', ''])
-        self.assertChunksToLines(['\n'], ['\n', ''])
-        self.assertChunksToLines(['\n'], ['', '\n'])
-        self.assertChunksToLines(['\n', '\n', '\n'], ['\n\n\n'])
-        self.assertChunksToLines(['\n', '\n', '\n'], ['\n', '\n', '\n'],
+        self.assertChunksToLines([b'\n'], [b'\n'], alreadly_lines=True)
+        self.assertChunksToLines([b'\n'], [b'', b'\n', b''])
+        self.assertChunksToLines([b'\n'], [b'\n', b''])
+        self.assertChunksToLines([b'\n'], [b'', b'\n'])
+        self.assertChunksToLines([b'\n', b'\n', b'\n'], [b'\n\n\n'])
+        self.assertChunksToLines([b'\n', b'\n', b'\n'], [b'\n', b'\n', b'\n'],
                                  alreadly_lines=True)
 
     def test_lines_to_lines(self):
-        self.assertChunksToLines(['foo\n', 'bar\r\n', 'ba\rz\n'],
-                                 ['foo\n', 'bar\r\n', 'ba\rz\n'],
+        self.assertChunksToLines([b'foo\n', b'bar\r\n', b'ba\rz\n'],
+                                 [b'foo\n', b'bar\r\n', b'ba\rz\n'],
                                  alreadly_lines=True)
 
     def test_no_final_newline(self):
-        self.assertChunksToLines(['foo\n', 'bar\r\n', 'ba\rz'],
-                                 ['foo\nbar\r\nba\rz'])
-        self.assertChunksToLines(['foo\n', 'bar\r\n', 'ba\rz'],
-                                 ['foo\n', 'bar\r\n', 'ba\rz'],
+        self.assertChunksToLines([b'foo\n', b'bar\r\n', b'ba\rz'],
+                                 [b'foo\nbar\r\nba\rz'])
+        self.assertChunksToLines([b'foo\n', b'bar\r\n', b'ba\rz'],
+                                 [b'foo\n', b'bar\r\n', b'ba\rz'],
                                  alreadly_lines=True)
-        self.assertChunksToLines(('foo\n', 'bar\r\n', 'ba\rz'),
-                                 ('foo\n', 'bar\r\n', 'ba\rz'),
+        self.assertChunksToLines((b'foo\n', b'bar\r\n', b'ba\rz'),
+                                 (b'foo\n', b'bar\r\n', b'ba\rz'),
                                  alreadly_lines=True)
         self.assertChunksToLines([], [], alreadly_lines=True)
-        self.assertChunksToLines(['foobarbaz'], ['foobarbaz'],
+        self.assertChunksToLines([b'foobarbaz'], [b'foobarbaz'],
                                  alreadly_lines=True)
-        self.assertChunksToLines([], [''])
+        self.assertChunksToLines([], [b''])
 
     def test_mixed(self):
-        self.assertChunksToLines(['foo\n', 'bar\r\n', 'ba\rz'],
-                                 ['foo\n', 'bar\r\nba\r', 'z'])
-        self.assertChunksToLines(['foo\n', 'bar\r\n', 'ba\rz'],
-                                 ['foo\nb', 'a', 'r\r\nba\r', 'z'])
-        self.assertChunksToLines(['foo\n', 'bar\r\n', 'ba\rz'],
-                                 ['foo\nbar\r\nba', '\r', 'z'])
+        self.assertChunksToLines([b'foo\n', b'bar\r\n', b'ba\rz'],
+                                 [b'foo\n', b'bar\r\nba\r', b'z'])
+        self.assertChunksToLines([b'foo\n', b'bar\r\n', b'ba\rz'],
+                                 [b'foo\nb', b'a', b'r\r\nba\r', b'z'])
+        self.assertChunksToLines([b'foo\n', b'bar\r\n', b'ba\rz'],
+                                 [b'foo\nbar\r\nba', b'\r', b'z'])
 
-        self.assertChunksToLines(['foo\n', 'bar\r\n', 'ba\rz'],
-                                 ['foo\n', '', 'bar\r\nba', '\r', 'z'])
-        self.assertChunksToLines(['foo\n', 'bar\r\n', 'ba\rz\n'],
-                                 ['foo\n', 'bar\r\n', 'ba\rz\n', ''])
-        self.assertChunksToLines(['foo\n', 'bar\r\n', 'ba\rz\n'],
-                                 ['foo\n', 'bar', '\r\n', 'ba\rz\n'])
+        self.assertChunksToLines([b'foo\n', b'bar\r\n', b'ba\rz'],
+                                 [b'foo\n', b'', b'bar\r\nba', b'\r', b'z'])
+        self.assertChunksToLines([b'foo\n', b'bar\r\n', b'ba\rz\n'],
+                                 [b'foo\n', b'bar\r\n', b'ba\rz\n', b''])
+        self.assertChunksToLines([b'foo\n', b'bar\r\n', b'ba\rz\n'],
+                                 [b'foo\n', b'bar', b'\r\n', b'ba\rz\n'])
 
     def test_not_lines(self):
         # We should raise a TypeError, not crash
@@ -107,4 +109,4 @@
         self.assertRaises(TypeError, self.module.chunks_to_lines,
                           [object()])
         self.assertRaises(TypeError, self.module.chunks_to_lines,
-                          ['foo', object()])
+                          [b'foo', object()])
 
=== modified file 'breezy/tests/test_inv.py'
--- breezy/tests/test_inv.py	2017-06-10 00:52:37 +0000
+++ breezy/tests/test_inv.py	2017-06-11 01:47:17 +0000
@@ -284,35 +284,35 @@
 
     def test_creation_from_root_id(self):
         # iff a root id is passed to the constructor, a root directory is made
-        inv = inventory.Inventory(root_id='tree-root')
+        inv = inventory.Inventory(root_id=b'tree-root')
         self.assertNotEqual(None, inv.root)
-        self.assertEqual('tree-root', inv.root.file_id)
+        self.assertEqual(b'tree-root', inv.root.file_id)
 
     def test_add_path_of_root(self):
         # if no root id is given at creation time, there is no root directory
         inv = inventory.Inventory(root_id=None)
         self.assertIs(None, inv.root)
         # add a root entry by adding its path
-        ie = inv.add_path("", "directory", "my-root")
-        ie.revision = 'test-rev'
-        self.assertEqual("my-root", ie.file_id)
+        ie = inv.add_path(u"", "directory", b"my-root")
+        ie.revision = b'test-rev'
+        self.assertEqual(b"my-root", ie.file_id)
         self.assertIs(ie, inv.root)
 
     def test_add_path(self):
-        inv = inventory.Inventory(root_id='tree_root')
-        ie = inv.add_path('hello', 'file', 'hello-id')
-        self.assertEqual('hello-id', ie.file_id)
+        inv = inventory.Inventory(root_id=b'tree_root')
+        ie = inv.add_path(u'hello', 'file', b'hello-id')
+        self.assertEqual(b'hello-id', ie.file_id)
         self.assertEqual('file', ie.kind)
 
     def test_copy(self):
         """Make sure copy() works and creates a deep copy."""
-        inv = inventory.Inventory(root_id='some-tree-root')
-        ie = inv.add_path('hello', 'file', 'hello-id')
+        inv = inventory.Inventory(root_id=b'some-tree-root')
+        ie = inv.add_path(u'hello', 'file', b'hello-id')
         inv2 = inv.copy()
-        inv.root.file_id = 'some-new-root'
-        ie.name = 'file2'
-        self.assertEqual('some-tree-root', inv2.root.file_id)
-        self.assertEqual('hello', inv2['hello-id'].name)
+        inv.root.file_id = b'some-new-root'
+        ie.name = u'file2'
+        self.assertEqual(b'some-tree-root', inv2.root.file_id)
+        self.assertEqual(u'hello', inv2[b'hello-id'].name)
 
     def test_copy_empty(self):
         """Make sure an empty inventory can be copied."""
@@ -322,16 +322,17 @@
 
     def test_copy_copies_root_revision(self):
         """Make sure the revision of the root gets copied."""
-        inv = inventory.Inventory(root_id='someroot')
-        inv.root.revision = 'therev'
+        inv = inventory.Inventory(root_id=b'someroot')
+        inv.root.revision = b'therev'
         inv2 = inv.copy()
-        self.assertEqual('someroot', inv2.root.file_id)
-        self.assertEqual('therev', inv2.root.revision)
+        self.assertEqual(b'someroot', inv2.root.file_id)
+        self.assertEqual(b'therev', inv2.root.revision)
 
     def test_create_tree_reference(self):
-        inv = inventory.Inventory('tree-root-123')
-        inv.add(TreeReference('nested-id', 'nested', parent_id='tree-root-123',
-                              revision='rev', reference_revision='rev2'))
+        inv = inventory.Inventory(b'tree-root-123')
+        inv.add(TreeReference(
+            b'nested-id', 'nested', parent_id=b'tree-root-123',
+            revision=b'rev', reference_revision=b'rev2'))
 
     def test_error_encoding(self):
         inv = inventory.Inventory('tree-root')
@@ -997,30 +998,30 @@
 
     def test___getitem__(self):
         inv = Inventory()
-        inv.revision_id = "revid"
-        inv.root.revision = "rootrev"
-        inv.add(InventoryFile("fileid", "file", inv.root.file_id))
-        inv["fileid"].revision = "filerev"
-        inv["fileid"].executable = True
-        inv["fileid"].text_sha1 = "ffff"
-        inv["fileid"].text_size = 1
+        inv.revision_id = b"revid"
+        inv.root.revision = b"rootrev"
+        inv.add(InventoryFile(b"fileid", u"file", inv.root.file_id))
+        inv[b"fileid"].revision = b"filerev"
+        inv[b"fileid"].executable = True
+        inv[b"fileid"].text_sha1 = b"ffff"
+        inv[b"fileid"].text_size = 1
         chk_bytes = self.get_chk_bytes()
         chk_inv = CHKInventory.from_inventory(chk_bytes, inv)
-        bytes = ''.join(chk_inv.to_lines())
-        new_inv = CHKInventory.deserialise(chk_bytes, bytes, ("revid",))
+        data = b''.join(chk_inv.to_lines())
+        new_inv = CHKInventory.deserialise(chk_bytes, data, (b"revid",))
         root_entry = new_inv[inv.root.file_id]
-        file_entry = new_inv["fileid"]
+        file_entry = new_inv[b"fileid"]
         self.assertEqual("directory", root_entry.kind)
         self.assertEqual(inv.root.file_id, root_entry.file_id)
         self.assertEqual(inv.root.parent_id, root_entry.parent_id)
         self.assertEqual(inv.root.name, root_entry.name)
-        self.assertEqual("rootrev", root_entry.revision)
+        self.assertEqual(b"rootrev", root_entry.revision)
         self.assertEqual("file", file_entry.kind)
-        self.assertEqual("fileid", file_entry.file_id)
+        self.assertEqual(b"fileid", file_entry.file_id)
         self.assertEqual(inv.root.file_id, file_entry.parent_id)
-        self.assertEqual("file", file_entry.name)
-        self.assertEqual("filerev", file_entry.revision)
-        self.assertEqual("ffff", file_entry.text_sha1)
+        self.assertEqual(u"file", file_entry.name)
+        self.assertEqual(b"filerev", file_entry.revision)
+        self.assertEqual(b"ffff", file_entry.text_sha1)
         self.assertEqual(1, file_entry.text_size)
         self.assertEqual(True, file_entry.executable)
         self.assertRaises(errors.NoSuchId, new_inv.__getitem__, 'missing')
 
=== modified file 'breezy/tests/test_inventory_delta.py'
--- breezy/tests/test_inventory_delta.py	2017-06-09 16:31:49 +0000
+++ breezy/tests/test_inventory_delta.py	2017-06-11 01:47:17 +0000
@@ -32,14 +32,14 @@
 from . import TestCase
 
 ### DO NOT REFLOW THESE TEXTS. NEW LINES ARE SIGNIFICANT. ###
-empty_lines = """format: bzr inventory delta v1 (bzr 1.14)
+empty_lines = b"""format: bzr inventory delta v1 (bzr 1.14)
 parent: null:
 version: null:
 versioned_root: true
 tree_references: true
 """
 
-root_only_lines = """format: bzr inventory delta v1 (bzr 1.14)
+root_only_lines = b"""format: bzr inventory delta v1 (bzr 1.14)
 parent: null:
 version: entry-version
 versioned_root: true
@@ -48,7 +48,7 @@
 """
 
 
-root_change_lines = """format: bzr inventory delta v1 (bzr 1.14)
+root_change_lines = b"""format: bzr inventory delta v1 (bzr 1.14)
 parent: entry-version
 version: changed-root
 versioned_root: true
@@ -56,7 +56,7 @@
 /\x00an-id\x00\x00different-version\x00dir
 """
 
-corrupt_parent_lines = """format: bzr inventory delta v1 (bzr 1.14)
+corrupt_parent_lines = b"""format: bzr inventory delta v1 (bzr 1.14)
 parent: entry-version
 version: changed-root
 versioned_root: false
@@ -64,7 +64,7 @@
 /\x00an-id\x00\x00different-version\x00dir
 """
 
-root_only_unversioned = """format: bzr inventory delta v1 (bzr 1.14)
+root_only_unversioned = b"""format: bzr inventory delta v1 (bzr 1.14)
 parent: null:
 version: entry-version
 versioned_root: false
@@ -72,7 +72,7 @@
 None\x00/\x00TREE_ROOT\x00\x00entry-version\x00dir
 """
 
-reference_lines = """format: bzr inventory delta v1 (bzr 1.14)
+reference_lines = b"""format: bzr inventory delta v1 (bzr 1.14)
 parent: null:
 version: entry-version
 versioned_root: true
@@ -81,7 +81,7 @@
 None\x00/foo\x00id\x00TREE_ROOT\x00changed\x00tree\x00subtree-version
 """
 
-change_tree_lines = """format: bzr inventory delta v1 (bzr 1.14)
+change_tree_lines = b"""format: bzr inventory delta v1 (bzr 1.14)
 parent: entry-version
 version: change-tree
 versioned_root: false
@@ -96,34 +96,34 @@
     def test_parse_no_bytes(self):
         deserializer = inventory_delta.InventoryDeltaDeserializer()
         err = self.assertRaises(
-            InventoryDeltaError, deserializer.parse_text_bytes, '')
+            InventoryDeltaError, deserializer.parse_text_bytes, b'')
         self.assertContainsRe(str(err), 'last line not empty')
 
     def test_parse_bad_format(self):
         deserializer = inventory_delta.InventoryDeltaDeserializer()
         err = self.assertRaises(InventoryDeltaError,
-            deserializer.parse_text_bytes, 'format: foo\n')
+            deserializer.parse_text_bytes, b'format: foo\n')
         self.assertContainsRe(str(err), 'unknown format')
 
     def test_parse_no_parent(self):
         deserializer = inventory_delta.InventoryDeltaDeserializer()
         err = self.assertRaises(InventoryDeltaError,
             deserializer.parse_text_bytes,
-            'format: bzr inventory delta v1 (bzr 1.14)\n')
+            b'format: bzr inventory delta v1 (bzr 1.14)\n')
         self.assertContainsRe(str(err), 'missing parent: marker')
 
     def test_parse_no_version(self):
         deserializer = inventory_delta.InventoryDeltaDeserializer()
         err = self.assertRaises(InventoryDeltaError,
             deserializer.parse_text_bytes,
-            'format: bzr inventory delta v1 (bzr 1.14)\n'
-            'parent: null:\n')
+            b'format: bzr inventory delta v1 (bzr 1.14)\n'
+            b'parent: null:\n')
         self.assertContainsRe(str(err), 'missing version: marker')
-            
+
     def test_parse_duplicate_key_errors(self):
         deserializer = inventory_delta.InventoryDeltaDeserializer()
         double_root_lines = \
-"""format: bzr inventory delta v1 (bzr 1.14)
+b"""format: bzr inventory delta v1 (bzr 1.14)
 parent: null:
 version: null:
 versioned_root: true
@@ -139,16 +139,16 @@
         deserializer = inventory_delta.InventoryDeltaDeserializer()
         parse_result = deserializer.parse_text_bytes(root_only_lines)
         expected_entry = inventory.make_entry(
-            'directory', u'', None, 'an-id')
-        expected_entry.revision = 'a@e\xc3\xa5ample.com--2004'
+            'directory', u'', None, b'an-id')
+        expected_entry.revision = b'a@e\xc3\xa5ample.com--2004'
         self.assertEqual(
-            ('null:', 'entry-version', True, True,
-             [(None, '', 'an-id', expected_entry)]),
+            (b'null:', b'entry-version', True, True,
+             [(None, u'', b'an-id', expected_entry)]),
             parse_result)
 
     def test_parse_special_revid_not_valid_last_mod(self):
         deserializer = inventory_delta.InventoryDeltaDeserializer()
-        root_only_lines = """format: bzr inventory delta v1 (bzr 1.14)
+        root_only_lines = b"""format: bzr inventory delta v1 (bzr 1.14)
 parent: null:
 version: null:
 versioned_root: false
@@ -161,7 +161,7 @@
 
     def test_parse_versioned_root_versioned_disabled(self):
         deserializer = inventory_delta.InventoryDeltaDeserializer()
-        root_only_lines = """format: bzr inventory delta v1 (bzr 1.14)
+        root_only_lines = b"""format: bzr inventory delta v1 (bzr 1.14)
 parent: null:
 version: null:
 versioned_root: false
@@ -174,7 +174,7 @@
 
     def test_parse_unique_root_id_root_versioned_disabled(self):
         deserializer = inventory_delta.InventoryDeltaDeserializer()
-        root_only_lines = """format: bzr inventory delta v1 (bzr 1.14)
+        root_only_lines = b"""format: bzr inventory delta v1 (bzr 1.14)
 parent: parent-id
 version: a@e\xc3\xa5ample.com--2004
 versioned_root: false
@@ -189,11 +189,11 @@
         deserializer = inventory_delta.InventoryDeltaDeserializer()
         parse_result = deserializer.parse_text_bytes(root_only_unversioned)
         expected_entry = inventory.make_entry(
-            'directory', u'', None, 'TREE_ROOT')
-        expected_entry.revision = 'entry-version'
+            'directory', u'', None, b'TREE_ROOT')
+        expected_entry.revision = b'entry-version'
         self.assertEqual(
-            ('null:', 'entry-version', False, False,
-             [(None, u'', 'TREE_ROOT', expected_entry)]),
+            (b'null:', b'entry-version', False, False,
+             [(None, u'', b'TREE_ROOT', expected_entry)]),
             parse_result)
 
     def test_parse_versioned_root_when_disabled(self):
@@ -215,7 +215,7 @@
         deserializer = inventory_delta.InventoryDeltaDeserializer()
         # A serialised inventory delta with a header saying no tree refs, but
         # that has a tree ref in its content.
-        lines = """format: bzr inventory delta v1 (bzr 1.14)
+        lines = b"""format: bzr inventory delta v1 (bzr 1.14)
 parent: null:
 version: entry-version
 versioned_root: false
@@ -231,7 +231,7 @@
         deserializer = inventory_delta.InventoryDeltaDeserializer()
         # A serialised inventory delta with a header saying no tree refs, but
         # that has a tree ref in its content.
-        lines = """format: bzr inventory delta v1 (bzr 1.14)
+        lines = b"""format: bzr inventory delta v1 (bzr 1.14)
 parent: null:
 version: entry-version
 versioned_root: false
@@ -254,7 +254,7 @@
     def test_parse_invalid_newpath(self):
         """newpath must start with / if it is not None."""
         lines = empty_lines
-        lines += "None\x00bad\x00TREE_ROOT\x00\x00version\x00dir\n"
+        lines += b"None\x00bad\x00TREE_ROOT\x00\x00version\x00dir\n"
         deserializer = inventory_delta.InventoryDeltaDeserializer()
         err = self.assertRaises(InventoryDeltaError,
             deserializer.parse_text_bytes, lines)
@@ -263,39 +263,39 @@
     def test_parse_invalid_oldpath(self):
         """oldpath must start with / if it is not None."""
         lines = root_only_lines
-        lines += "bad\x00/new\x00file-id\x00\x00version\x00dir\n"
+        lines += b"bad\x00/new\x00file-id\x00\x00version\x00dir\n"
         deserializer = inventory_delta.InventoryDeltaDeserializer()
         err = self.assertRaises(InventoryDeltaError,
             deserializer.parse_text_bytes, lines)
         self.assertContainsRe(str(err), 'oldpath invalid')
-    
+
     def test_parse_new_file(self):
         """a new file is parsed correctly"""
         lines = root_only_lines
-        fake_sha = "deadbeef" * 5
+        fake_sha = b"deadbeef" * 5
         lines += (
-            "None\x00/new\x00file-id\x00an-id\x00version\x00file\x00123\x00" +
-            "\x00" + fake_sha + "\n")
+            b"None\x00/new\x00file-id\x00an-id\x00version\x00file\x00123\x00" +
+            b"\x00" + fake_sha + b"\n")
         deserializer = inventory_delta.InventoryDeltaDeserializer()
         parse_result = deserializer.parse_text_bytes(lines)
         expected_entry = inventory.make_entry(
-            'file', u'new', 'an-id', 'file-id')
-        expected_entry.revision = 'version'
+            'file', u'new', b'an-id', b'file-id')
+        expected_entry.revision = b'version'
         expected_entry.text_size = 123
         expected_entry.text_sha1 = fake_sha
         delta = parse_result[4]
         self.assertEqual(
-             (None, u'new', 'file-id', expected_entry), delta[-1])
+             (None, u'new', b'file-id', expected_entry), delta[-1])
 
     def test_parse_delete(self):
         lines = root_only_lines
         lines += (
-            "/old-file\x00None\x00deleted-id\x00\x00null:\x00deleted\x00\x00\n")
+            b"/old-file\x00None\x00deleted-id\x00\x00null:\x00deleted\x00\x00\n")
         deserializer = inventory_delta.InventoryDeltaDeserializer()
         parse_result = deserializer.parse_text_bytes(lines)
         delta = parse_result[4]
         self.assertEqual(
-             (u'old-file', None, 'deleted-id', None), delta[-1])
+             (u'old-file', None, b'deleted-id', None), delta[-1])
 
 
 class TestSerialization(TestCase):
@@ -313,86 +313,86 @@
     def test_root_only_to_lines(self):
         old_inv = Inventory(None)
         new_inv = Inventory(None)
-        root = new_inv.make_entry('directory', '', None, 'an-id')
-        root.revision = 'a@e\xc3\xa5ample.com--2004'
+        root = new_inv.make_entry('directory', u'', None, b'an-id')
+        root.revision = b'a@e\xc3\xa5ample.com--2004'
         new_inv.add(root)
         delta = new_inv._make_delta(old_inv)
         serializer = inventory_delta.InventoryDeltaSerializer(
             versioned_root=True, tree_references=True)
         self.assertEqual(BytesIO(root_only_lines).readlines(),
-            serializer.delta_to_lines(NULL_REVISION, 'entry-version', delta))
+            serializer.delta_to_lines(NULL_REVISION, b'entry-version', delta))
 
     def test_unversioned_root(self):
         old_inv = Inventory(None)
         new_inv = Inventory(None)
-        root = new_inv.make_entry('directory', '', None, 'TREE_ROOT')
+        root = new_inv.make_entry('directory', u'', None, b'TREE_ROOT')
         # Implicit roots are considered modified in every revision.
-        root.revision = 'entry-version'
+        root.revision = b'entry-version'
         new_inv.add(root)
         delta = new_inv._make_delta(old_inv)
         serializer = inventory_delta.InventoryDeltaSerializer(
             versioned_root=False, tree_references=False)
         serialized_lines = serializer.delta_to_lines(
-            NULL_REVISION, 'entry-version', delta)
+            NULL_REVISION, b'entry-version', delta)
         self.assertEqual(BytesIO(root_only_unversioned).readlines(),
             serialized_lines)
         deserializer = inventory_delta.InventoryDeltaDeserializer()
         self.assertEqual(
-            (NULL_REVISION, 'entry-version', False, False, delta),
-            deserializer.parse_text_bytes(''.join(serialized_lines)))
+            (NULL_REVISION, b'entry-version', False, False, delta),
+            deserializer.parse_text_bytes(b''.join(serialized_lines)))
 
     def test_unversioned_non_root_errors(self):
         old_inv = Inventory(None)
         new_inv = Inventory(None)
-        root = new_inv.make_entry('directory', '', None, 'TREE_ROOT')
-        root.revision = 'a@e\xc3\xa5ample.com--2004'
+        root = new_inv.make_entry('directory', u'', None, b'TREE_ROOT')
+        root.revision = b'a@e\xc3\xa5ample.com--2004'
         new_inv.add(root)
-        non_root = new_inv.make_entry('directory', 'foo', root.file_id, 'id')
+        non_root = new_inv.make_entry('directory', u'foo', root.file_id, b'id')
         new_inv.add(non_root)
         delta = new_inv._make_delta(old_inv)
         serializer = inventory_delta.InventoryDeltaSerializer(
             versioned_root=True, tree_references=True)
         err = self.assertRaises(InventoryDeltaError,
-            serializer.delta_to_lines, NULL_REVISION, 'entry-version', delta)
+            serializer.delta_to_lines, NULL_REVISION, b'entry-version', delta)
         self.assertContainsRe(str(err), "^no version for fileid b?'id'$")
 
     def test_richroot_unversioned_root_errors(self):
         old_inv = Inventory(None)
         new_inv = Inventory(None)
-        root = new_inv.make_entry('directory', '', None, 'TREE_ROOT')
+        root = new_inv.make_entry('directory', '', None, b'TREE_ROOT')
         new_inv.add(root)
         delta = new_inv._make_delta(old_inv)
         serializer = inventory_delta.InventoryDeltaSerializer(
             versioned_root=True, tree_references=True)
         err = self.assertRaises(InventoryDeltaError,
-            serializer.delta_to_lines, NULL_REVISION, 'entry-version', delta)
+            serializer.delta_to_lines, NULL_REVISION, b'entry-version', delta)
         self.assertContainsRe(
             str(err), "no version for fileid b?'TREE_ROOT'$")
 
     def test_nonrichroot_versioned_root_errors(self):
         old_inv = Inventory(None)
         new_inv = Inventory(None)
-        root = new_inv.make_entry('directory', '', None, 'TREE_ROOT')
-        root.revision = 'a@e\xc3\xa5ample.com--2004'
+        root = new_inv.make_entry('directory', u'', None, b'TREE_ROOT')
+        root.revision = b'a@e\xc3\xa5ample.com--2004'
         new_inv.add(root)
         delta = new_inv._make_delta(old_inv)
         serializer = inventory_delta.InventoryDeltaSerializer(
             versioned_root=False, tree_references=True)
         err = self.assertRaises(InventoryDeltaError,
-            serializer.delta_to_lines, NULL_REVISION, 'entry-version', delta)
+            serializer.delta_to_lines, NULL_REVISION, b'entry-version', delta)
         self.assertContainsRe(
             str(err), "^Version present for / in b?'TREE_ROOT'")
 
     def test_unknown_kind_errors(self):
         old_inv = Inventory(None)
         new_inv = Inventory(None)
-        root = new_inv.make_entry('directory', '', None, 'my-rich-root-id')
-        root.revision = 'changed'
+        root = new_inv.make_entry('directory', u'', None, b'my-rich-root-id')
+        root.revision = b'changed'
         new_inv.add(root)
         class StrangeInventoryEntry(inventory.InventoryEntry):
             kind = 'strange'
-        non_root = StrangeInventoryEntry('id', 'foo', root.file_id)
-        non_root.revision = 'changed'
+        non_root = StrangeInventoryEntry('id', u'foo', root.file_id)
+        non_root.revision = b'changed'
         new_inv.add(non_root)
         delta = new_inv._make_delta(old_inv)
         serializer = inventory_delta.InventoryDeltaSerializer(
@@ -400,19 +400,19 @@
         # we expect keyerror because there is little value wrapping this.
         # This test aims to prove that it errors more than how it errors.
         err = self.assertRaises(KeyError,
-            serializer.delta_to_lines, NULL_REVISION, 'entry-version', delta)
+            serializer.delta_to_lines, NULL_REVISION, b'entry-version', delta)
         self.assertEqual(('strange',), err.args)
 
     def test_tree_reference_disabled(self):
         old_inv = Inventory(None)
         new_inv = Inventory(None)
-        root = new_inv.make_entry('directory', '', None, 'TREE_ROOT')
-        root.revision = 'a@e\xc3\xa5ample.com--2004'
+        root = new_inv.make_entry('directory', u'', None, b'TREE_ROOT')
+        root.revision = b'a@e\xc3\xa5ample.com--2004'
         new_inv.add(root)
         non_root = new_inv.make_entry(
-            'tree-reference', 'foo', root.file_id, 'id')
-        non_root.revision = 'changed'
-        non_root.reference_revision = 'subtree-version'
+            'tree-reference', u'foo', root.file_id, b'id')
+        non_root.revision = b'changed'
+        non_root.reference_revision = b'subtree-version'
         new_inv.add(non_root)
         delta = new_inv._make_delta(old_inv)
         serializer = inventory_delta.InventoryDeltaSerializer(
@@ -420,59 +420,60 @@
         # we expect keyerror because there is little value wrapping this.
         # This test aims to prove that it errors more than how it errors.
         err = self.assertRaises(KeyError,
-            serializer.delta_to_lines, NULL_REVISION, 'entry-version', delta)
+            serializer.delta_to_lines, NULL_REVISION, b'entry-version', delta)
         self.assertEqual(('tree-reference',), err.args)
 
     def test_tree_reference_enabled(self):
         old_inv = Inventory(None)
         new_inv = Inventory(None)
-        root = new_inv.make_entry('directory', '', None, 'TREE_ROOT')
-        root.revision = 'a@e\xc3\xa5ample.com--2004'
+        root = new_inv.make_entry('directory', u'', None, b'TREE_ROOT')
+        root.revision = b'a@e\xc3\xa5ample.com--2004'
         new_inv.add(root)
         non_root = new_inv.make_entry(
-            'tree-reference', 'foo', root.file_id, 'id')
-        non_root.revision = 'changed'
-        non_root.reference_revision = 'subtree-version'
+            'tree-reference', u'foo', root.file_id, b'id')
+        non_root.revision = b'changed'
+        non_root.reference_revision = b'subtree-version'
         new_inv.add(non_root)
         delta = new_inv._make_delta(old_inv)
         serializer = inventory_delta.InventoryDeltaSerializer(
             versioned_root=True, tree_references=True)
         self.assertEqual(BytesIO(reference_lines).readlines(),
-            serializer.delta_to_lines(NULL_REVISION, 'entry-version', delta))
+            serializer.delta_to_lines(NULL_REVISION, b'entry-version', delta))
 
     def test_to_inventory_root_id_versioned_not_permitted(self):
-        root_entry = inventory.make_entry('directory', '', None, 'TREE_ROOT')
-        root_entry.revision = 'some-version'
-        delta = [(None, '', 'TREE_ROOT', root_entry)]
+        root_entry = inventory.make_entry('directory', u'', None, b'TREE_ROOT')
+        root_entry.revision = b'some-version'
+        delta = [(None, u'', b'TREE_ROOT', root_entry)]
         serializer = inventory_delta.InventoryDeltaSerializer(
             versioned_root=False, tree_references=True)
         self.assertRaises(
-            InventoryDeltaError, serializer.delta_to_lines, 'old-version',
-            'new-version', delta)
+            InventoryDeltaError, serializer.delta_to_lines, b'old-version',
+            b'new-version', delta)
 
     def test_to_inventory_root_id_not_versioned(self):
-        delta = [(None, '', 'an-id', inventory.make_entry(
-            'directory', '', None, 'an-id'))]
+        delta = [(None, u'', b'an-id', inventory.make_entry(
+            'directory', u'', None, b'an-id'))]
         serializer = inventory_delta.InventoryDeltaSerializer(
             versioned_root=True, tree_references=True)
         self.assertRaises(
-            InventoryDeltaError, serializer.delta_to_lines, 'old-version',
-            'new-version', delta)
+            InventoryDeltaError, serializer.delta_to_lines, b'old-version',
+            b'new-version', delta)
 
     def test_to_inventory_has_tree_not_meant_to(self):
         make_entry = inventory.make_entry
-        tree_ref = make_entry('tree-reference', 'foo', 'changed-in', 'ref-id')
-        tree_ref.reference_revision = 'ref-revision'
+        tree_ref = make_entry(
+            'tree-reference', u'foo', b'changed-in', b'ref-id')
+        tree_ref.reference_revision = b'ref-revision'
         delta = [
-            (None, '', 'an-id',
-             make_entry('directory', '', 'changed-in', 'an-id')),
-            (None, 'foo', 'ref-id', tree_ref)
+            (None, u'', b'an-id',
+             make_entry('directory', u'', b'changed-in', b'an-id')),
+            (None, u'foo', b'ref-id', tree_ref)
             # a file that followed the root move
             ]
         serializer = inventory_delta.InventoryDeltaSerializer(
             versioned_root=True, tree_references=True)
         self.assertRaises(InventoryDeltaError, serializer.delta_to_lines,
-            'old-version', 'new-version', delta)
+            b'old-version', b'new-version', delta)
 
     def test_to_inventory_torture(self):
         def make_entry(kind, name, parent_id, file_id, **attrs):
@@ -488,43 +489,43 @@
         # - files with and without exec bit
         delta = [
             # new root:
-            (None, '', 'new-root-id',
-                make_entry('directory', '', None, 'new-root-id',
-                    revision='changed-in')),
+            (None, u'', b'new-root-id',
+                make_entry('directory', u'', None, b'new-root-id',
+                    revision=b'changed-in')),
             # an old root:
-            ('', 'old-root', 'TREE_ROOT',
-                make_entry('directory', 'subdir-now', 'new-root-id',
-                'TREE_ROOT', revision='moved-root')),
+            (u'', u'old-root', b'TREE_ROOT',
+                make_entry('directory', u'subdir-now', b'new-root-id',
+                b'TREE_ROOT', revision=b'moved-root')),
             # a file that followed the root move
-            ('under-old-root', 'old-root/under-old-root', 'moved-id',
-                make_entry('file', 'under-old-root', 'TREE_ROOT', 'moved-id',
-                   revision='old-rev', executable=False, text_size=30,
-                   text_sha1='some-sha')),
+            (u'under-old-root', u'old-root/under-old-root', b'moved-id',
+                make_entry('file', u'under-old-root', b'TREE_ROOT',
+                    b'moved-id', revision=b'old-rev', executable=False,
+                    text_size=30, text_sha1=b'some-sha')),
             # a deleted path
-            ('old-file', None, 'deleted-id', None),
+            (u'old-file', None, b'deleted-id', None),
             # a tree reference moved to the new root
-            ('ref', 'ref', 'ref-id',
-                make_entry('tree-reference', 'ref', 'new-root-id', 'ref-id',
-                    reference_revision='tree-reference-id',
-                    revision='new-rev')),
+            (u'ref', u'ref', b'ref-id',
+                make_entry('tree-reference', u'ref', b'new-root-id', b'ref-id',
+                    reference_revision=b'tree-reference-id',
+                    revision=b'new-rev')),
             # a symlink now in a deep dir
-            ('dir/link', 'old-root/dir/link', 'link-id',
-                make_entry('symlink', 'link', 'deep-id', 'link-id',
-                   symlink_target='target', revision='new-rev')),
+            (u'dir/link', u'old-root/dir/link', b'link-id',
+                make_entry('symlink', u'link', b'deep-id', b'link-id',
+                   symlink_target=u'target', revision=b'new-rev')),
             # a deep dir
-            ('dir', 'old-root/dir', 'deep-id',
-                make_entry('directory', 'dir', 'TREE_ROOT', 'deep-id',
-                    revision='new-rev')),
+            (u'dir', u'old-root/dir', b'deep-id',
+                make_entry('directory', u'dir', b'TREE_ROOT', b'deep-id',
+                    revision=b'new-rev')),
             # a file with an exec bit set
-            (None, 'configure', 'exec-id',
-                make_entry('file', 'configure', 'new-root-id', 'exec-id',
-                   executable=True, text_size=30, text_sha1='some-sha',
-                   revision='old-rev')),
+            (None, u'configure', b'exec-id',
+                make_entry('file', u'configure', b'new-root-id', b'exec-id',
+                   executable=True, text_size=30, text_sha1=b'some-sha',
+                   revision=b'old-rev')),
             ]
         serializer = inventory_delta.InventoryDeltaSerializer(
             versioned_root=True, tree_references=True)
-        lines = serializer.delta_to_lines(NULL_REVISION, 'something', delta)
-        expected = """format: bzr inventory delta v1 (bzr 1.14)
+        lines = serializer.delta_to_lines(NULL_REVISION, b'something', delta)
+        expected = b"""format: bzr inventory delta v1 (bzr 1.14)
 parent: null:
 version: something
 versioned_root: true
@@ -538,8 +539,8 @@
 None\x00/\x00new-root-id\x00\x00changed-in\x00dir
 None\x00/configure\x00exec-id\x00new-root-id\x00old-rev\x00file\x0030\x00Y\x00some-sha
 """
-        serialized = ''.join(lines)
-        self.assertIsInstance(serialized, str)
+        serialized = b''.join(lines)
+        self.assertIsInstance(serialized, bytes)
         self.assertEqual(expected, serialized)
 
 
@@ -547,79 +548,79 @@
     """Test serialization of the content part of a line."""
 
     def test_dir(self):
-        entry = inventory.make_entry('directory', 'a dir', None)
-        self.assertEqual('dir', inventory_delta._directory_content(entry))
+        entry = inventory.make_entry('directory', u'a dir', None)
+        self.assertEqual(b'dir', inventory_delta._directory_content(entry))
 
     def test_file_0_short_sha(self):
-        file_entry = inventory.make_entry('file', 'a file', None, 'file-id')
-        file_entry.text_sha1 = ''
+        file_entry = inventory.make_entry('file', u'a file', None, b'file-id')
+        file_entry.text_sha1 = b''
         file_entry.text_size = 0
-        self.assertEqual('file\x000\x00\x00',
+        self.assertEqual(b'file\x000\x00\x00',
             inventory_delta._file_content(file_entry))
 
     def test_file_10_foo(self):
-        file_entry = inventory.make_entry('file', 'a file', None, 'file-id')
-        file_entry.text_sha1 = 'foo'
+        file_entry = inventory.make_entry('file', u'a file', None, b'file-id')
+        file_entry.text_sha1 = b'foo'
         file_entry.text_size = 10
-        self.assertEqual('file\x0010\x00\x00foo',
+        self.assertEqual(b'file\x0010\x00\x00foo',
             inventory_delta._file_content(file_entry))
 
     def test_file_executable(self):
-        file_entry = inventory.make_entry('file', 'a file', None, 'file-id')
+        file_entry = inventory.make_entry('file', u'a file', None, b'file-id')
         file_entry.executable = True
-        file_entry.text_sha1 = 'foo'
+        file_entry.text_sha1 = b'foo'
         file_entry.text_size = 10
-        self.assertEqual('file\x0010\x00Y\x00foo',
+        self.assertEqual(b'file\x0010\x00Y\x00foo',
             inventory_delta._file_content(file_entry))
 
     def test_file_without_size(self):
-        file_entry = inventory.make_entry('file', 'a file', None, 'file-id')
-        file_entry.text_sha1 = 'foo'
+        file_entry = inventory.make_entry('file', u'a file', None, b'file-id')
+        file_entry.text_sha1 = b'foo'
         self.assertRaises(InventoryDeltaError,
             inventory_delta._file_content, file_entry)
 
     def test_file_without_sha1(self):
-        file_entry = inventory.make_entry('file', 'a file', None, 'file-id')
+        file_entry = inventory.make_entry('file', u'a file', None, b'file-id')
         file_entry.text_size = 10
         self.assertRaises(InventoryDeltaError,
             inventory_delta._file_content, file_entry)
 
     def test_link_empty_target(self):
-        entry = inventory.make_entry('symlink', 'a link', None)
-        entry.symlink_target = ''
-        self.assertEqual('link\x00',
+        entry = inventory.make_entry('symlink', u'a link', None)
+        entry.symlink_target = u''
+        self.assertEqual(b'link\x00',
             inventory_delta._link_content(entry))
 
     def test_link_unicode_target(self):
-        entry = inventory.make_entry('symlink', 'a link', None)
-        entry.symlink_target = ' \xc3\xa5'.decode('utf8')
-        self.assertEqual('link\x00 \xc3\xa5',
+        entry = inventory.make_entry('symlink', u'a link', None)
+        entry.symlink_target = b' \xc3\xa5'.decode('utf8')
+        self.assertEqual(b'link\x00 \xc3\xa5',
             inventory_delta._link_content(entry))
 
     def test_link_space_target(self):
-        entry = inventory.make_entry('symlink', 'a link', None)
-        entry.symlink_target = ' '
-        self.assertEqual('link\x00 ',
+        entry = inventory.make_entry('symlink', u'a link', None)
+        entry.symlink_target = u' '
+        self.assertEqual(b'link\x00 ',
             inventory_delta._link_content(entry))
 
     def test_link_no_target(self):
-        entry = inventory.make_entry('symlink', 'a link', None)
+        entry = inventory.make_entry('symlink', u'a link', None)
         self.assertRaises(InventoryDeltaError,
             inventory_delta._link_content, entry)
 
     def test_reference_null(self):
-        entry = inventory.make_entry('tree-reference', 'a tree', None)
+        entry = inventory.make_entry('tree-reference', u'a tree', None)
         entry.reference_revision = NULL_REVISION
-        self.assertEqual('tree\x00null:',
+        self.assertEqual(b'tree\x00null:',
             inventory_delta._reference_content(entry))
 
     def test_reference_revision(self):
-        entry = inventory.make_entry('tree-reference', 'a tree', None)
-        entry.reference_revision = 'foo@\xc3\xa5b-lah'
-        self.assertEqual('tree\x00foo@\xc3\xa5b-lah',
+        entry = inventory.make_entry('tree-reference', u'a tree', None)
+        entry.reference_revision = b'foo@\xc3\xa5b-lah'
+        self.assertEqual(b'tree\x00foo@\xc3\xa5b-lah',
             inventory_delta._reference_content(entry))
 
     def test_reference_no_reference(self):
-        entry = inventory.make_entry('tree-reference', 'a tree', None)
+        entry = inventory.make_entry('tree-reference', u'a tree', None)
         self.assertRaises(InventoryDeltaError,
             inventory_delta._reference_content, entry)
 
=== modified file 'breezy/transport/memory.py'
--- breezy/transport/memory.py	2017-05-24 19:44:00 +0000
+++ breezy/transport/memory.py	2017-06-11 01:47:17 +0000
@@ -164,7 +164,7 @@
 
     def open_write_stream(self, relpath, mode=None):
         """See Transport.open_write_stream."""
-        self.put_bytes(relpath, "", mode)
+        self.put_bytes(relpath, b"", mode)
         result = AppendBasedFileStream(self, relpath)
         _file_streams[self.abspath(relpath)] = result
         return result
 
=== modified file 'breezy/versionedfile.py'
--- breezy/versionedfile.py	2017-06-05 20:48:31 +0000
+++ breezy/versionedfile.py	2017-06-11 01:47:17 +0000
@@ -120,7 +120,7 @@
         if storage_kind == 'chunked':
             return self._chunks
         elif storage_kind == 'fulltext':
-            return ''.join(self._chunks)
+            return b''.join(self._chunks)
         raise errors.UnavailableRepresentation(self.key, storage_kind,
             self.storage_kind)
 
@@ -1079,13 +1079,13 @@
     def _check_lines_not_unicode(self, lines):
         """Check that lines being added to a versioned file are not unicode."""
         for line in lines:
-            if line.__class__ is not str:
+            if line.__class__ is not bytes:
                 raise errors.BzrBadParameterUnicode("lines")
 
     def _check_lines_are_lines(self, lines):
         """Check that the lines really are full lines without inline EOL."""
         for line in lines:
-            if '\n' in line[:-1]:
+            if b'\n' in line[:-1]:
                 raise errors.BzrBadParameterContainsNewline("lines")
 
     def get_known_graph_ancestry(self, keys):
@@ -1792,7 +1792,7 @@
                 "nostore_sha behaviour.")
         if key[-1] is None:
             sha1 = osutils.sha_strings(lines)
-            key = ("sha1:" + sha1,)
+            key = (b"sha1:" + sha1,)
         else:
             sha1 = None
         if key in self._store.get_parent_map([key]):
@@ -1816,7 +1816,7 @@
     :param network_bytes: The bytes of a record.
     :return: A tuple (storage_kind, offset_of_remaining_bytes)
     """
-    line_end = network_bytes.find('\n')
+    line_end = network_bytes.find(b'\n')
     storage_kind = network_bytes[:line_end]
     return storage_kind, line_end + 1
 
@@ -1859,7 +1859,7 @@
     meta_len, = struct.unpack('!L', bytes[line_end:line_end+4])
     record_meta = bytes[line_end+4:line_end+4+meta_len]
     key, parents = bencode.bdecode_as_tuple(record_meta)
-    if parents == 'nil':
+    if parents == b'nil':
         parents = None
     fulltext = bytes[line_end+4+meta_len:]
     return [FulltextContentFactory(key, parents, None, fulltext)]
@@ -1871,12 +1871,12 @@
 
 def record_to_fulltext_bytes(record):
     if record.parents is None:
-        parents = 'nil'
+        parents = b'nil'
     else:
         parents = record.parents
     record_meta = bencode.bencode((record.key, parents))
     record_content = record.get_bytes_as('fulltext')
-    return "fulltext\n%s%s%s" % (
+    return b"fulltext\n%s%s%s" % (
         _length_prefix(record_meta), record_meta, record_content)
 
 
@@ -1893,8 +1893,8 @@
     per_prefix_map = {}
     for item in viewitems(parent_map):
         key = item[0]
-        if isinstance(key, str) or len(key) == 1:
-            prefix = ''
+        if isinstance(key, bytes) or len(key) == 1:
+            prefix = b''
         else:
             prefix = key[0]
         try:
 
=== modified file 'breezy/xml_serializer.py'
--- breezy/xml_serializer.py	2017-05-25 01:35:55 +0000
+++ breezy/xml_serializer.py	2017-06-11 01:47:17 +0000
@@ -37,9 +37,9 @@
     except ImportError:
         from xml.parsers.expat import ExpatError as ParseError
 
-(ElementTree, SubElement, Element, XMLTreeBuilder, fromstring, tostring) = (
+(ElementTree, SubElement, Element, fromstring, tostring) = (
     elementtree.ElementTree, elementtree.SubElement, elementtree.Element,
-    elementtree.XMLTreeBuilder, elementtree.fromstring, elementtree.tostring)
+    elementtree.fromstring, elementtree.tostring)
 
 
 from . import (