Merge lp:~jelmer/brz/inventory-chunks into lp:brz

[Jelmer Vernooij]

Use chunks rather than fulltexts for inventories where possible.

Use chunks rather than fulltexts for inventories where possible.

[Jelmer Vernooij (jelmer)]

review: Approve

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

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

=== modified file 'breezy/bzr/bundle/bundle_data.py'
--- breezy/bzr/bundle/bundle_data.py	2020-01-19 13:47:29 +0000
+++ breezy/bzr/bundle/bundle_data.py	2020-01-30 16:35:32 +0000
@@ -40,7 +40,7 @@
     InventoryFile,
     InventoryLink,
     )
-from ...osutils import sha_string, pathjoin
+from ...osutils import sha_string, sha_strings, pathjoin
 from ...revision import Revision, NULL_REVISION
 from ...sixish import (
     viewitems,
@@ -286,15 +286,15 @@
         so build up an inventory, and make sure the hashes match.
         """
         # Now we should have a complete inventory entry.
-        s = serializer_v5.write_inventory_to_string(inv)
-        sha1 = sha_string(s)
+        cs = serializer_v5.write_inventory_to_chunks(inv)
+        sha1 = sha_strings(cs)
         # Target revision is the last entry in the real_revisions list
         rev = self.get_revision(revision_id)
         if rev.revision_id != revision_id:
             raise AssertionError()
         if sha1 != rev.inventory_sha1:
             with open(',,bogus-inv', 'wb') as f:
-                f.write(s)
+                f.writelines(cs)
             warning('Inventory sha hash mismatch for revision %s. %s'
                     ' != %s' % (revision_id, sha1, rev.inventory_sha1))
 

=== modified file 'breezy/bzr/bundle/serializer/v4.py'
--- breezy/bzr/bundle/serializer/v4.py	2019-06-30 10:50:40 +0000
+++ breezy/bzr/bundle/serializer/v4.py	2020-01-30 16:35:32 +0000
@@ -62,7 +62,7 @@
         # parents first, and then grab the ordered requests.
         needed_ids = [k[-1] for k in self.present_parents]
         needed_ids.extend([k[-1] for k in self.ordered_keys])
-        inv_to_bytes = self.repo._serializer.write_inventory_to_string
+        inv_to_lines = self.repo._serializer.write_inventory_to_chunks
         for inv in self.repo.iter_inventories(needed_ids):
             revision_id = inv.revision_id
             key = (revision_id,)
@@ -72,12 +72,12 @@
                 parent_ids = None
             else:
                 parent_ids = [k[-1] for k in self.parent_map[key]]
-            as_bytes = inv_to_bytes(inv)
-            self._process_one_record(key, (as_bytes,))
+            as_chunks = inv_to_lines(inv)
+            self._process_one_record(key, as_chunks)
             if parent_ids is None:
                 continue
             diff = self.diffs.pop(key)
-            sha1 = osutils.sha_string(as_bytes)
+            sha1 = osutils.sha_strings(as_chunks)
             yield revision_id, parent_ids, sha1, diff
 
 
@@ -368,7 +368,7 @@
         """Generate mpdiffs by serializing inventories.
 
         The current repository only has part of the tree shape information in
-        the 'inventories' vf. So we use serializer.write_inventory_to_string to
+        the 'inventories' vf. So we use serializer.write_inventory_to_lines to
         get a 'full' representation of the tree shape, and then generate
         mpdiffs on that data stream. This stream can then be reconstructed on
         the other side.
@@ -626,10 +626,10 @@
                     present_parent_ids.append(p_id)
                 else:
                     ghosts.add(p_id)
-            to_string = self._source_serializer.write_inventory_to_string
+            to_lines = self._source_serializer.write_inventory_to_chunks
             for parent_inv in self._repository.iter_inventories(
                     present_parent_ids):
-                p_text = to_string(parent_inv)
+                p_text = b''.join(to_lines(parent_inv))
                 inventory_cache[parent_inv.revision_id] = parent_inv
                 cached_parent_texts[parent_inv.revision_id] = p_text
                 inventory_text_cache[parent_inv.revision_id] = p_text
@@ -670,15 +670,14 @@
                 # as lines and then cast back to a string.
                 target_lines = multiparent.MultiParent.from_patch(bytes
                                                                   ).to_lines(p_texts)
-                inv_text = b''.join(target_lines)
-                del target_lines
-                sha1 = osutils.sha_string(inv_text)
+                sha1 = osutils.sha_strings(target_lines)
                 if sha1 != metadata[b'sha1']:
                     raise errors.BadBundle("Can't convert to target format")
                 # Add this to the cache so we don't have to extract it again.
-                inventory_text_cache[revision_id] = inv_text
-                target_inv = self._source_serializer.read_inventory_from_string(
-                    inv_text)
+                inventory_text_cache[revision_id] = b''.join(target_lines)
+                target_inv = self._source_serializer.read_inventory_from_lines(
+                    target_lines)
+                del target_lines
                 self._handle_root(target_inv, parent_ids)
                 parent_inv = None
                 if parent_ids:

=== modified file 'breezy/bzr/chk_serializer.py'
--- breezy/bzr/chk_serializer.py	2018-11-11 04:08:32 +0000
+++ breezy/bzr/chk_serializer.py	2020-01-30 16:35:32 +0000
@@ -162,8 +162,8 @@
                                                    return_from_cache)
         return inv
 
-    def read_inventory_from_string(self, xml_string, revision_id=None,
-                                   entry_cache=None, return_from_cache=False):
+    def read_inventory_from_lines(self, xml_lines, revision_id=None,
+                                  entry_cache=None, return_from_cache=False):
         """Read xml_string into an inventory object.
 
         :param xml_string: The xml to read.
@@ -179,7 +179,7 @@
         """
         try:
             return self._unpack_inventory(
-                xml_serializer.fromstring(xml_string), revision_id,
+                xml_serializer.fromstringlist(xml_lines), revision_id,
                 entry_cache=entry_cache,
                 return_from_cache=return_from_cache)
         except xml_serializer.ParseError as e:
@@ -200,15 +200,9 @@
         """Return a list of lines with the encoded inventory."""
         return self.write_inventory(inv, None)
 
-    def write_inventory_to_string(self, inv, working=False):
-        """Just call write_inventory with a BytesIO and return the value.
-
-        :param working: If True skip history data - text_sha1, text_size,
-            reference_revision, symlink_target.
-        """
-        sio = BytesIO()
-        self.write_inventory(inv, sio, working)
-        return sio.getvalue()
+    def write_inventory_to_chunks(self, inv):
+        """Return a list of lines with the encoded inventory."""
+        return self.write_inventory(inv, None)
 
     def write_inventory(self, inv, f, working=False):
         """Write inventory to a file.

=== modified file 'breezy/bzr/groupcompress_repo.py'
--- breezy/bzr/groupcompress_repo.py	2020-01-25 14:07:41 +0000
+++ breezy/bzr/groupcompress_repo.py	2020-01-30 16:35:32 +0000
@@ -234,9 +234,9 @@
             stream = source_vf.get_record_stream(keys, 'groupcompress', True)
             for idx, record in enumerate(stream):
                 # Inventories should always be with revisions; assume success.
-                bytes = record.get_bytes_as('fulltext')
-                chk_inv = inventory.CHKInventory.deserialise(None, bytes,
-                                                             record.key)
+                lines = record.get_bytes_as('lines')
+                chk_inv = inventory.CHKInventory.deserialise(
+                    None, lines, record.key)
                 if pb is not None:
                     pb.update('inv', idx, total_keys)
                 key = chk_inv.id_to_entry.key()
@@ -664,9 +664,9 @@
             search_key_name = None
             for idx, record in enumerate(stream):
                 # Inventories should always be with revisions; assume success.
-                bytes = record.get_bytes_as('fulltext')
+                lines = record.get_bytes_as('lines')
                 chk_inv = inventory.CHKInventory.deserialise(
-                    source_chk_vf, bytes, record.key)
+                    source_chk_vf, lines, record.key)
                 if pb is not None:
                     pb.update('inv', idx, total_keys)
                 chk_inv.id_to_entry._ensure_root()
@@ -979,8 +979,8 @@
             if basis_tree is not None:
                 basis_tree.unlock()
 
-    def _deserialise_inventory(self, revision_id, bytes):
-        return inventory.CHKInventory.deserialise(self.chk_bytes, bytes,
+    def _deserialise_inventory(self, revision_id, lines):
+        return inventory.CHKInventory.deserialise(self.chk_bytes, lines,
                                                   (revision_id,))
 
     def _iter_inventories(self, revision_ids, ordering):
@@ -992,16 +992,16 @@
         texts = {}
         for record in stream:
             if record.storage_kind != 'absent':
-                texts[record.key] = record.get_bytes_as('fulltext')
+                texts[record.key] = record.get_bytes_as('lines')
             else:
                 texts[record.key] = None
         for key in keys:
-            bytes = texts[key]
-            if bytes is None:
+            lines = texts[key]
+            if lines is None:
                 yield (None, key[-1])
             else:
                 yield (inventory.CHKInventory.deserialise(
-                    self.chk_bytes, bytes, key), key[-1])
+                    self.chk_bytes, lines, key), key[-1])
 
     def _get_inventory_xml(self, revision_id):
         """Get serialized inventory as a string."""
@@ -1010,7 +1010,7 @@
         # it allowing _get_inventory_xml to work. Bundles currently use the
         # serializer directly; this also isn't ideal, but there isn't an xml
         # iteration interface offered at all for repositories.
-        return self._serializer.write_inventory_to_string(
+        return self._serializer.write_inventory_to_lines(
             self.get_inventory(revision_id))
 
     def _find_present_inventory_keys(self, revision_keys):
@@ -1187,8 +1187,8 @@
                         continue
                     else:
                         raise errors.NoSuchRevision(self, record.key)
-                bytes = record.get_bytes_as('fulltext')
-                chk_inv = inventory.CHKInventory.deserialise(None, bytes,
+                lines = record.get_bytes_as('lines')
+                chk_inv = inventory.CHKInventory.deserialise(None, lines,
                                                              record.key)
                 key = chk_inv.id_to_entry.key()
                 if key not in id_roots_set:

=== modified file 'breezy/bzr/inventory.py'
--- breezy/bzr/inventory.py	2019-10-06 11:30:57 +0000
+++ breezy/bzr/inventory.py	2020-01-30 16:35:32 +0000
@@ -1829,7 +1829,7 @@
         return result
 
     @classmethod
-    def deserialise(klass, chk_store, bytes, expected_revision_id):
+    def deserialise(klass, chk_store, lines, expected_revision_id):
         """Deserialise a CHKInventory.
 
         :param chk_store: A CHK capable VersionedFiles instance.
@@ -1838,18 +1838,16 @@
             for.
         :return: A CHKInventory
         """
-        lines = bytes.split(b'\n')
-        if lines[-1] != b'':
-            raise AssertionError('bytes to deserialize must end with an eol')
-        lines.pop()
-        if lines[0] != b'chkinventory:':
+        if not lines[-1].endswith(b'\n'):
+            raise ValueError("last line should have trailing eol\n")
+        if lines[0] != b'chkinventory:\n':
             raise ValueError("not a serialised CHKInventory: %r" % bytes)
         info = {}
         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(b': ', 1)
+            key, value = line.rstrip(b'\n').split(b': ', 1)
             if key not in allowed_keys:
                 raise errors.BzrError('Unknown key in inventory: %r\n%r'
                                       % (key, bytes))

=== modified file 'breezy/bzr/serializer.py'
--- breezy/bzr/serializer.py	2018-11-11 04:08:32 +0000
+++ breezy/bzr/serializer.py	2020-01-30 16:35:32 +0000
@@ -34,26 +34,35 @@
         """
         raise NotImplementedError(self.write_inventory)
 
-    def write_inventory_to_string(self, inv):
-        """Produce a simple string representation of an inventory.
-
-        Note: this is a *whole inventory* operation, and should only be used
-        sparingly, as it does not scale well with large trees.
-
-        The requirement for the contents of the string is that it can be passed
-        to read_inventory_from_string and the result is an identical inventory
-        in memory.
-
-        (All serializers as of 2009-07-29 produce XML, but this is not mandated
-        by the interface.)
-        """
-        raise NotImplementedError(self.write_inventory_to_string)
-
-    def read_inventory_from_string(self, string, revision_id=None,
-                                   entry_cache=None, return_from_cache=False):
-        """Read string into an inventory object.
-
-        :param string: The serialized inventory to read.
+    def write_inventory_to_chunks(self, inv):
+        """Produce a simple bytestring chunk representation of an inventory.
+
+        Note: this is a *whole inventory* operation, and should only be used
+        sparingly, as it does not scale well with large trees.
+
+        The requirement for the contents of the string is that it can be passed
+        to read_inventory_from_lines and the result is an identical inventory
+        in memory.
+        """
+        raise NotImplementedError(self.write_inventory_to_chunks)
+
+    def write_inventory_to_lines(self, inv):
+        """Produce a simple lines representation of an inventory.
+
+        Note: this is a *whole inventory* operation, and should only be used
+        sparingly, as it does not scale well with large trees.
+
+        The requirement for the contents of the string is that it can be passed
+        to read_inventory_from_lines and the result is an identical inventory
+        in memory.
+        """
+        raise NotImplementedError(self.write_inventory_to_lines)
+
+    def read_inventory_from_lines(self, lines, revision_id=None,
+                                  entry_cache=None, return_from_cache=False):
+        """Read bytestring chunks into an inventory object.
+
+        :param lines: The serialized inventory to read.
         :param revision_id: If not-None, the expected revision id of the
             inventory. Some serialisers use this to set the results' root
             revision. This should be supplied for deserialising all
@@ -69,10 +78,10 @@
             promises not to mutate the returned inventory entries, but it can
             make some operations significantly faster.
         """
-        raise NotImplementedError(self.read_inventory_from_string)
+        raise NotImplementedError(self.read_inventory_from_lines)
 
     def read_inventory(self, f, revision_id=None):
-        """See read_inventory_from_string."""
+        """See read_inventory_from_lines."""
         raise NotImplementedError(self.read_inventory)
 
     def write_revision(self, rev, f):

=== modified file 'breezy/bzr/vf_repository.py'
--- breezy/bzr/vf_repository.py	2020-01-25 14:58:19 +0000
+++ breezy/bzr/vf_repository.py	2020-01-30 16:35:32 +0000
@@ -854,7 +854,7 @@
         if kind == 'inventories':
             rev_id = record.key[0]
             inv = self._deserialise_inventory(
-                rev_id, record.get_bytes_as('fulltext'))
+                rev_id, record.get_bytes_as('lines'))
             if last_object is not None:
                 delta = inv._make_delta(last_object)
                 for old_path, path, file_id, ie in delta:
@@ -1469,11 +1469,11 @@
     def _iter_inventories(self, revision_ids, ordering):
         """single-document based inventory iteration."""
         inv_xmls = self._iter_inventory_xmls(revision_ids, ordering)
-        for text, revision_id in inv_xmls:
-            if text is None:
+        for lines, revision_id in inv_xmls:
+            if lines is None:
                 yield None, revision_id
             else:
-                yield self._deserialise_inventory(revision_id, text), revision_id
+                yield self._deserialise_inventory(revision_id, lines), revision_id
 
     def _iter_inventory_xmls(self, revision_ids, ordering):
         if ordering is None:
@@ -1488,21 +1488,21 @@
             key_iter = iter(keys)
             next_key = next(key_iter)
         stream = self.inventories.get_record_stream(keys, ordering, True)
-        text_chunks = {}
+        text_lines = {}
         for record in stream:
             if record.storage_kind != 'absent':
-                chunks = record.get_bytes_as('chunked')
+                lines = record.get_bytes_as('lines')
                 if order_as_requested:
-                    text_chunks[record.key] = chunks
+                    text_lines[record.key] = lines
                 else:
-                    yield b''.join(chunks), record.key[-1]
+                    yield lines, record.key[-1]
             else:
                 yield None, record.key[-1]
             if order_as_requested:
                 # Yield as many results as we can while preserving order.
-                while next_key in text_chunks:
-                    chunks = text_chunks.pop(next_key)
-                    yield b''.join(chunks), next_key[-1]
+                while next_key in text_lines:
+                    lines = text_lines.pop(next_key)
+                    yield lines, next_key[-1]
                     try:
                         next_key = next(key_iter)
                     except StopIteration:
@@ -1517,9 +1517,9 @@
         :param revision_id: The expected revision id of the inventory.
         :param xml: A serialised inventory.
         """
-        result = self._serializer.read_inventory_from_string(xml, revision_id,
-                                                             entry_cache=self._inventory_entry_cache,
-                                                             return_from_cache=self._safe_to_return_from_cache)
+        result = self._serializer.read_inventory_from_lines(
+            xml, revision_id, entry_cache=self._inventory_entry_cache,
+            return_from_cache=self._safe_to_return_from_cache)
         if result.revision_id != revision_id:
             raise AssertionError('revision id mismatch %s != %s' % (
                 result.revision_id, revision_id))
@@ -1532,10 +1532,10 @@
         """Get serialized inventory as a string."""
         with self.lock_read():
             texts = self._iter_inventory_xmls([revision_id], 'unordered')
-            text, revision_id = next(texts)
-            if text is None:
+            lines, revision_id = next(texts)
+            if lines is None:
                 raise errors.NoSuchRevision(self, revision_id)
-            return text
+            return lines
 
     def revision_tree(self, revision_id):
         """Return Tree for a revision on this branch.
@@ -1963,9 +1963,9 @@
         for record in substream:
             # It's not a delta, so it must be a fulltext in the source
             # serializer's format.
-            bytes = record.get_bytes_as('fulltext')
+            lines = record.get_bytes_as('lines')
             revision_id = record.key[0]
-            inv = serializer.read_inventory_from_string(bytes, revision_id)
+            inv = serializer.read_inventory_from_lines(lines, revision_id)
             parents = [key[0] for key in record.parents]
             self.target_repo.add_inventory(revision_id, inv, parents)
             # No need to keep holding this full inv in memory when the rest of

=== modified file 'breezy/bzr/workingtree.py'
--- breezy/bzr/workingtree.py	2020-01-19 03:22:04 +0000
+++ breezy/bzr/workingtree.py	2020-01-30 16:35:32 +0000
@@ -303,7 +303,7 @@
     def _write_basis_inventory(self, xml):
         """Write the basis inventory XML to the basis-inventory file"""
         path = self._basis_inventory_name()
-        sio = BytesIO(xml)
+        sio = BytesIO(b''.join(xml))
         self._transport.put_file(path, sio,
                                  mode=self.controldir._get_file_mode())
 
@@ -548,14 +548,14 @@
             # revision_id is set. We must check for this full string, because a
             # root node id can legitimately look like 'revision_id' but cannot
             # contain a '"'.
-            xml = self.branch.repository._get_inventory_xml(new_revision)
-            firstline = xml.split(b'\n', 1)[0]
+            lines = self.branch.repository._get_inventory_xml(new_revision)
+            firstline = lines[0]
             if (b'revision_id="' not in firstline
                     or b'format="7"' not in firstline):
-                inv = self.branch.repository._serializer.read_inventory_from_string(
-                    xml, new_revision)
-                xml = self._create_basis_xml_from_inventory(new_revision, inv)
-            self._write_basis_inventory(xml)
+                inv = self.branch.repository._serializer.read_inventory_from_lines(
+                    lines, new_revision)
+                lines = self._create_basis_xml_from_inventory(new_revision, inv)
+            self._write_basis_inventory(lines)
         except (errors.NoSuchRevision, errors.RevisionNotPresent):
             pass
 
@@ -565,7 +565,7 @@
     def _create_basis_xml_from_inventory(self, revision_id, inventory):
         """Create the text that will be saved in basis-inventory"""
         inventory.revision_id = revision_id
-        return xml7.serializer_v7.write_inventory_to_string(inventory)
+        return xml7.serializer_v7.write_inventory_to_lines(inventory)
 
     def set_conflicts(self, conflicts):
         with self.lock_tree_write():
@@ -641,7 +641,7 @@
     def read_basis_inventory(self):
         """Read the cached basis inventory."""
         path = self._basis_inventory_name()
-        return self._transport.get_bytes(path)
+        return osutils.split_lines(self._transport.get_bytes(path))
 
     def read_working_inventory(self):
         """Read the working inventory.
@@ -801,12 +801,12 @@
         """See WorkingTree.revision_id."""
         if revision_id == self.last_revision():
             try:
-                xml = self.read_basis_inventory()
+                xml_lines = self.read_basis_inventory()
             except errors.NoSuchFile:
                 pass
             else:
                 try:
-                    inv = xml7.serializer_v7.read_inventory_from_string(xml)
+                    inv = xml7.serializer_v7.read_inventory_from_lines(xml_lines)
                     # dont use the repository revision_tree api because we want
                     # to supply the inventory.
                     if inv.revision_id == revision_id:

=== modified file 'breezy/bzr/xml8.py'
--- breezy/bzr/xml8.py	2018-11-16 11:37:47 +0000
+++ breezy/bzr/xml8.py	2020-01-30 16:35:32 +0000
@@ -134,15 +134,8 @@
         """Return a list of lines with the encoded inventory."""
         return self.write_inventory(inv, None)
 
-    def write_inventory_to_string(self, inv, working=False):
-        """Just call write_inventory with a BytesIO and return the value.
-
-        :param working: If True skip history data - text_sha1, text_size,
-            reference_revision, symlink_target.
-        """
-        sio = BytesIO()
-        self.write_inventory(inv, sio, working)
-        return sio.getvalue()
+    def write_inventory_to_chunks(self, inv):
+        return self.write_inventory(inv, None)
 
     def write_inventory(self, inv, f, working=False):
         """Write inventory to a file.

=== modified file 'breezy/bzr/xml_serializer.py'
--- breezy/bzr/xml_serializer.py	2019-02-14 05:21:21 +0000
+++ breezy/bzr/xml_serializer.py	2020-01-30 16:35:32 +0000
@@ -28,7 +28,7 @@
 
 try:
     import xml.etree.cElementTree as elementtree
-    ParseError = getattr(elementtree, "ParseError", SyntaxError)
+    from xml.etree.ElementTree import ParseError
 except ImportError:
     # Fall back to pure python implementation if C extension is unavailable
     import xml.etree.ElementTree as elementtree
@@ -37,9 +37,11 @@
     except ImportError:
         from xml.parsers.expat import ExpatError as ParseError
 
-(ElementTree, SubElement, Element, fromstring, tostring) = (
+(ElementTree, SubElement, Element, fromstringlist, tostringlist, tostring,
+ fromstring) = (
     elementtree.ElementTree, elementtree.SubElement, elementtree.Element,
-    elementtree.fromstring, elementtree.tostring)
+    elementtree.fromstringlist, elementtree.tostringlist, elementtree.tostring,
+    elementtree.fromstring)
 
 
 from .. import (
@@ -59,11 +61,11 @@
 
     squashes_xml_invalid_characters = True
 
-    def read_inventory_from_string(self, xml_string, revision_id=None,
-                                   entry_cache=None, return_from_cache=False):
+    def read_inventory_from_lines(self, lines, revision_id=None,
+                                  entry_cache=None, return_from_cache=False):
         """Read xml_string into an inventory object.
 
-        :param xml_string: The xml to read.
+        :param chunks: The xml to read.
         :param revision_id: If not-None, the expected revision id of the
             inventory. Some serialisers use this to set the results' root
             revision. This should be supplied for deserialising all
@@ -80,7 +82,7 @@
             make some operations significantly faster.
         """
         try:
-            return self._unpack_inventory(fromstring(xml_string), revision_id,
+            return self._unpack_inventory(fromstringlist(lines), revision_id,
                                           entry_cache=entry_cache,
                                           return_from_cache=return_from_cache)
         except ParseError as e:

=== modified file 'breezy/plugins/weave_fmt/bzrdir.py'
--- breezy/plugins/weave_fmt/bzrdir.py	2019-10-19 23:18:56 +0000
+++ breezy/plugins/weave_fmt/bzrdir.py	2020-01-30 16:35:32 +0000
@@ -18,6 +18,8 @@
 
 from __future__ import absolute_import
 
+from io import BytesIO
+
 from ...bzr.bzrdir import (
     BzrDir,
     BzrDirFormat,
@@ -311,9 +313,9 @@
     def _convert_working_inv(self):
         inv = xml4.serializer_v4.read_inventory(
             self.branch._transport.get('inventory'))
-        new_inv_xml = xml5.serializer_v5.write_inventory_to_string(
-            inv, working=True)
-        self.branch._transport.put_bytes('inventory', new_inv_xml,
+        f = BytesIO()
+        xml5.serializer_v5.write_inventory(inv, f, working=True)
+        self.branch._transport.put_bytes('inventory', f.getvalue(),
                                          mode=self.controldir._get_file_mode())
 
     def _write_all_weaves(self):
@@ -382,15 +384,14 @@
 
     def _load_old_inventory(self, rev_id):
         with self.branch.repository.inventory_store.get(rev_id) as f:
-            old_inv_xml = f.read()
-        inv = xml4.serializer_v4.read_inventory_from_string(old_inv_xml)
+            inv = xml4.serializer_v4.read_inventory(f)
         inv.revision_id = rev_id
         rev = self.revisions[rev_id]
         return inv
 
     def _load_updated_inventory(self, rev_id):
-        inv_xml = self.inv_weave.get_text(rev_id)
-        inv = xml5.serializer_v5.read_inventory_from_string(inv_xml, rev_id)
+        inv_xml = self.inv_weave.get_lines(rev_id)
+        inv = xml5.serializer_v5.read_inventory_from_lines(inv_xml, rev_id)
         return inv
 
     def _convert_one_rev(self, rev_id):
@@ -404,11 +405,11 @@
         self.converted_revs.add(rev_id)
 
     def _store_new_inv(self, rev, inv, present_parents):
-        new_inv_xml = xml5.serializer_v5.write_inventory_to_string(inv)
-        new_inv_sha1 = osutils.sha_string(new_inv_xml)
+        new_inv_xml = xml5.serializer_v5.write_inventory_to_lines(inv)
+        new_inv_sha1 = osutils.sha_strings(new_inv_xml)
         self.inv_weave.add_lines(rev.revision_id,
                                  present_parents,
-                                 new_inv_xml.splitlines(True))
+                                 new_inv_xml)
         rev.inventory_sha1 = new_inv_sha1
 
     def _convert_revision_contents(self, rev, inv, present_parents):

=== modified file 'breezy/tests/per_pack_repository.py'
--- breezy/tests/per_pack_repository.py	2019-12-23 03:04:00 +0000
+++ breezy/tests/per_pack_repository.py	2020-01-30 16:35:32 +0000
@@ -786,8 +786,8 @@
         same_repo.resume_write_group(wg_tokens)
         self.assertEqual([key], list(same_repo.chk_bytes.keys()))
         self.assertEqual(
-            text, next(same_repo.chk_bytes.get_record_stream([key],
-                                                             'unordered', True)).get_bytes_as('fulltext'))
+            text, next(same_repo.chk_bytes.get_record_stream(
+                [key], 'unordered', True)).get_bytes_as('fulltext'))
         same_repo.abort_write_group()
         self.assertEqual([], list(same_repo.chk_bytes.keys()))
 

=== modified file 'breezy/tests/per_repository_reference/test_fetch.py'
--- breezy/tests/per_repository_reference/test_fetch.py	2018-11-11 04:08:32 +0000
+++ breezy/tests/per_repository_reference/test_fetch.py	2020-01-30 16:35:32 +0000
@@ -74,8 +74,8 @@
         self.assertEqual(b'C-id', final_b.last_revision())
         text_keys = [(b'a-id', b'A-id'), (b'a-id', b'B-id'),
                      (b'a-id', b'C-id')]
-        stream = final_b.repository.texts.get_record_stream(text_keys,
-                                                            'unordered', True)
+        stream = final_b.repository.texts.get_record_stream(
+            text_keys, 'unordered', True)
         records = sorted([(r.key, r.get_bytes_as('fulltext')) for r in stream])
         self.assertEqual([
             ((b'a-id', b'A-id'), b''.join(content[:-2])),

=== modified file 'breezy/tests/per_workingtree/test_basis_inventory.py'
--- breezy/tests/per_workingtree/test_basis_inventory.py	2018-11-11 04:08:32 +0000
+++ breezy/tests/per_workingtree/test_basis_inventory.py	2020-01-30 16:35:32 +0000
@@ -58,9 +58,9 @@
 
         self.assertTrue(t._transport.has('basis-inventory-cache'))
 
-        basis_inv_txt = t.read_basis_inventory()
-        basis_inv = breezy.bzr.xml7.serializer_v7.read_inventory_from_string(
-            basis_inv_txt)
+        basis_inv_lines = t.read_basis_inventory()
+        basis_inv = breezy.bzr.xml7.serializer_v7.read_inventory_from_lines(
+            basis_inv_lines)
         self.assertEqual(r2, basis_inv.revision_id)
         store_inv = b.repository.get_inventory(r2)
 

=== modified file 'breezy/tests/test_bundle.py'
--- breezy/tests/test_bundle.py	2020-01-19 13:47:29 +0000
+++ breezy/tests/test_bundle.py	2020-01-30 16:35:32 +0000
@@ -1036,7 +1036,7 @@
         bundle = read_bundle(self.create_bundle_text(b'null:', b'rev2')[0])
         repo = self.make_repository('repo', format='dirstate-with-subtree')
         bundle.install_revisions(repo)
-        inv_text = repo._get_inventory_xml(b'rev2')
+        inv_text = b''.join(repo._get_inventory_xml(b'rev2'))
         self.assertNotContainsRe(inv_text, b'format="5"')
         self.assertContainsRe(inv_text, b'format="7"')
 
@@ -1063,7 +1063,7 @@
     def test_inv_hash_across_serializers(self):
         repo = self.make_repo_with_installed_revisions()
         recorded_inv_sha1 = repo.get_revision(b'rev2').inventory_sha1
-        xml = repo._get_inventory_xml(b'rev2')
+        xml = b''.join(repo._get_inventory_xml(b'rev2'))
         self.assertEqual(osutils.sha_string(xml), recorded_inv_sha1)
 
     def test_across_models_incompatible(self):

=== modified file 'breezy/tests/test_inv.py'
--- breezy/tests/test_inv.py	2019-05-29 03:22:34 +0000
+++ breezy/tests/test_inv.py	2020-01-30 16:35:32 +0000
@@ -861,8 +861,8 @@
         inv.root.revision = b"rootrev"
         chk_bytes = self.get_chk_bytes()
         chk_inv = CHKInventory.from_inventory(chk_bytes, inv)
-        bytes = b''.join(chk_inv.to_lines())
-        new_inv = CHKInventory.deserialise(chk_bytes, bytes, (b"revid",))
+        lines = chk_inv.to_lines()
+        new_inv = CHKInventory.deserialise(chk_bytes, lines, (b"revid",))
         self.assertEqual(b"revid", new_inv.revision_id)
         self.assertEqual("directory", new_inv.root.kind)
         self.assertEqual(inv.root.file_id, new_inv.root.file_id)
@@ -877,9 +877,9 @@
         inv.root.revision = b"rootrev"
         chk_bytes = self.get_chk_bytes()
         chk_inv = CHKInventory.from_inventory(chk_bytes, inv)
-        bytes = b''.join(chk_inv.to_lines())
+        lines = chk_inv.to_lines()
         self.assertRaises(ValueError, CHKInventory.deserialise, chk_bytes,
-                          bytes, (b"revid2",))
+                          lines, (b"revid2",))
 
     def test_captures_rev_root_byid(self):
         inv = Inventory()
@@ -896,7 +896,7 @@
             b'id_to_entry: sha1:debfe920f1f10e7929260f0534ac9a24d7aabbb4\n',
             ], lines)
         chk_inv = CHKInventory.deserialise(
-            chk_bytes, b''.join(lines), (b'foo',))
+            chk_bytes, lines, (b'foo',))
         self.assertEqual(b'plain', chk_inv._search_key_name)
 
     def test_captures_parent_id_basename_index(self):
@@ -914,7 +914,7 @@
             b'id_to_entry: sha1:debfe920f1f10e7929260f0534ac9a24d7aabbb4\n',
             ], lines)
         chk_inv = CHKInventory.deserialise(
-            chk_bytes, b''.join(lines), (b'foo',))
+            chk_bytes, lines, (b'foo',))
         self.assertEqual(b'plain', chk_inv._search_key_name)
 
     def test_captures_search_key_name(self):
@@ -934,7 +934,7 @@
             b'id_to_entry: sha1:debfe920f1f10e7929260f0534ac9a24d7aabbb4\n',
             ], lines)
         chk_inv = CHKInventory.deserialise(
-            chk_bytes, b''.join(lines), (b'foo',))
+            chk_bytes, lines, (b'foo',))
         self.assertEqual(b'hash-16-way', chk_inv._search_key_name)
 
     def test_directory_children_on_demand(self):
@@ -948,8 +948,8 @@
         inv.get_entry(b"fileid").text_size = 1
         chk_bytes = self.get_chk_bytes()
         chk_inv = CHKInventory.from_inventory(chk_bytes, inv)
-        bytes = b''.join(chk_inv.to_lines())
-        new_inv = CHKInventory.deserialise(chk_bytes, bytes, (b"revid",))
+        lines = chk_inv.to_lines()
+        new_inv = CHKInventory.deserialise(chk_bytes, lines, (b"revid",))
         root_entry = new_inv.get_entry(inv.root.file_id)
         self.assertEqual(None, root_entry._children)
         self.assertEqual({'file'}, set(root_entry.children))
@@ -990,8 +990,8 @@
         inv.get_entry(b"fileid").text_size = 1
         chk_bytes = self.get_chk_bytes()
         chk_inv = CHKInventory.from_inventory(chk_bytes, inv)
-        bytes = b''.join(chk_inv.to_lines())
-        new_inv = CHKInventory.deserialise(chk_bytes, bytes, (b"revid",))
+        lines = chk_inv.to_lines()
+        new_inv = CHKInventory.deserialise(chk_bytes, lines, (b"revid",))
         fileids = sorted(new_inv.iter_all_ids())
         self.assertEqual([inv.root.file_id, b"fileid"], fileids)
 
@@ -1019,8 +1019,8 @@
         inv.get_entry(b"fileid").text_size = 1
         chk_bytes = self.get_chk_bytes()
         chk_inv = CHKInventory.from_inventory(chk_bytes, inv)
-        data = b''.join(chk_inv.to_lines())
-        new_inv = CHKInventory.deserialise(chk_bytes, data, (b"revid",))
+        lines = chk_inv.to_lines()
+        new_inv = CHKInventory.deserialise(chk_bytes, lines, (b"revid",))
         root_entry = new_inv.get_entry(inv.root.file_id)
         file_entry = new_inv.get_entry(b"fileid")
         self.assertEqual("directory", root_entry.kind)
@@ -1075,8 +1075,8 @@
         inv.get_entry(b"dirid").revision = b"filerev"
         chk_bytes = self.get_chk_bytes()
         chk_inv = CHKInventory.from_inventory(chk_bytes, inv)
-        bytes = b''.join(chk_inv.to_lines())
-        new_inv = CHKInventory.deserialise(chk_bytes, bytes, (b"revid",))
+        lines = chk_inv.to_lines()
+        new_inv = CHKInventory.deserialise(chk_bytes, lines, (b"revid",))
         self.assertEqual('', new_inv.id2path(inv.root.file_id))
         self.assertEqual('dir', new_inv.id2path(b'dirid'))
         self.assertEqual('dir/file', new_inv.id2path(b'fileid'))
@@ -1096,8 +1096,8 @@
         inv.get_entry(b"dirid").revision = b"filerev"
         chk_bytes = self.get_chk_bytes()
         chk_inv = CHKInventory.from_inventory(chk_bytes, inv)
-        bytes = b''.join(chk_inv.to_lines())
-        new_inv = CHKInventory.deserialise(chk_bytes, bytes, (b"revid",))
+        lines = chk_inv.to_lines()
+        new_inv = CHKInventory.deserialise(chk_bytes, lines, (b"revid",))
         self.assertEqual(inv.root.file_id, new_inv.path2id(''))
         self.assertEqual(b'dirid', new_inv.path2id('dir'))
         self.assertEqual(b'fileid', new_inv.path2id('dir/file'))
@@ -1191,11 +1191,11 @@
         # get fresh objects.
         chk_bytes = self.get_chk_bytes()
         chk_inv = CHKInventory.from_inventory(chk_bytes, inv)
-        bytes = b''.join(chk_inv.to_lines())
-        inv_1 = CHKInventory.deserialise(chk_bytes, bytes, (b"revid",))
+        lines = chk_inv.to_lines()
+        inv_1 = CHKInventory.deserialise(chk_bytes, lines, (b"revid",))
         chk_inv2 = CHKInventory.from_inventory(chk_bytes, inv2)
-        bytes = b''.join(chk_inv2.to_lines())
-        inv_2 = CHKInventory.deserialise(chk_bytes, bytes, (b"revid2",))
+        lines = chk_inv2.to_lines()
+        inv_2 = CHKInventory.deserialise(chk_bytes, lines, (b"revid2",))
         self.assertEqual([(b'fileid', (u'file', u'file'), True, (True, True),
                            (b'TREE_ROOT', b'TREE_ROOT'), (u'file',
                                                           u'file'), ('file', 'file'),
@@ -1214,8 +1214,8 @@
         # get fresh objects.
         chk_bytes = self.get_chk_bytes()
         tmp_inv = CHKInventory.from_inventory(chk_bytes, inv)
-        bytes = b''.join(tmp_inv.to_lines())
-        chk_inv = CHKInventory.deserialise(chk_bytes, bytes, (b"revid",))
+        lines = tmp_inv.to_lines()
+        chk_inv = CHKInventory.deserialise(chk_bytes, lines, (b"revid",))
         self.assertIsInstance(
             chk_inv.parent_id_basename_to_file_id, chk_map.CHKMap)
         self.assertEqual(
@@ -1345,8 +1345,8 @@
         inv.get_entry(b"childid").text_size = 0
         chk_bytes = self.get_chk_bytes()
         chk_inv = CHKInventory.from_inventory(chk_bytes, inv)
-        bytes = b''.join(chk_inv.to_lines())
-        return CHKInventory.deserialise(chk_bytes, bytes, (b"revid",))
+        lines = chk_inv.to_lines()
+        return CHKInventory.deserialise(chk_bytes, lines, (b"revid",))
 
     def test__preload_handles_utf8(self):
         new_inv = self.make_basic_utf8_inventory()
@@ -1381,8 +1381,8 @@
         inv.get_entry(b"childid").text_size = 1
         chk_bytes = self.get_chk_bytes()
         chk_inv = CHKInventory.from_inventory(chk_bytes, inv)
-        bytes = b''.join(chk_inv.to_lines())
-        new_inv = CHKInventory.deserialise(chk_bytes, bytes, (b"revid",))
+        lines = chk_inv.to_lines()
+        new_inv = CHKInventory.deserialise(chk_bytes, lines, (b"revid",))
         self.assertEqual({}, new_inv._fileid_to_entry_cache)
         self.assertFalse(new_inv._fully_cached)
         new_inv._preload_cache()
@@ -1485,8 +1485,8 @@
         chk_inv = CHKInventory.from_inventory(chk_bytes, inv,
                                               maximum_size=100,
                                               search_key_name=b'hash-255-way')
-        bytes = b''.join(chk_inv.to_lines())
-        return CHKInventory.deserialise(chk_bytes, bytes, (b"revid",))
+        lines = chk_inv.to_lines()
+        return CHKInventory.deserialise(chk_bytes, lines, (b"revid",))
 
     def assert_Getitems(self, expected_fileids, inv, file_ids):
         self.assertEqual(sorted(expected_fileids),

=== modified file 'breezy/tests/test_remote.py'
--- breezy/tests/test_remote.py	2020-01-19 14:49:03 +0000
+++ breezy/tests/test_remote.py	2020-01-30 16:35:32 +0000
@@ -3536,9 +3536,9 @@
 
         def inventories_substream():
             # An empty inventory fulltext.  This will be streamed normally.
-            text = fmt._serializer.write_inventory_to_string(inv)
-            yield versionedfile.FulltextContentFactory(
-                (b'rev1',), (), None, text)
+            chunks = fmt._serializer.write_inventory_to_lines(inv)
+            yield versionedfile.ChunkedContentFactory(
+                (b'rev1',), (), None, chunks, chunks_are_lines=True)
 
         def inventory_delta_substream():
             # An inventory delta.  This can't be streamed via this verb, so it

=== modified file 'breezy/tests/test_repository.py'
--- breezy/tests/test_repository.py	2018-11-16 18:40:46 +0000
+++ breezy/tests/test_repository.py	2020-01-30 16:35:32 +0000
@@ -329,7 +329,7 @@
         repo = self.make_repository(
             '.', format=controldir.format_registry.get('knit')())
         inv_xml = b'<inventory format="5">\n</inventory>\n'
-        inv = repo._deserialise_inventory(b'test-rev-id', inv_xml)
+        inv = repo._deserialise_inventory(b'test-rev-id', [inv_xml])
         self.assertEqual(b'test-rev-id', inv.root.revision)
 
     def test_deserialise_uses_global_revision_id(self):
@@ -342,8 +342,8 @@
         # raise an error, rather than silently using one revision_id over the
         # other.
         self.assertRaises(AssertionError, repo._deserialise_inventory,
-                          b'test-rev-id', inv_xml)
-        inv = repo._deserialise_inventory(b'other-rev-id', inv_xml)
+                          b'test-rev-id', [inv_xml])
+        inv = repo._deserialise_inventory(b'other-rev-id', [inv_xml])
         self.assertEqual(b'other-rev-id', inv.root.revision)
 
     def test_supports_external_lookups(self):

=== modified file 'breezy/tests/test_xml.py'
--- breezy/tests/test_xml.py	2019-02-14 05:21:21 +0000
+++ breezy/tests/test_xml.py	2020-01-30 16:35:32 +0000
@@ -236,8 +236,8 @@
 
     def test_unpack_basis_inventory_5(self):
         """Unpack canned new-style inventory"""
-        inp = BytesIO(_basis_inv_v5)
-        inv = breezy.bzr.xml5.serializer_v5.read_inventory(inp)
+        inv = breezy.bzr.xml5.serializer_v5.read_inventory_from_lines(
+            breezy.osutils.split_lines(_basis_inv_v5))
         eq = self.assertEqual
         eq(len(inv), 4)
         eq(inv.revision_id,
@@ -249,8 +249,8 @@
         eq(inv.get_entry(ie.parent_id).kind, 'directory')
 
     def test_unpack_inventory_5a(self):
-        inv = breezy.bzr.xml5.serializer_v5.read_inventory_from_string(
-            _inventory_v5a, revision_id=b'test-rev-id')
+        inv = breezy.bzr.xml5.serializer_v5.read_inventory_from_lines(
+            breezy.osutils.split_lines(_inventory_v5a), revision_id=b'test-rev-id')
         self.assertEqual(b'test-rev-id', inv.root.revision)
 
     def test_unpack_inventory_5a_cache_and_copy(self):
@@ -258,8 +258,8 @@
         # But the returned objects should be copies if return_from_cache is
         # False
         entry_cache = fifo_cache.FIFOCache()
-        inv = breezy.bzr.xml5.serializer_v5.read_inventory_from_string(
-            _inventory_v5a, revision_id=b'test-rev-id',
+        inv = breezy.bzr.xml5.serializer_v5.read_inventory_from_lines(
+            breezy.osutils.split_lines(_inventory_v5a), revision_id=b'test-rev-id',
             entry_cache=entry_cache, return_from_cache=False)
         for entry in inv.iter_just_entries():
             key = (entry.file_id, entry.revision)
@@ -274,8 +274,8 @@
         # The returned objects should be exact if return_from_cache is
         # True
         entry_cache = fifo_cache.FIFOCache()
-        inv = breezy.bzr.xml5.serializer_v5.read_inventory_from_string(
-            _inventory_v5a, revision_id=b'test-rev-id',
+        inv = breezy.bzr.xml5.serializer_v5.read_inventory_from_lines(
+            breezy.osutils.split_lines(_inventory_v5a), revision_id=b'test-rev-id',
             entry_cache=entry_cache, return_from_cache=True)
         for entry in inv.iter_just_entries():
             key = (entry.file_id, entry.revision)
@@ -286,18 +286,18 @@
                 self.assertIs(entry, entry_cache[key])
 
     def test_unpack_inventory_5b(self):
-        inv = breezy.bzr.xml5.serializer_v5.read_inventory_from_string(
-            _inventory_v5b, revision_id=b'test-rev-id')
+        inv = breezy.bzr.xml5.serializer_v5.read_inventory_from_lines(
+            breezy.osutils.split_lines(_inventory_v5b), revision_id=b'test-rev-id')
         self.assertEqual(b'a-rev-id', inv.root.revision)
 
     def test_repack_inventory_5(self):
-        inp = BytesIO(_committed_inv_v5)
-        inv = breezy.bzr.xml5.serializer_v5.read_inventory(inp)
+        inv = breezy.bzr.xml5.serializer_v5.read_inventory_from_lines(
+            breezy.osutils.split_lines(_committed_inv_v5))
         outp = BytesIO()
         breezy.bzr.xml5.serializer_v5.write_inventory(inv, outp)
         self.assertEqualDiff(_expected_inv_v5, outp.getvalue())
-        inv2 = breezy.bzr.xml5.serializer_v5.read_inventory(
-            BytesIO(outp.getvalue()))
+        inv2 = breezy.bzr.xml5.serializer_v5.read_inventory_from_lines(
+            breezy.osutils.split_lines(outp.getvalue()))
         self.assertEqual(inv, inv2)
 
     def assertRoundTrips(self, xml_string):
@@ -377,22 +377,18 @@
         inv = self.get_sample_inventory()
         inv.add(inventory.TreeReference(b'nested-id', 'nested', b'tree-root-321',
                                         b'rev_outer', b'rev_inner'))
-        txt = xml7.serializer_v7.write_inventory_to_string(inv)
         lines = xml7.serializer_v7.write_inventory_to_lines(inv)
-        self.assertEqual(breezy.osutils.split_lines(txt), lines)
-        self.assertEqualDiff(_expected_inv_v7, txt)
-        inv2 = xml7.serializer_v7.read_inventory_from_string(txt)
+        self.assertEqualDiff(_expected_inv_v7, b''.join(lines))
+        inv2 = xml7.serializer_v7.read_inventory_from_lines(lines)
         self.assertEqual(5, len(inv2))
         for path, ie in inv.iter_entries():
             self.assertEqual(ie, inv2.get_entry(ie.file_id))
 
     def test_roundtrip_inventory_v6(self):
         inv = self.get_sample_inventory()
-        txt = xml6.serializer_v6.write_inventory_to_string(inv)
         lines = xml6.serializer_v6.write_inventory_to_lines(inv)
-        self.assertEqual(breezy.osutils.split_lines(txt), lines)
-        self.assertEqualDiff(_expected_inv_v6, txt)
-        inv2 = xml6.serializer_v6.read_inventory_from_string(txt)
+        self.assertEqualDiff(_expected_inv_v6, b''.join(lines))
+        inv2 = xml6.serializer_v6.read_inventory_from_lines(lines)
         self.assertEqual(4, len(inv2))
         for path, ie in inv.iter_entries():
             self.assertEqual(ie, inv2.get_entry(ie.file_id))
@@ -402,9 +398,11 @@
         s_v6 = breezy.bzr.xml6.serializer_v6
         s_v7 = xml7.serializer_v7
         self.assertRaises(errors.UnexpectedInventoryFormat,
-                          s_v7.read_inventory_from_string, _expected_inv_v5)
+                          s_v7.read_inventory_from_lines,
+                          breezy.osutils.split_lines(_expected_inv_v5))
         self.assertRaises(errors.UnexpectedInventoryFormat,
-                          s_v6.read_inventory_from_string, _expected_inv_v7)
+                          s_v6.read_inventory_from_lines,
+                          breezy.osutils.split_lines(_expected_inv_v7))
 
     def test_tree_reference(self):
         s_v5 = breezy.bzr.xml5.serializer_v5
@@ -415,13 +413,11 @@
         inv.add(inventory.TreeReference(b'nested-id', 'nested', b'tree-root-321',
                                         b'rev-outer', b'rev-inner'))
         self.assertRaises(errors.UnsupportedInventoryKind,
-                          s_v5.write_inventory_to_string, inv)
+                          s_v5.write_inventory_to_lines, inv)
         self.assertRaises(errors.UnsupportedInventoryKind,
-                          s_v6.write_inventory_to_string, inv)
-        txt = s_v7.write_inventory_to_string(inv)
-        lines = s_v7.write_inventory_to_lines(inv)
-        self.assertEqual(breezy.osutils.split_lines(txt), lines)
-        inv2 = s_v7.read_inventory_from_string(txt)
+                          s_v6.write_inventory_to_lines, inv)
+        lines = s_v7.write_inventory_to_chunks(inv)
+        inv2 = s_v7.read_inventory_from_lines(lines)
         self.assertEqual(b'tree-root-321',
                          inv2.get_entry(b'nested-id').parent_id)
         self.assertEqual(b'rev-outer', inv2.get_entry(b'nested-id').revision)
@@ -430,18 +426,16 @@
 
     def test_roundtrip_inventory_v8(self):
         inv = self.get_sample_inventory()
-        txt = xml8.serializer_v8.write_inventory_to_string(inv)
-        inv2 = xml8.serializer_v8.read_inventory_from_string(txt)
+        lines = xml8.serializer_v8.write_inventory_to_lines(inv)
+        inv2 = xml8.serializer_v8.read_inventory_from_lines(lines)
         self.assertEqual(4, len(inv2))
         for path, ie in inv.iter_entries():
             self.assertEqual(ie, inv2.get_entry(ie.file_id))
 
     def test_inventory_text_v8(self):
         inv = self.get_sample_inventory()
-        txt = xml8.serializer_v8.write_inventory_to_string(inv)
         lines = xml8.serializer_v8.write_inventory_to_lines(inv)
-        self.assertEqual(breezy.osutils.split_lines(txt), lines)
-        self.assertEqualDiff(_expected_inv_v8, txt)
+        self.assertEqualDiff(_expected_inv_v8, b''.join(lines))
 
     def test_revision_text_v6(self):
         """Pack revision to XML v6"""
@@ -480,7 +474,7 @@
         self.assertIsInstance(rev.message, text_type)
 
         # ie.revision should either be None or a utf-8 revision id
-        inv = s_v5.read_inventory_from_string(_inventory_utf8_v5)
+        inv = s_v5.read_inventory_from_lines(breezy.osutils.split_lines(_inventory_utf8_v5))
         rev_id_1 = u'erik@b\xe5gfors-01'.encode('utf8')
         rev_id_2 = u'erik@b\xe5gfors-02'.encode('utf8')
         fid_root = u'TRE\xe9_ROOT'.encode('utf8')
@@ -515,7 +509,7 @@
         s_v5 = breezy.bzr.xml5.serializer_v5
         e = self.assertRaises(
             errors.UnexpectedInventoryFormat,
-            s_v5.read_inventory_from_string, b"<Notquitexml")
+            s_v5.read_inventory_from_lines, [b"<Notquitexml"])
         self.assertEqual(str(e), "unclosed token: line 1, column 0")