Merge lp:~jelmer/brz/misc-foreign3 into lp:~jelmer/brz/foreign

[Jelmer Vernooij]

Avoid specifying revision_id/file_id in a few more cases.

[Martin Packman (gz)]

There are a stack of commits (and some conflicts) in the branch here.

Looking only at the last rev, changes seems good.

review: Approve

=== modified file 'breezy/bzr/bzrdir.py'
--- breezy/bzr/bzrdir.py	2017-11-20 22:56:39 +0000
+++ breezy/bzr/bzrdir.py	2017-11-29 12:08:31 +0000
@@ -305,9 +305,9 @@
                     return policy
             else:
                 try:
-                    return UseExistingRepository(self.open_repository(),
-                        stack_on, stack_on_pwd,
-                        require_stacking=require_stacking)
+                    return UseExistingRepository(
+                            self.open_repository(), stack_on, stack_on_pwd,
+                            require_stacking=require_stacking)
                 except errors.NoRepositoryPresent:
                     pass
         return CreateRepository(self, stack_on, stack_on_pwd,
@@ -1737,14 +1737,22 @@
         except errors.NoRepositoryPresent:
             pass
         else:
-            if not isinstance(repo._format, self.target_format.repository_format.__class__):
+            repo_fmt = self.target_format.repository_format
+            if not isinstance(repo._format, repo_fmt.__class__):
                 from ..repository import CopyConverter
                 ui.ui_factory.note(gettext('starting repository conversion'))
+<<<<<<< TREE
                 if not (self.target_format.
                         repository_format.supports_overriding_transport):
                     raise AssertionError(
                             "Repository in metadir does not support "
                             "overriding transport")
+=======
+                if not repo_fmt.supports_overriding_transport:
+                    raise AssertionError(
+                            "Repository in metadir does not support "
+                            "overriding transport")
+>>>>>>> MERGE-SOURCE
                 converter = CopyConverter(self.target_format.repository_format)
                 converter.convert(repo, pb)
         for branch in self.controldir.list_branches():
@@ -1833,138 +1841,43 @@
         return BzrDir.open_from_transport(to_convert.root_transport)
 
 
-class RepositoryAcquisitionPolicy(object):
-    """Abstract base class for repository acquisition policies.
-
-    A repository acquisition policy decides how a BzrDir acquires a repository
-    for a branch that is being created.  The most basic policy decision is
-    whether to create a new repository or use an existing one.
-    """
-    def __init__(self, stack_on, stack_on_pwd, require_stacking):
-        """Constructor.
-
-        :param stack_on: A location to stack on
-        :param stack_on_pwd: If stack_on is relative, the location it is
-            relative to.
-        :param require_stacking: If True, it is a failure to not stack.
-        """
-        self._stack_on = stack_on
-        self._stack_on_pwd = stack_on_pwd
-        self._require_stacking = require_stacking
-
-    def configure_branch(self, branch):
-        """Apply any configuration data from this policy to the branch.
-
-        Default implementation sets repository stacking.
-        """
-        if self._stack_on is None:
-            return
-        if self._stack_on_pwd is None:
-            stack_on = self._stack_on
-        else:
-            try:
-                stack_on = urlutils.rebase_url(self._stack_on,
-                    self._stack_on_pwd,
-                    branch.user_url)
-            except urlutils.InvalidRebaseURLs:
-                stack_on = self._get_full_stack_on()
-        try:
-            branch.set_stacked_on_url(stack_on)
-        except (_mod_branch.UnstackableBranchFormat,
-                errors.UnstackableRepositoryFormat):
-            if self._require_stacking:
-                raise
-
-    def requires_stacking(self):
-        """Return True if this policy requires stacking."""
-        return self._stack_on is not None and self._require_stacking
-
-    def _get_full_stack_on(self):
-        """Get a fully-qualified URL for the stack_on location."""
-        if self._stack_on is None:
-            return None
-        if self._stack_on_pwd is None:
-            return self._stack_on
-        else:
-            return urlutils.join(self._stack_on_pwd, self._stack_on)
-
-    def _add_fallback(self, repository, possible_transports=None):
-        """Add a fallback to the supplied repository, if stacking is set."""
-        stack_on = self._get_full_stack_on()
-        if stack_on is None:
-            return
-        try:
-            stacked_dir = BzrDir.open(stack_on,
-                                      possible_transports=possible_transports)
-        except errors.JailBreak:
-            # We keep the stacking details, but we are in the server code so
-            # actually stacking is not needed.
-            return
-        try:
-            stacked_repo = stacked_dir.open_branch().repository
-        except errors.NotBranchError:
-            stacked_repo = stacked_dir.open_repository()
-        try:
-            repository.add_fallback_repository(stacked_repo)
-        except errors.UnstackableRepositoryFormat:
-            if self._require_stacking:
-                raise
-        else:
-            self._require_stacking = True
-
-    def acquire_repository(self, make_working_trees=None, shared=False,
-            possible_transports=None):
-        """Acquire a repository for this bzrdir.
-
-        Implementations may create a new repository or use a pre-exising
-        repository.
-
-        :param make_working_trees: If creating a repository, set
-            make_working_trees to this value (if non-None)
-        :param shared: If creating a repository, make it shared if True
-        :return: A repository, is_new_flag (True if the repository was
-            created).
-        """
-        raise NotImplementedError(RepositoryAcquisitionPolicy.acquire_repository)
-
-
-class CreateRepository(RepositoryAcquisitionPolicy):
+class CreateRepository(controldir.RepositoryAcquisitionPolicy):
     """A policy of creating a new repository"""
 
-    def __init__(self, bzrdir, stack_on=None, stack_on_pwd=None,
+    def __init__(self, controldir, stack_on=None, stack_on_pwd=None,
                  require_stacking=False):
         """Constructor.
 
-        :param bzrdir: The bzrdir to create the repository on.
+        :param controldir: The controldir to create the repository on.
         :param stack_on: A location to stack on
         :param stack_on_pwd: If stack_on is relative, the location it is
             relative to.
         """
-        RepositoryAcquisitionPolicy.__init__(self, stack_on, stack_on_pwd,
-                                             require_stacking)
-        self._bzrdir = bzrdir
+        super(CreateRepository, self).__init__(
+                stack_on, stack_on_pwd, require_stacking)
+        self._controldir = controldir
 
     def acquire_repository(self, make_working_trees=None, shared=False,
             possible_transports=None):
         """Implementation of RepositoryAcquisitionPolicy.acquire_repository
 
-        Creates the desired repository in the bzrdir we already have.
+        Creates the desired repository in the controldir we already have.
         """
         if possible_transports is None:
             possible_transports = []
         else:
             possible_transports = list(possible_transports)
-        possible_transports.append(self._bzrdir.root_transport)
+        possible_transports.append(self._controldir.root_transport)
         stack_on = self._get_full_stack_on()
         if stack_on:
-            format = self._bzrdir._format
+            format = self._controldir._format
             format.require_stacking(stack_on=stack_on,
                                     possible_transports=possible_transports)
             if not self._require_stacking:
                 # We have picked up automatic stacking somewhere.
                 note(gettext('Using default stacking branch {0} at {1}').format(
                     self._stack_on, self._stack_on_pwd))
-        repository = self._bzrdir.create_repository(shared=shared)
+        repository = self._controldir.create_repository(shared=shared)
         self._add_fallback(repository,
                            possible_transports=possible_transports)
         if make_working_trees is not None:
@@ -1972,7 +1885,7 @@
         return repository, True
 
 
-class UseExistingRepository(RepositoryAcquisitionPolicy):
+class UseExistingRepository(controldir.RepositoryAcquisitionPolicy):
     """A policy of reusing an existing repository"""
 
     def __init__(self, repository, stack_on=None, stack_on_pwd=None,
@@ -1984,8 +1897,8 @@
         :param stack_on_pwd: If stack_on is relative, the location it is
             relative to.
         """
-        RepositoryAcquisitionPolicy.__init__(self, stack_on, stack_on_pwd,
-                                             require_stacking)
+        super(UseExistingRepository, self).__init__(
+                stack_on, stack_on_pwd, require_stacking)
         self._repository = repository
 
     def acquire_repository(self, make_working_trees=None, shared=False,
 
=== modified file 'breezy/bzr/remote.py'
--- breezy/bzr/remote.py	2017-11-20 22:51:10 +0000
+++ breezy/bzr/remote.py	2017-11-29 12:08:31 +0000
@@ -308,8 +308,8 @@
                     remote_repo.dont_leave_lock_in_place()
             else:
                 remote_repo.lock_write()
-            policy = _mod_bzrdir.UseExistingRepository(remote_repo, final_stack,
-                final_stack_pwd, require_stacking)
+            policy = _mod_bzrdir.UseExistingRepository(remote_repo,
+                    final_stack, final_stack_pwd, require_stacking)
             policy.acquire_repository()
         else:
             remote_repo = None
 
=== modified file 'breezy/bzr/workingtree.py'
--- breezy/bzr/workingtree.py	2017-11-19 18:10:24 +0000
+++ breezy/bzr/workingtree.py	2017-11-29 12:08:31 +0000
@@ -32,9 +32,12 @@
 
 from __future__ import absolute_import
 
+from bisect import bisect_left
 import breezy
 import collections
 import errno
+import itertools
+import operator
 import os
 import stat
 import sys
@@ -1501,6 +1504,127 @@
                 subp = osutils.pathjoin(path, subf)
                 yield subp
 
+    def walkdirs(self, prefix=""):
+        """Walk the directories of this tree.
+
+        returns a generator which yields items in the form:
+                ((curren_directory_path, fileid),
+                 [(file1_path, file1_name, file1_kind, (lstat), file1_id,
+                   file1_kind), ... ])
+
+        This API returns a generator, which is only valid during the current
+        tree transaction - within a single lock_read or lock_write duration.
+
+        If the tree is not locked, it may cause an error to be raised,
+        depending on the tree implementation.
+        """
+        disk_top = self.abspath(prefix)
+        if disk_top.endswith('/'):
+            disk_top = disk_top[:-1]
+        top_strip_len = len(disk_top) + 1
+        inventory_iterator = self._walkdirs(prefix)
+        disk_iterator = osutils.walkdirs(disk_top, prefix)
+        try:
+            current_disk = next(disk_iterator)
+            disk_finished = False
+        except OSError as e:
+            if not (e.errno == errno.ENOENT or
+                (sys.platform == 'win32' and e.errno == ERROR_PATH_NOT_FOUND)):
+                raise
+            current_disk = None
+            disk_finished = True
+        try:
+            current_inv = next(inventory_iterator)
+            inv_finished = False
+        except StopIteration:
+            current_inv = None
+            inv_finished = True
+        while not inv_finished or not disk_finished:
+            if current_disk:
+                ((cur_disk_dir_relpath, cur_disk_dir_path_from_top),
+                    cur_disk_dir_content) = current_disk
+            else:
+                ((cur_disk_dir_relpath, cur_disk_dir_path_from_top),
+                    cur_disk_dir_content) = ((None, None), None)
+            if not disk_finished:
+                # strip out .bzr dirs
+                if (cur_disk_dir_path_from_top[top_strip_len:] == '' and
+                    len(cur_disk_dir_content) > 0):
+                    # osutils.walkdirs can be made nicer -
+                    # yield the path-from-prefix rather than the pathjoined
+                    # value.
+                    bzrdir_loc = bisect_left(cur_disk_dir_content,
+                        ('.bzr', '.bzr'))
+                    if (bzrdir_loc < len(cur_disk_dir_content)
+                        and self.controldir.is_control_filename(
+                            cur_disk_dir_content[bzrdir_loc][0])):
+                        # we dont yield the contents of, or, .bzr itself.
+                        del cur_disk_dir_content[bzrdir_loc]
+            if inv_finished:
+                # everything is unknown
+                direction = 1
+            elif disk_finished:
+                # everything is missing
+                direction = -1
+            else:
+                direction = cmp(current_inv[0][0], cur_disk_dir_relpath)
+            if direction > 0:
+                # disk is before inventory - unknown
+                dirblock = [(relpath, basename, kind, stat, None, None) for
+                    relpath, basename, kind, stat, top_path in
+                    cur_disk_dir_content]
+                yield (cur_disk_dir_relpath, None), dirblock
+                try:
+                    current_disk = next(disk_iterator)
+                except StopIteration:
+                    disk_finished = True
+            elif direction < 0:
+                # inventory is before disk - missing.
+                dirblock = [(relpath, basename, 'unknown', None, fileid, kind)
+                    for relpath, basename, dkind, stat, fileid, kind in
+                    current_inv[1]]
+                yield (current_inv[0][0], current_inv[0][1]), dirblock
+                try:
+                    current_inv = next(inventory_iterator)
+                except StopIteration:
+                    inv_finished = True
+            else:
+                # versioned present directory
+                # merge the inventory and disk data together
+                dirblock = []
+                for relpath, subiterator in itertools.groupby(sorted(
+                    current_inv[1] + cur_disk_dir_content,
+                    key=operator.itemgetter(0)), operator.itemgetter(1)):
+                    path_elements = list(subiterator)
+                    if len(path_elements) == 2:
+                        inv_row, disk_row = path_elements
+                        # versioned, present file
+                        dirblock.append((inv_row[0],
+                            inv_row[1], disk_row[2],
+                            disk_row[3], inv_row[4],
+                            inv_row[5]))
+                    elif len(path_elements[0]) == 5:
+                        # unknown disk file
+                        dirblock.append((path_elements[0][0],
+                            path_elements[0][1], path_elements[0][2],
+                            path_elements[0][3], None, None))
+                    elif len(path_elements[0]) == 6:
+                        # versioned, absent file.
+                        dirblock.append((path_elements[0][0],
+                            path_elements[0][1], 'unknown', None,
+                            path_elements[0][4], path_elements[0][5]))
+                    else:
+                        raise NotImplementedError('unreachable code')
+                yield current_inv[0], dirblock
+                try:
+                    current_inv = next(inventory_iterator)
+                except StopIteration:
+                    inv_finished = True
+                try:
+                    current_disk = next(disk_iterator)
+                except StopIteration:
+                    disk_finished = True
+
     def _walkdirs(self, prefix=""):
         """Walk the directories of this tree.
 
 
=== modified file 'breezy/controldir.py'
--- breezy/controldir.py	2017-07-30 21:23:44 +0000
+++ breezy/controldir.py	2017-11-29 12:08:31 +0000
@@ -29,6 +29,7 @@
 import textwrap
 
 from breezy import (
+    branch as _mod_branch,
     hooks,
     revision as _mod_revision,
     transport as _mod_transport,
@@ -1454,6 +1455,101 @@
     return filename == '.bzr'
 
 
+class RepositoryAcquisitionPolicy(object):
+    """Abstract base class for repository acquisition policies.
+
+    A repository acquisition policy decides how a ControlDir acquires a repository
+    for a branch that is being created.  The most basic policy decision is
+    whether to create a new repository or use an existing one.
+    """
+    def __init__(self, stack_on, stack_on_pwd, require_stacking):
+        """Constructor.
+
+        :param stack_on: A location to stack on
+        :param stack_on_pwd: If stack_on is relative, the location it is
+            relative to.
+        :param require_stacking: If True, it is a failure to not stack.
+        """
+        self._stack_on = stack_on
+        self._stack_on_pwd = stack_on_pwd
+        self._require_stacking = require_stacking
+
+    def configure_branch(self, branch):
+        """Apply any configuration data from this policy to the branch.
+
+        Default implementation sets repository stacking.
+        """
+        if self._stack_on is None:
+            return
+        if self._stack_on_pwd is None:
+            stack_on = self._stack_on
+        else:
+            try:
+                stack_on = urlutils.rebase_url(self._stack_on,
+                    self._stack_on_pwd,
+                    branch.user_url)
+            except urlutils.InvalidRebaseURLs:
+                stack_on = self._get_full_stack_on()
+        try:
+            branch.set_stacked_on_url(stack_on)
+        except (_mod_branch.UnstackableBranchFormat,
+                errors.UnstackableRepositoryFormat):
+            if self._require_stacking:
+                raise
+
+    def requires_stacking(self):
+        """Return True if this policy requires stacking."""
+        return self._stack_on is not None and self._require_stacking
+
+    def _get_full_stack_on(self):
+        """Get a fully-qualified URL for the stack_on location."""
+        if self._stack_on is None:
+            return None
+        if self._stack_on_pwd is None:
+            return self._stack_on
+        else:
+            return urlutils.join(self._stack_on_pwd, self._stack_on)
+
+    def _add_fallback(self, repository, possible_transports=None):
+        """Add a fallback to the supplied repository, if stacking is set."""
+        stack_on = self._get_full_stack_on()
+        if stack_on is None:
+            return
+        try:
+            stacked_dir = ControlDir.open(
+                    stack_on, possible_transports=possible_transports)
+        except errors.JailBreak:
+            # We keep the stacking details, but we are in the server code so
+            # actually stacking is not needed.
+            return
+        try:
+            stacked_repo = stacked_dir.open_branch().repository
+        except errors.NotBranchError:
+            stacked_repo = stacked_dir.open_repository()
+        try:
+            repository.add_fallback_repository(stacked_repo)
+        except errors.UnstackableRepositoryFormat:
+            if self._require_stacking:
+                raise
+        else:
+            self._require_stacking = True
+
+    def acquire_repository(self, make_working_trees=None, shared=False,
+            possible_transports=None):
+        """Acquire a repository for this controlrdir.
+
+        Implementations may create a new repository or use a pre-exising
+        repository.
+
+        :param make_working_trees: If creating a repository, set
+            make_working_trees to this value (if non-None)
+        :param shared: If creating a repository, make it shared if True
+        :return: A repository, is_new_flag (True if the repository was
+            created).
+        """
+        raise NotImplementedError(RepositoryAcquisitionPolicy.acquire_repository)
+
+
 # Please register new formats after old formats so that formats
 # appear in chronological order and format descriptions can build
 # on previous ones.
 
=== modified file 'breezy/log.py'
--- breezy/log.py	2017-11-12 20:07:32 +0000
+++ breezy/log.py	2017-11-29 12:08:31 +0000
@@ -103,38 +103,38 @@
     TODO: Perhaps some way to limit this to only particular revisions,
     or to traverse a non-mainline set of revisions?
     """
-    last_ie = None
+    last_verifier = None
     last_path = None
     revno = 1
     graph = branch.repository.get_graph()
     history = list(graph.iter_lefthand_ancestry(branch.last_revision(),
         [_mod_revision.NULL_REVISION]))
     for revision_id in reversed(history):
-        this_inv = branch.repository.get_inventory(revision_id)
-        if this_inv.has_id(file_id):
-            this_ie = this_inv[file_id]
-            this_path = this_inv.id2path(file_id)
+        this_tree = branch.repository.revision_tree(revision_id)
+        try:
+            this_path = this_tree.id2path(file_id)
+        except errors.NoSuchId:
+            this_verifier = this_path = None
         else:
-            this_ie = this_path = None
+            this_verifier = this_tree.get_file_verifier(this_path, file_id)
 
         # now we know how it was last time, and how it is in this revision.
         # are those two states effectively the same or not?
 
-        if not this_ie and not last_ie:
+        if not this_verifier and not last_verifier:
             # not present in either
             pass
-        elif this_ie and not last_ie:
+        elif this_verifier and not last_verifier:
             yield revno, revision_id, "added " + this_path
-        elif not this_ie and last_ie:
+        elif not this_verifier and last_verifier:
             # deleted here
             yield revno, revision_id, "deleted " + last_path
         elif this_path != last_path:
             yield revno, revision_id, ("renamed %s => %s" % (last_path, this_path))
-        elif (this_ie.text_size != last_ie.text_size
-              or this_ie.text_sha1 != last_ie.text_sha1):
+        elif (this_verifier != last_verifier):
             yield revno, revision_id, "modified " + this_path
 
-        last_ie = this_ie
+        last_verifier = this_verifier
         last_path = this_path
         revno += 1
 
 
=== modified file 'breezy/tests/per_branch/test_push.py'
--- breezy/tests/per_branch/test_push.py	2017-11-16 00:39:04 +0000
+++ breezy/tests/per_branch/test_push.py	2017-11-29 12:08:31 +0000
@@ -237,11 +237,10 @@
         except errors.UninitializableFormat:
             raise tests.TestNotApplicable('cannot initialize this format')
         source.start_series()
-        source.build_snapshot(None, [
-            ('add', ('', 'root-id', 'directory', None))],
-            revision_id='A')
-        source.build_snapshot(['A'], [], revision_id='B')
-        source.build_snapshot(['A'], [], revision_id='C')
+        revid_a = source.build_snapshot(None, [
+            ('add', ('', 'root-id', 'directory', None))])
+        revid_b = source.build_snapshot([revid_a], [])
+        revid_c = source.build_snapshot([revid_a], [])
         source.finish_series()
         b = source.get_branch()
         # Note: We can't read lock the source branch. Some formats take a write
@@ -251,9 +250,9 @@
         # This means 'push the source branch into this dir'
         bzrdir.push_branch(b)
         self.addCleanup(repo.lock_read().unlock)
-        # We should have pushed 'C', but not 'B', since it isn't in the
+        # We should have pushed revid_c, but not revid_b, since it isn't in the
         # ancestry
-        self.assertEqual(['A', 'C'], sorted(repo.all_revision_ids()))
+        self.assertEqual([revid_a, revid_c], sorted(repo.all_revision_ids()))
 
     def test_push_with_default_stacking_does_not_create_broken_branch(self):
         """Pushing a new standalone branch works even when there's a default
@@ -278,24 +277,22 @@
         repo = self.make_repository('repo', shared=True, format='1.6')
         builder = self.make_branch_builder('repo/local')
         builder.start_series()
-        builder.build_snapshot(None, [
+        revid1 = builder.build_snapshot(None, [
             ('add', ('', 'root-id', 'directory', '')),
-            ('add', ('filename', 'f-id', 'file', 'content\n'))],
-            revision_id='rev-1',)
-        builder.build_snapshot(['rev-1'], [], revision_id='rev-2')
-        builder.build_snapshot(['rev-2'],
-            [('modify', ('f-id', 'new-content\n'))],
-            revision_id='rev-3')
+            ('add', ('filename', 'f-id', 'file', 'content\n'))])
+        revid2 = builder.build_snapshot([revid1], [])
+        revid3 = builder.build_snapshot([revid2],
+            [('modify', ('f-id', 'new-content\n'))])
         builder.finish_series()
         trunk = builder.get_branch()
         # Sprout rev-1 to "trunk", so that we can stack on it.
-        trunk.controldir.sprout(self.get_url('trunk'), revision_id='rev-1')
+        trunk.controldir.sprout(self.get_url('trunk'), revision_id=revid1)
         # Set a default stacking policy so that new branches will automatically
         # stack on trunk.
         self.make_controldir('.').get_config().set_default_stack_on('trunk')
         # Push rev-2 to a new branch "remote".  It will be stacked on "trunk".
         output = BytesIO()
-        push._show_push_branch(trunk, 'rev-2', self.get_url('remote'), output)
+        push._show_push_branch(trunk, revid2, self.get_url('remote'), output)
         # Push rev-3 onto "remote".  If "remote" not stacked and is missing the
         # fulltext record for f-id @ rev-1, then this will fail.
         remote_branch = branch.Branch.open(self.get_url('remote'))
 
=== modified file 'breezy/tests/per_branch/test_tags.py'
--- breezy/tests/per_branch/test_tags.py	2017-11-21 20:09:04 +0000
+++ breezy/tests/per_branch/test_tags.py	2017-11-29 12:08:31 +0000
@@ -116,29 +116,31 @@
             self.fail("didn't get expected exception")
 
     def test_merge_tags(self):
-        b1 = self.make_branch_with_revisions('b1', ['revid', 'revid-1'])
-        b2 = self.make_branch_with_revisions('b2', ['revid', 'revid-2'])
+        b1, [revid, revid1] = self.make_branch_with_revision_tuple('b1', 2)
+        w2 = b1.controldir.sprout('b2', revision_id=revid).open_workingtree()
+        revid2 = w2.commit('revision 2')
+        b2 = w2.branch
         # if there are tags in the source and not the destination, then they
         # just go across
-        b1.tags.set_tag('tagname', 'revid')
+        b1.tags.set_tag('tagname', revid)
         b1.tags.merge_to(b2.tags)
-        self.assertEqual(b2.tags.lookup_tag('tagname'), 'revid')
+        self.assertEqual(b2.tags.lookup_tag('tagname'), revid)
         # if a tag is in the destination and not in the source, it is not
         # removed when we merge them
-        b2.tags.set_tag('in-destination', 'revid')
+        b2.tags.set_tag('in-destination', revid)
         updates, conflicts = b1.tags.merge_to(b2.tags)
         self.assertEqual(list(conflicts), [])
         self.assertEqual(updates, {})
-        self.assertEqual(b2.tags.lookup_tag('in-destination'), 'revid')
+        self.assertEqual(b2.tags.lookup_tag('in-destination'), revid)
         # if there's a conflicting tag, it's reported -- the command line
         # interface will say "these tags couldn't be copied"
-        b1.tags.set_tag('conflicts', 'revid-1')
-        b2.tags.set_tag('conflicts', 'revid-2')
+        b1.tags.set_tag('conflicts', revid1)
+        b2.tags.set_tag('conflicts', revid2)
         updates, conflicts = b1.tags.merge_to(b2.tags)
-        self.assertEqual(list(conflicts), [('conflicts', 'revid-1', 'revid-2')])
+        self.assertEqual(list(conflicts), [('conflicts', revid1, revid2)])
         # and it keeps the same value
         self.assertEqual(updates, {})
-        self.assertEqual(b2.tags.lookup_tag('conflicts'), 'revid-2')
+        self.assertEqual(b2.tags.lookup_tag('conflicts'), revid2)
 
     def test_unicode_tag(self):
         tag_name = u'\u3070'
@@ -238,7 +240,7 @@
 
     def test_merge_to_invalides_cache(self):
         b1, revids = self.make_write_locked_branch_with_one_tag()
-        b2 = self.make_branch_with_revisions('b2', [revids[1], revids[0]])
+        b2 = b1.controldir.sprout('b2').open_branch()
         b2.tags.set_tag('two', revids[1])
         b2.tags.merge_to(b1.tags)
         self.assertEqual(
 
=== modified file 'breezy/tests/per_controldir/test_controldir.py'
--- breezy/tests/per_controldir/test_controldir.py	2017-08-10 01:21:20 +0000
+++ breezy/tests/per_controldir/test_controldir.py	2017-11-29 12:08:31 +0000
@@ -314,6 +314,8 @@
         tree.add('foo')
         rev1 = tree.commit('revision 1')
         tree_repo = tree.branch.repository
+        if not tree_repo._format.supports_revision_signatures:
+            self.skipTest('repository format does not support signing')
         tree_repo.lock_write()
         tree_repo.start_write_group()
         tree_repo.sign_revision(rev1, gpg.LoopbackGPGStrategy(None))
 
=== modified file 'breezy/tests/per_intertree/test_compare.py'
--- breezy/tests/per_intertree/test_compare.py	2017-11-12 20:44:54 +0000
+++ breezy/tests/per_intertree/test_compare.py	2017-11-29 12:08:31 +0000
@@ -130,9 +130,9 @@
         d = self.intertree_class(tree1, tree2).compare()
         self.assertEqual([], d.added)
         self.assertEqual([], d.modified)
-        self.assertEqual([('a', 'a-id', 'file'),
-                          ('b', 'b-id', 'directory'),
-                          ('b/c', 'c-id', 'file'),
+        self.assertEqual([('a', tree1.path2id('a'), 'file'),
+                          ('b', tree1.path2id('b'), 'directory'),
+                          ('b/c', tree1.path2id('b/c'), 'file'),
                          ], d.removed)
         self.assertEqual([], d.renamed)
         self.assertEqual([], d.unchanged)
@@ -146,7 +146,7 @@
         tree1, tree2 = self.mutable_trees_to_test_trees(self, tree1, tree2)
         d = self.intertree_class(tree1, tree2).compare()
         self.assertEqual([], d.added)
-        self.assertEqual([('a', 'a-id', 'file', True, False)], d.modified)
+        self.assertEqual([('a', tree1.path2id('a'), 'file', True, False)], d.modified)
         self.assertEqual([], d.removed)
         self.assertEqual([], d.renamed)
         self.assertEqual([], d.unchanged)
@@ -160,7 +160,7 @@
         tree1, tree2 = self.mutable_trees_to_test_trees(self, tree1, tree2)
         d = self.intertree_class(tree1, tree2).compare()
         self.assertEqual([], d.added)
-        self.assertEqual([('b/c', 'c-id', 'file', False, True)], d.modified)
+        self.assertEqual([('b/c', tree1.path2id('b/c'), 'file', False, True)], d.modified)
         self.assertEqual([], d.removed)
         self.assertEqual([], d.renamed)
         self.assertEqual([], d.unchanged)
@@ -176,7 +176,7 @@
         self.assertEqual([], d.added)
         self.assertEqual([], d.modified)
         self.assertEqual([], d.removed)
-        self.assertEqual([('a', 'd', 'a-id', 'file', False, False)], d.renamed)
+        self.assertEqual([('a', 'd', tree1.path2id('a'), 'file', False, False)], d.renamed)
         self.assertEqual([], d.unchanged)
 
     def test_file_rename_and_modification(self):
@@ -190,7 +190,7 @@
         self.assertEqual([], d.added)
         self.assertEqual([], d.modified)
         self.assertEqual([], d.removed)
-        self.assertEqual([('a', 'd', 'a-id', 'file', True, False)], d.renamed)
+        self.assertEqual([('a', 'd', tree1.path2id('a'), 'file', True, False)], d.renamed)
         self.assertEqual([], d.unchanged)
 
     def test_file_rename_and_meta_modification(self):
@@ -204,7 +204,7 @@
         self.assertEqual([], d.added)
         self.assertEqual([], d.modified)
         self.assertEqual([], d.removed)
-        self.assertEqual([('b/c', 'e', 'c-id', 'file', False, True)], d.renamed)
+        self.assertEqual([('b/c', 'e', tree1.path2id('b/c'), 'file', False, True)], d.renamed)
         self.assertEqual([], d.unchanged)
 
     def test_empty_to_abc_content_a_only(self):
@@ -215,7 +215,7 @@
         tree2 = self.get_tree_no_parents_abc_content(tree2)
         tree1, tree2 = self.mutable_trees_to_test_trees(self, tree1, tree2)
         d = self.intertree_class(tree1, tree2).compare(specific_files=['a'])
-        self.assertEqual([('a', 'a-id', 'file')], d.added)
+        self.assertEqual([('a', tree2.path2id('a'), 'file')], d.added)
         self.assertEqual([], d.modified)
         self.assertEqual([], d.removed)
         self.assertEqual([], d.renamed)
@@ -230,8 +230,9 @@
         d = self.intertree_class(tree1, tree2).compare(
             specific_files=['a', 'b/c'])
         self.assertEqual(
-            [('a', 'a-id', 'file'),  (u'b', 'b-id', 'directory'),
-             ('b/c', 'c-id', 'file')],
+            [('a', tree2.path2id('a'), 'file'),
+             (u'b', tree2.path2id('b'), 'directory'),
+             ('b/c', tree2.path2id('b/c'), 'file')],
             d.added)
         self.assertEqual([], d.modified)
         self.assertEqual([], d.removed)
@@ -765,7 +766,7 @@
         tree2 = self.get_tree_no_parents_abc_content_4(tree2)
         tree1, tree2 = self.mutable_trees_to_test_trees(self, tree1, tree2)
         root_id = tree1.path2id('')
-        self.assertEqual([('a-id', ('a', 'd'), False, (True, True),
+        self.assertEqual([(tree1.path2id('a'), ('a', 'd'), False, (True, True),
                            (root_id, root_id), ('a', 'd'), ('file', 'file'),
                            (False, False))],
                          self.do_iter_changes(tree1, tree2))
@@ -861,7 +862,7 @@
         # d is new, d/e is b-id renamed, d/e/a is a-id renamed 
         root_id = tree1.path2id('')
         self.assertEqualIterChanges(
-            [self.renamed(tree1, tree2, 'b-id', False),
+            [self.renamed(tree1, tree2, tree1.path2id('b'), False),
              self.added(tree2, 'd-id'),
              self.renamed(tree1, tree2, 'a-id', False)],
              self.do_iter_changes(tree1, tree2, specific_files=['d/e/a']))
 
=== modified file 'breezy/tests/per_repository/test_fetch.py'
--- breezy/tests/per_repository/test_fetch.py	2017-11-19 19:00:31 +0000
+++ breezy/tests/per_repository/test_fetch.py	2017-11-29 12:08:31 +0000
@@ -320,27 +320,26 @@
     def make_simple_branch_with_ghost(self):
         builder = self.make_branch_builder('source')
         builder.start_series()
-        builder.build_snapshot(None, [
+        a_revid = builder.build_snapshot(None, [
             ('add', ('', 'root-id', 'directory', None)),
-            ('add', ('file', 'file-id', 'file', 'content\n'))],
-            revision_id='A-id')
-        builder.build_snapshot(['A-id', 'ghost-id'], [], revision_id='B-id')
+            ('add', ('file', 'file-id', 'file', 'content\n'))])
+        b_revid = builder.build_snapshot([a_revid, 'ghost-id'], [])
         builder.finish_series()
         source_b = builder.get_branch()
         source_b.lock_read()
         self.addCleanup(source_b.unlock)
-        return source_b
+        return source_b, b_revid
 
     def test_fetch_with_ghost(self):
-        source_b = self.make_simple_branch_with_ghost()
+        source_b, b_revid = self.make_simple_branch_with_ghost()
         target = self.make_repository('target')
         target.lock_write()
         self.addCleanup(target.unlock)
-        target.fetch(source_b.repository, revision_id='B-id')
+        target.fetch(source_b.repository, revision_id=b_revid)
 
     def test_fetch_into_smart_with_ghost(self):
         trans = self.make_smart_server('target')
-        source_b = self.make_simple_branch_with_ghost()
+        source_b, b_revid = self.make_simple_branch_with_ghost()
         if not source_b.controldir._format.supports_transport(trans):
             raise TestNotApplicable("format does not support transport")
         target = self.make_repository('target')
@@ -349,7 +348,7 @@
         target.lock_write()
         self.addCleanup(target.unlock)
         try:
-            target.fetch(source_b.repository, revision_id='B-id')
+            target.fetch(source_b.repository, revision_id=b_revid)
         except errors.TokenLockingNotSupported:
             # The code inside fetch() that tries to lock and then fails, also
             # causes weird problems with 'lock_not_held' later on...
@@ -359,7 +358,7 @@
 
     def test_fetch_from_smart_with_ghost(self):
         trans = self.make_smart_server('source')
-        source_b = self.make_simple_branch_with_ghost()
+        source_b, b_revid = self.make_simple_branch_with_ghost()
         if not source_b.controldir._format.supports_transport(trans):
             raise TestNotApplicable("format does not support transport")
         target = self.make_repository('target')
@@ -369,5 +368,5 @@
         source = repository.Repository.open(trans.base)
         source.lock_read()
         self.addCleanup(source.unlock)
-        target.fetch(source, revision_id='B-id')
+        target.fetch(source, revision_id=b_revid)
 
 
=== modified file 'breezy/tests/per_repository/test_repository.py'
--- breezy/tests/per_repository/test_repository.py	2017-11-21 00:38:51 +0000
+++ breezy/tests/per_repository/test_repository.py	2017-11-29 12:08:31 +0000
@@ -69,7 +69,7 @@
     def assertFormatAttribute(self, attribute, allowed_values):
         """Assert that the format has an attribute 'attribute'."""
         repo = self.make_repository('repo')
-        self.assertSubset([getattr(repo._format, attribute)], allowed_values)
+        self.assertIn(getattr(repo._format, attribute), allowed_values)
 
     def test_attribute_fast_deltas(self):
         """Test the format.fast_deltas attribute."""
@@ -118,6 +118,7 @@
         self.assertFormatAttribute('supports_setting_revision_ids',
             (True, False))
 
+<<<<<<< TREE
     def test_attribute_format_supports_storing_branch_nick(self):
         self.assertFormatAttribute('supports_storing_branch_nick',
             (True, False))
@@ -137,13 +138,34 @@
             self.assertRaises(TypeError, repo._format.open,
                     repo.controldir, _override_transport=backup_transport)
 
+=======
+    def test_attribute_format_supports_storing_branch_nick(self):
+        self.assertFormatAttribute('supports_storing_branch_nick',
+            (True, False))
+
+    def test_attribute_format_supports_overriding_transport(self):
+        repo = self.make_repository('repo')
+        self.assertIn(repo._format.supports_overriding_transport, (True, False))
+
+        repo.control_transport.copy_tree('.', '../repository.backup')
+        backup_transport = repo.control_transport.clone('../repository.backup')
+        if repo._format.supports_overriding_transport:
+            backup = repo._format.open(
+                    repo.controldir,
+                    _override_transport=backup_transport)
+            self.assertIs(backup_transport, backup.control_transport)
+        else:
+            self.assertRaises(TypeError, repo._format.open,
+                    repo.controldir, _override_transport=backup_transport)
+
+>>>>>>> MERGE-SOURCE
     def test_format_is_deprecated(self):
         repo = self.make_repository('repo')
-        self.assertSubset([repo._format.is_deprecated()], (True, False))
+        self.assertIn(repo._format.is_deprecated(), (True, False))
 
     def test_format_is_supported(self):
         repo = self.make_repository('repo')
-        self.assertSubset([repo._format.is_supported()], (True, False))
+        self.assertIn(repo._format.is_supported(), (True, False))
 
     def test_clone_to_default_format(self):
         #TODO: Test that cloning a repository preserves all the information
@@ -387,8 +409,7 @@
 
     def test_format_supports_external_lookups(self):
         repo = self.make_repository('.')
-        self.assertSubset(
-            [repo._format.supports_external_lookups], (True, False))
+        self.assertIn(repo._format.supports_external_lookups, (True, False))
 
     def assertMessageRoundtrips(self, message):
         """Assert that message roundtrips to a repository and back intact."""
 
=== modified file 'breezy/tests/per_tree/test_annotate_iter.py'
--- breezy/tests/per_tree/test_annotate_iter.py	2017-11-12 13:09:58 +0000
+++ breezy/tests/per_tree/test_annotate_iter.py	2017-11-29 12:08:31 +0000
@@ -32,6 +32,8 @@
 
     def get_tree_with_ghost(self):
         tree = self.make_branch_and_tree('tree')
+        if not tree.branch.repository._format.supports_ghosts:
+            self.skipTest('repository format does not support ghosts')
         self.build_tree_contents([('tree/one', 'first\ncontent\n')])
         tree.add(['one'])
         rev_1 = tree.commit('one')
 
=== modified file 'breezy/tests/per_workingtree/test_add.py'
--- breezy/tests/per_workingtree/test_add.py	2017-11-19 18:57:33 +0000
+++ breezy/tests/per_workingtree/test_add.py	2017-11-29 12:08:31 +0000
@@ -58,6 +58,8 @@
     def test_add_old_id(self):
         """We can add an old id, as long as it doesn't exist now."""
         tree = self.make_branch_and_tree('.')
+        if not tree.supports_setting_file_ids():
+            self.skipTest("tree does not support setting file ids")
         self.build_tree(['a', 'b'])
         tree.add(['a'])
         file_id = tree.path2id('a')
 
=== modified file 'breezy/tests/per_workingtree/test_annotate_iter.py'
--- breezy/tests/per_workingtree/test_annotate_iter.py	2017-11-19 19:00:31 +0000
+++ breezy/tests/per_workingtree/test_annotate_iter.py	2017-11-29 12:08:31 +0000
@@ -23,159 +23,159 @@
 
     def make_single_rev_tree(self):
         builder = self.make_branch_builder('branch')
-        builder.build_snapshot(None, [
+        revid = builder.build_snapshot(None, [
             ('add', ('', 'TREE_ROOT', 'directory', None)),
             ('add', ('file', 'file-id', 'file', 'initial content\n')),
-            ], revision_id='rev-1')
+            ])
         b = builder.get_branch()
         tree = b.create_checkout('tree', lightweight=True)
         tree.lock_read()
         self.addCleanup(tree.unlock)
-        return tree
+        return tree, revid
 
     def test_annotate_same_as_parent(self):
-        tree = self.make_single_rev_tree()
+        tree, revid = self.make_single_rev_tree()
         annotations = tree.annotate_iter('file')
-        self.assertEqual([('rev-1', 'initial content\n')],
+        self.assertEqual([(revid, 'initial content\n')],
                          annotations)
 
     def test_annotate_mod_from_parent(self):
-        tree = self.make_single_rev_tree()
+        tree, revid = self.make_single_rev_tree()
         self.build_tree_contents([('tree/file',
                                    'initial content\nnew content\n')])
         annotations = tree.annotate_iter('file')
-        self.assertEqual([('rev-1', 'initial content\n'),
+        self.assertEqual([(revid, 'initial content\n'),
                           ('current:', 'new content\n'),
                          ], annotations)
 
     def test_annotate_merge_parents(self):
         builder = self.make_branch_builder('branch')
         builder.start_series()
-        builder.build_snapshot(None, [
+        revid1 = builder.build_snapshot(None, [
             ('add', ('', 'TREE_ROOT', 'directory', None)),
             ('add', ('file', 'file-id', 'file', 'initial content\n')),
-            ], revision_id='rev-1')
-        builder.build_snapshot(['rev-1'], [
+            ])
+        revid2 = builder.build_snapshot([revid1], [
             ('modify', ('file-id', 'initial content\ncontent in 2\n')),
-            ], revision_id='rev-2')
-        builder.build_snapshot(['rev-1'], [
+            ])
+        revid3 = builder.build_snapshot([revid1], [
             ('modify', ('file-id', 'initial content\ncontent in 3\n')),
-            ], revision_id='rev-3')
+            ])
         builder.finish_series()
         b = builder.get_branch()
-        tree = b.create_checkout('tree', revision_id='rev-2', lightweight=True)
+        tree = b.create_checkout('tree', revision_id=revid2, lightweight=True)
         tree.lock_write()
         self.addCleanup(tree.unlock)
-        tree.set_parent_ids(['rev-2', 'rev-3'])
+        tree.set_parent_ids([revid2, revid3])
         self.build_tree_contents([('tree/file',
                                    'initial content\ncontent in 2\n'
                                    'content in 3\nnew content\n')])
         annotations = tree.annotate_iter('file')
-        self.assertEqual([('rev-1', 'initial content\n'),
-                          ('rev-2', 'content in 2\n'),
-                          ('rev-3', 'content in 3\n'),
+        self.assertEqual([(revid1, 'initial content\n'),
+                          (revid2, 'content in 2\n'),
+                          (revid3, 'content in 3\n'),
                           ('current:', 'new content\n'),
                          ], annotations)
 
     def test_annotate_merge_parent_no_file(self):
         builder = self.make_branch_builder('branch')
         builder.start_series()
-        builder.build_snapshot(None, [
+        revid1 = builder.build_snapshot(None, [
             ('add', ('', 'TREE_ROOT', 'directory', None)),
-            ], revision_id='rev-1')
-        builder.build_snapshot(['rev-1'], [
+            ])
+        revid2 = builder.build_snapshot([revid1], [
             ('add', ('file', 'file-id', 'file', 'initial content\n')),
-            ], revision_id='rev-2')
-        builder.build_snapshot(['rev-1'], [], revision_id='rev-3')
+            ])
+        revid3 = builder.build_snapshot([revid1], [])
         builder.finish_series()
         b = builder.get_branch()
-        tree = b.create_checkout('tree', revision_id='rev-2', lightweight=True)
+        tree = b.create_checkout('tree', revision_id=revid2, lightweight=True)
         tree.lock_write()
         self.addCleanup(tree.unlock)
-        tree.set_parent_ids(['rev-2', 'rev-3'])
+        tree.set_parent_ids([revid2, revid3])
         self.build_tree_contents([('tree/file',
                                    'initial content\nnew content\n')])
         annotations = tree.annotate_iter('file')
-        self.assertEqual([('rev-2', 'initial content\n'),
+        self.assertEqual([(revid2, 'initial content\n'),
                           ('current:', 'new content\n'),
                          ], annotations)
 
     def test_annotate_merge_parent_was_directory(self):
         builder = self.make_branch_builder('branch')
         builder.start_series()
-        builder.build_snapshot(None, [
+        revid1 = builder.build_snapshot(None, [
             ('add', ('', 'TREE_ROOT', 'directory', None)),
-            ], revision_id='rev-1')
-        builder.build_snapshot(['rev-1'], [
+            ])
+        revid2 = builder.build_snapshot([revid1], [
             ('add', ('file', 'file-id', 'file', 'initial content\n')),
-            ], revision_id='rev-2')
-        builder.build_snapshot(['rev-1'], [
+            ])
+        revid3 = builder.build_snapshot([revid1], [
             ('add', ('a_dir', 'file-id', 'directory', None)),
-            ], revision_id='rev-3')
+            ])
         builder.finish_series()
         b = builder.get_branch()
-        tree = b.create_checkout('tree', revision_id='rev-2', lightweight=True)
+        tree = b.create_checkout('tree', revision_id=revid2, lightweight=True)
         tree.lock_write()
         self.addCleanup(tree.unlock)
-        tree.set_parent_ids(['rev-2', 'rev-3'])
+        tree.set_parent_ids([revid2, revid3])
         self.build_tree_contents([('tree/file',
                                    'initial content\nnew content\n')])
         annotations = tree.annotate_iter('file')
-        self.assertEqual([('rev-2', 'initial content\n'),
+        self.assertEqual([(revid2, 'initial content\n'),
                           ('current:', 'new content\n'),
                          ], annotations)
 
     def test_annotate_same_as_merge_parent(self):
         builder = self.make_branch_builder('branch')
         builder.start_series()
-        builder.build_snapshot(None, [
+        revid1 = builder.build_snapshot(None, [
             ('add', ('', 'TREE_ROOT', 'directory', None)),
             ('add', ('file', 'file-id', 'file', 'initial content\n')),
-            ], revision_id='rev-1')
-        builder.build_snapshot(['rev-1'], [
-            ], revision_id='rev-2')
-        builder.build_snapshot(['rev-1'], [
+            ])
+        revid2 = builder.build_snapshot([revid1], [
+            ])
+        revid3 = builder.build_snapshot([revid1], [
             ('modify', ('file-id', 'initial content\ncontent in 3\n')),
-            ], revision_id='rev-3')
+            ])
         builder.finish_series()
         b = builder.get_branch()
-        tree = b.create_checkout('tree', revision_id='rev-2', lightweight=True)
+        tree = b.create_checkout('tree', revision_id=revid2, lightweight=True)
         tree.lock_write()
         self.addCleanup(tree.unlock)
-        tree.set_parent_ids(['rev-2', 'rev-3'])
+        tree.set_parent_ids([revid2, revid3])
         self.build_tree_contents([('tree/file',
                                    'initial content\ncontent in 3\n')])
         annotations = tree.annotate_iter('file')
-        self.assertEqual([('rev-1', 'initial content\n'),
-                          ('rev-3', 'content in 3\n'),
+        self.assertEqual([(revid1, 'initial content\n'),
+                          (revid3, 'content in 3\n'),
                          ], annotations)
 
     def test_annotate_same_as_merge_parent_supersedes(self):
         builder = self.make_branch_builder('branch')
         builder.start_series()
-        builder.build_snapshot(None, [
+        revid1 = builder.build_snapshot(None, [
             ('add', ('', 'TREE_ROOT', 'directory', None)),
             ('add', ('file', 'file-id', 'file', 'initial content\n')),
-            ], revision_id='rev-1')
-        builder.build_snapshot(['rev-1'], [
+            ])
+        revid2 = builder.build_snapshot([revid1], [
             ('modify', ('file-id', 'initial content\nnew content\n')),
-            ], revision_id='rev-2')
-        builder.build_snapshot(['rev-2'], [
+            ])
+        revid3 = builder.build_snapshot([revid2], [
             ('modify', ('file-id', 'initial content\ncontent in 3\n')),
-            ], revision_id='rev-3')
-        builder.build_snapshot(['rev-3'], [
+            ])
+        revid4 = builder.build_snapshot([revid3], [
             ('modify', ('file-id', 'initial content\nnew content\n')),
-            ], revision_id='rev-4')
+            ])
         # In this case, the content locally is the same as content in basis
         # tree, but the merge revision states that *it* should win
         builder.finish_series()
         b = builder.get_branch()
-        tree = b.create_checkout('tree', revision_id='rev-2', lightweight=True)
+        tree = b.create_checkout('tree', revision_id=revid2, lightweight=True)
         tree.lock_write()
         self.addCleanup(tree.unlock)
-        tree.set_parent_ids(['rev-2', 'rev-4'])
+        tree.set_parent_ids([revid2, revid4])
         annotations = tree.annotate_iter('file')
-        self.assertEqual([('rev-1', 'initial content\n'),
-                          ('rev-4', 'new content\n'),
+        self.assertEqual([(revid1, 'initial content\n'),
+                          (revid4, 'new content\n'),
                          ], annotations)
 
 
=== modified file 'breezy/tests/per_workingtree/test_get_file_mtime.py'
--- breezy/tests/per_workingtree/test_get_file_mtime.py	2017-11-12 20:44:54 +0000
+++ breezy/tests/per_workingtree/test_get_file_mtime.py	2017-11-29 12:08:31 +0000
@@ -57,7 +57,7 @@
         one_id = tree.path2id('one')
 
         st = os.lstat('tree/one')
-        tree.commit('one', rev_id='rev-1')
+        tree.commit('one')
 
         tree.lock_read()
         try:
 
=== modified file 'breezy/tests/per_workingtree/test_set_root_id.py'
--- breezy/tests/per_workingtree/test_set_root_id.py	2017-06-10 00:17:06 +0000
+++ breezy/tests/per_workingtree/test_set_root_id.py	2017-11-29 12:08:31 +0000
@@ -32,6 +32,8 @@
         # deliberately tests concurrent access that isn't possible on windows.
         self.thisFailsStrictLockCheck()
         tree = self.make_branch_and_tree('a-tree')
+        if not tree.supports_setting_file_ids():
+            self.skipTest('format does not support setting file ids')
         # setting the root id allows it to be read via get_root_id.
         root_id = u'\xe5n-id'.encode('utf8')
         tree.lock_write()
@@ -57,6 +59,8 @@
 
     def test_set_root_id(self):
         tree = self.make_branch_and_tree('.')
+        if not tree.supports_setting_file_ids():
+            self.skipTest('format does not support setting file ids')
         tree.lock_write()
         self.addCleanup(tree.unlock)
         orig_root_id = tree.get_root_id()
 
=== modified file 'breezy/tests/per_workingtree/test_walkdirs.py'
--- breezy/tests/per_workingtree/test_walkdirs.py	2017-11-14 01:20:44 +0000
+++ breezy/tests/per_workingtree/test_walkdirs.py	2017-11-29 12:08:31 +0000
@@ -84,7 +84,6 @@
         def add_dirblock(path, kind):
             dirblock = DirBlock(tree, path)
             if file_status != self.unknown:
-                dirblock.id = 'a ' + str(path).replace('/', '-') + '-id'
                 dirblock.inventory_kind = kind
             if file_status != self.missing:
                 dirblock.disk_kind = kind
@@ -97,7 +96,10 @@
         add_dirblock(paths[3], 'directory')
 
         if file_status != self.unknown:
-            tree.add(paths, [db.id for db in dirblocks])
+            tree.add(paths)
+            for dirblock in dirblocks:
+                if file_status != self.unknown:
+                    dirblock.id = tree.path2id(dirblock.relpath)
 
         if file_status == self.missing:
             # now make the files be missing
 
=== modified file 'breezy/tests/per_workingtree/test_workingtree.py'
--- breezy/tests/per_workingtree/test_workingtree.py	2017-11-21 20:09:04 +0000
+++ breezy/tests/per_workingtree/test_workingtree.py	2017-11-29 12:08:31 +0000
@@ -409,17 +409,17 @@
         wt = self.make_branch_and_tree('source')
         self.build_tree(['added', 'deleted', 'notadded'],
                         transport=wt.controldir.transport.clone('..'))
-        wt.add('deleted', 'deleted')
+        wt.add('deleted')
         wt.commit('add deleted')
         wt.remove('deleted')
-        wt.add('added', 'added')
+        wt.add('added')
         cloned_dir = wt.controldir.clone('target')
         cloned = cloned_dir.open_workingtree()
         cloned_transport = cloned.controldir.transport.clone('..')
         self.assertFalse(cloned_transport.has('deleted'))
         self.assertTrue(cloned_transport.has('added'))
         self.assertFalse(cloned_transport.has('notadded'))
-        self.assertEqual('added', cloned.path2id('added'))
+        self.assertIsNot(None, cloned.path2id('added'))
         self.assertEqual(None, cloned.path2id('deleted'))
         self.assertEqual(None, cloned.path2id('notadded'))
 
@@ -799,12 +799,13 @@
         self.build_tree(['foo.pyc'])
         # ensure that foo.pyc is ignored
         self.build_tree_contents([('.bzrignore', 'foo.pyc')])
-        tree.add('foo.pyc', 'anid')
+        tree.add('foo.pyc')
+        anid = tree.path2id('foo.pyc')
         tree.lock_read()
         files = sorted(list(tree.list_files()))
         tree.unlock()
         self.assertEqual((u'.bzrignore', '?', 'file', None), files[0][:-1])
-        self.assertEqual((u'foo.pyc', 'V', 'file', 'anid'), files[1][:-1])
+        self.assertEqual((u'foo.pyc', 'V', 'file', anid), files[1][:-1])
         self.assertEqual(2, len(files))
 
     def test_non_normalized_add_accessible(self):
 
=== modified file 'breezy/workingtree.py'
--- breezy/workingtree.py	2017-11-17 03:06:50 +0000
+++ breezy/workingtree.py	2017-11-29 12:08:31 +0000
@@ -38,9 +38,6 @@
 
 from .lazy_import import lazy_import
 lazy_import(globals(), """
-from bisect import bisect_left
-import itertools
-import operator
 import stat
 
 from breezy import (
@@ -393,7 +390,7 @@
         except errors.NoSuchRevision:
             pass
         # No cached copy available, retrieve from the repository.
-        # FIXME? RBC 20060403 should we cache the inventory locally
+        # FIXME? RBC 20060403 should we cache the tree locally
         # at this point ?
         try:
             return self.branch.repository.revision_tree(revision_id)
@@ -762,7 +759,7 @@
         because of a merge.
 
         This returns a map of file_id->sha1, containing only files which are
-        still in the working inventory and have that text hash.
+        still in the working tree and have that text hash.
         """
         raise NotImplementedError(self.merge_modified)
 
@@ -1155,8 +1152,8 @@
     def revision_tree(self, revision_id):
         """See Tree.revision_tree.
 
-        WorkingTree can supply revision_trees for the basis revision only
-        because there is only one cached inventory in the bzr directory.
+        For trees that can be obtained from the working tree, this
+        will do so. For other trees, it will fall back to the repository.
         """
         raise NotImplementedError(self.revision_tree)
 
@@ -1350,124 +1347,7 @@
         If the tree is not locked, it may cause an error to be raised,
         depending on the tree implementation.
         """
-        disk_top = self.abspath(prefix)
-        if disk_top.endswith('/'):
-            disk_top = disk_top[:-1]
-        top_strip_len = len(disk_top) + 1
-        inventory_iterator = self._walkdirs(prefix)
-        disk_iterator = osutils.walkdirs(disk_top, prefix)
-        try:
-            current_disk = next(disk_iterator)
-            disk_finished = False
-        except OSError as e:
-            if not (e.errno == errno.ENOENT or
-                (sys.platform == 'win32' and e.errno == ERROR_PATH_NOT_FOUND)):
-                raise
-            current_disk = None
-            disk_finished = True
-        try:
-            current_inv = next(inventory_iterator)
-            inv_finished = False
-        except StopIteration:
-            current_inv = None
-            inv_finished = True
-        while not inv_finished or not disk_finished:
-            if current_disk:
-                ((cur_disk_dir_relpath, cur_disk_dir_path_from_top),
-                    cur_disk_dir_content) = current_disk
-            else:
-                ((cur_disk_dir_relpath, cur_disk_dir_path_from_top),
-                    cur_disk_dir_content) = ((None, None), None)
-            if not disk_finished:
-                # strip out .bzr dirs
-                if (cur_disk_dir_path_from_top[top_strip_len:] == '' and
-                    len(cur_disk_dir_content) > 0):
-                    # osutils.walkdirs can be made nicer -
-                    # yield the path-from-prefix rather than the pathjoined
-                    # value.
-                    bzrdir_loc = bisect_left(cur_disk_dir_content,
-                        ('.bzr', '.bzr'))
-                    if (bzrdir_loc < len(cur_disk_dir_content)
-                        and self.controldir.is_control_filename(
-                            cur_disk_dir_content[bzrdir_loc][0])):
-                        # we dont yield the contents of, or, .bzr itself.
-                        del cur_disk_dir_content[bzrdir_loc]
-            if inv_finished:
-                # everything is unknown
-                direction = 1
-            elif disk_finished:
-                # everything is missing
-                direction = -1
-            else:
-                direction = cmp(current_inv[0][0], cur_disk_dir_relpath)
-            if direction > 0:
-                # disk is before inventory - unknown
-                dirblock = [(relpath, basename, kind, stat, None, None) for
-                    relpath, basename, kind, stat, top_path in
-                    cur_disk_dir_content]
-                yield (cur_disk_dir_relpath, None), dirblock
-                try:
-                    current_disk = next(disk_iterator)
-                except StopIteration:
-                    disk_finished = True
-            elif direction < 0:
-                # inventory is before disk - missing.
-                dirblock = [(relpath, basename, 'unknown', None, fileid, kind)
-                    for relpath, basename, dkind, stat, fileid, kind in
-                    current_inv[1]]
-                yield (current_inv[0][0], current_inv[0][1]), dirblock
-                try:
-                    current_inv = next(inventory_iterator)
-                except StopIteration:
-                    inv_finished = True
-            else:
-                # versioned present directory
-                # merge the inventory and disk data together
-                dirblock = []
-                for relpath, subiterator in itertools.groupby(sorted(
-                    current_inv[1] + cur_disk_dir_content,
-                    key=operator.itemgetter(0)), operator.itemgetter(1)):
-                    path_elements = list(subiterator)
-                    if len(path_elements) == 2:
-                        inv_row, disk_row = path_elements
-                        # versioned, present file
-                        dirblock.append((inv_row[0],
-                            inv_row[1], disk_row[2],
-                            disk_row[3], inv_row[4],
-                            inv_row[5]))
-                    elif len(path_elements[0]) == 5:
-                        # unknown disk file
-                        dirblock.append((path_elements[0][0],
-                            path_elements[0][1], path_elements[0][2],
-                            path_elements[0][3], None, None))
-                    elif len(path_elements[0]) == 6:
-                        # versioned, absent file.
-                        dirblock.append((path_elements[0][0],
-                            path_elements[0][1], 'unknown', None,
-                            path_elements[0][4], path_elements[0][5]))
-                    else:
-                        raise NotImplementedError('unreachable code')
-                yield current_inv[0], dirblock
-                try:
-                    current_inv = next(inventory_iterator)
-                except StopIteration:
-                    inv_finished = True
-                try:
-                    current_disk = next(disk_iterator)
-                except StopIteration:
-                    disk_finished = True
-
-    def _walkdirs(self, prefix=""):
-        """Walk the directories of this tree.
-
-        :param prefix: is used as the directrory to start with.
-        :returns: a generator which yields items in the form::
-
-            ((curren_directory_path, fileid),
-             [(file1_path, file1_name, file1_kind, None, file1_id,
-               file1_kind), ... ])
-        """
-        raise NotImplementedError(self._walkdirs)
+        raise NotImplementedError(self.walkdirs)
 
     def auto_resolve(self):
         """Automatically resolve text conflicts according to contents.