branchcache: add a "pure topological head" fast path

In a narrow but actually quick common case, all topological heads are all on
the same branch and all open. In this case, computing the branch map is very
simple. We can quickly detect situation where this situation will not change.

So we update the V3 format to be able to express this situation and upgrade the
update code to detect we remains in that mode.

The branch cache is populated with the actual value when the branch map is
accessed, but the update_disk method can do the update without needing to
populate it.

mercurial/branchmap.py

@@ -1,1299 +1,1394 b''
 # branchmap.py - logic to computes, maintain and stores branchmap for local repo
 #
 # Copyright 2005-2007 Olivia Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 
 import struct
 
 from .node import (
     bin,
     hex,
     nullrev,
 )
 
 from typing import (
     Any,
     Callable,
     Dict,
     Iterable,
     List,
     Optional,
     Set,
     TYPE_CHECKING,
     Tuple,
     Union,
     cast,
 )
 
 from . import (
     encoding,
     error,
     obsolete,
     scmutil,
     util,
 )
 
 from .utils import (
     repoviewutil,
     stringutil,
 )
 
 if TYPE_CHECKING:
     from . import localrepo
 
     assert [localrepo]
 
 subsettable = repoviewutil.subsettable
 
 calcsize = struct.calcsize
 pack_into = struct.pack_into
 unpack_from = struct.unpack_from
 
 
 class BranchMapCache:
     """mapping of filtered views of repo with their branchcache"""
 
     def __init__(self):
         self._per_filter = {}
 
     def __getitem__(self, repo):
         self.updatecache(repo)
         bcache = self._per_filter[repo.filtername]
+        bcache._ensure_populated(repo)
         assert bcache._filtername == repo.filtername, (
             bcache._filtername,
             repo.filtername,
         )
         return bcache
 
     def update_disk(self, repo):
         """ensure and up-to-date cache is (or will be) written on disk
 
         The cache for this repository view is updated  if needed and written on
         disk.
 
         If a transaction is in progress, the writing is schedule to transaction
         close. See the `BranchMapCache.write_dirty` method.
 
         This method exist independently of __getitem__ as it is sometime useful
         to signal that we have no intend to use the data in memory yet.
         """
         self.updatecache(repo)
         bcache = self._per_filter[repo.filtername]
         assert bcache._filtername == repo.filtername, (
             bcache._filtername,
             repo.filtername,
         )
         tr = repo.currenttransaction()
         if getattr(tr, 'finalized', True):
             bcache.sync_disk(repo)
 
     def updatecache(self, repo):
         """Update the cache for the given filtered view on a repository"""
         # This can trigger updates for the caches for subsets of the filtered
         # view, e.g. when there is no cache for this filtered view or the cache
         # is stale.
 
         cl = repo.changelog
         filtername = repo.filtername
         bcache = self._per_filter.get(filtername)
         if bcache is None or not bcache.validfor(repo):
             # cache object missing or cache object stale? Read from disk
             bcache = branch_cache_from_file(repo)
 
         revs = []
         if bcache is None:
             # no (fresh) cache available anymore, perhaps we can re-use
             # the cache for a subset, then extend that to add info on missing
             # revisions.
             subsetname = subsettable.get(filtername)
             if subsetname is not None:
                 subset = repo.filtered(subsetname)
                 self.updatecache(subset)
                 bcache = self._per_filter[subset.filtername].inherit_for(repo)
                 extrarevs = subset.changelog.filteredrevs - cl.filteredrevs
                 revs.extend(r for r in extrarevs if r <= bcache.tiprev)
             else:
                 # nothing to fall back on, start empty.
                 bcache = new_branch_cache(repo)
 
         revs.extend(cl.revs(start=bcache.tiprev + 1))
         if revs:
             bcache.update(repo, revs)
 
         assert bcache.validfor(repo), filtername
         self._per_filter[repo.filtername] = bcache
 
     def replace(self, repo, remotebranchmap):
         """Replace the branchmap cache for a repo with a branch mapping.
 
         This is likely only called during clone with a branch map from a
         remote.
 
         """
         cl = repo.changelog
         clrev = cl.rev
         clbranchinfo = cl.branchinfo
         rbheads = []
         closed = set()
         for bheads in remotebranchmap.values():
             rbheads += bheads
             for h in bheads:
                 r = clrev(h)
                 b, c = clbranchinfo(r)
                 if c:
                     closed.add(h)
 
         if rbheads:
             rtiprev = max((int(clrev(node)) for node in rbheads))
             cache = new_branch_cache(
                 repo,
                 remotebranchmap,
                 repo[rtiprev].node(),
                 rtiprev,
                 closednodes=closed,
             )
 
             # Try to stick it as low as possible
             # filter above served are unlikely to be fetch from a clone
             for candidate in (b'base', b'immutable', b'served'):
                 rview = repo.filtered(candidate)
                 if cache.validfor(rview):
                     cache._filtername = candidate
                     self._per_filter[candidate] = cache
                     cache._state = STATE_DIRTY
                     cache.write(rview)
                     return
 
     def clear(self):
         self._per_filter.clear()
 
     def write_dirty(self, repo):
         unfi = repo.unfiltered()
         for filtername in repoviewutil.get_ordered_subset():
             cache = self._per_filter.get(filtername)
             if cache is None:
                 continue
             if filtername is None:
                 repo = unfi
             else:
                 repo = unfi.filtered(filtername)
             cache.sync_disk(repo)
 
 
 def _unknownnode(node):
     """raises ValueError when branchcache found a node which does not exists"""
     raise ValueError('node %s does not exist' % node.hex())
 
 
 def _branchcachedesc(repo):
     if repo.filtername is not None:
         return b'branch cache (%s)' % repo.filtername
     else:
         return b'branch cache'
 
 
 class _BaseBranchCache:
     """A dict like object that hold branches heads cache.
 
     This cache is used to avoid costly computations to determine all the
     branch heads of a repo.
     """
 
     def __init__(
         self,
         repo: "localrepo.localrepository",
         entries: Union[
             Dict[bytes, List[bytes]], Iterable[Tuple[bytes, List[bytes]]]
         ] = (),
         closed_nodes: Optional[Set[bytes]] = None,
     ) -> None:
         """hasnode is a function which can be used to verify whether changelog
         has a given node or not. If it's not provided, we assume that every node
         we have exists in changelog"""
         # closednodes is a set of nodes that close their branch. If the branch
         # cache has been updated, it may contain nodes that are no longer
         # heads.
         if closed_nodes is None:
             closed_nodes = set()
         self._closednodes = set(closed_nodes)
         self._entries = dict(entries)
 
     def __iter__(self):
         return iter(self._entries)
 
     def __setitem__(self, key, value):
         self._entries[key] = value
 
     def __getitem__(self, key):
         return self._entries[key]
 
     def __contains__(self, key):
         return key in self._entries
 
     def iteritems(self):
         return self._entries.items()
 
     items = iteritems
 
     def hasbranch(self, label):
         """checks whether a branch of this name exists or not"""
         return label in self._entries
 
     def _branchtip(self, heads):
         """Return tuple with last open head in heads and false,
         otherwise return last closed head and true."""
         tip = heads[-1]
         closed = True
         for h in reversed(heads):
             if h not in self._closednodes:
                 tip = h
                 closed = False
                 break
         return tip, closed
 
     def branchtip(self, branch):
         """Return the tipmost open head on branch head, otherwise return the
         tipmost closed head on branch.
         Raise KeyError for unknown branch."""
         return self._branchtip(self[branch])[0]
 
     def iteropen(self, nodes):
         return (n for n in nodes if n not in self._closednodes)
 
     def branchheads(self, branch, closed=False):
         heads = self._entries[branch]
         if not closed:
             heads = list(self.iteropen(heads))
         return heads
 
     def iterbranches(self):
         for bn, heads in self.items():
             yield (bn, heads) + self._branchtip(heads)
 
     def iterheads(self):
         """returns all the heads"""
         return self._entries.values()
 
     def update(self, repo, revgen):
         """Given a branchhead cache, self, that may have extra nodes or be
         missing heads, and a generator of nodes that are strictly a superset of
         heads missing, this function updates self to be correct.
         """
         starttime = util.timer()
         cl = repo.changelog
         # Faster than using ctx.obsolete()
         obsrevs = obsolete.getrevs(repo, b'obsolete')
         # collect new branch entries
         newbranches = {}
         new_closed = set()
         obs_ignored = set()
         getbranchinfo = repo.revbranchcache().branchinfo
         max_rev = -1
         for r in revgen:
             max_rev = max(max_rev, r)
             if r in obsrevs:
                 # We ignore obsolete changesets as they shouldn't be
                 # considered heads.
                 obs_ignored.add(r)
                 continue
             branch, closesbranch = getbranchinfo(r)
             newbranches.setdefault(branch, []).append(r)
             if closesbranch:
                 new_closed.add(r)
         if max_rev < 0:
             msg = "running branchcache.update without revision to update"
             raise error.ProgrammingError(msg)
 
         self._process_new(
             repo,
             newbranches,
             new_closed,
             obs_ignored,
             max_rev,
         )
 
         self._closednodes.update(cl.node(rev) for rev in new_closed)
 
         duration = util.timer() - starttime
         repo.ui.log(
             b'branchcache',
             b'updated %s in %.4f seconds\n',
             _branchcachedesc(repo),
             duration,
         )
         return max_rev
 
     def _process_new(
         self,
         repo,
         newbranches,
         new_closed,
         obs_ignored,
         max_rev,
     ):
         """update the branchmap from a set of new information"""
         # Delay fetching the topological heads until they are needed.
         # A repository without non-continous branches can skip this part.
         topoheads = None
 
         cl = repo.changelog
         getbranchinfo = repo.revbranchcache().branchinfo
         # Faster than using ctx.obsolete()
         obsrevs = obsolete.getrevs(repo, b'obsolete')
 
         # If a changeset is visible, its parents must be visible too, so
         # use the faster unfiltered parent accessor.
         parentrevs = cl._uncheckedparentrevs
 
         for branch, newheadrevs in newbranches.items():
             # For every branch, compute the new branchheads.
             # A branchhead is a revision such that no descendant is on
             # the same branch.
             #
             # The branchheads are computed iteratively in revision order.
             # This ensures topological order, i.e. parents are processed
             # before their children. Ancestors are inclusive here, i.e.
             # any revision is an ancestor of itself.
             #
             # Core observations:
             # - The current revision is always a branchhead for the
             #   repository up to that point.
             # - It is the first revision of the branch if and only if
             #   there was no branchhead before. In that case, it is the
             #   only branchhead as there are no possible ancestors on
             #   the same branch.
             # - If a parent is on the same branch, a branchhead can
             #   only be an ancestor of that parent, if it is parent
             #   itself. Otherwise it would have been removed as ancestor
             #   of that parent before.
             # - Therefore, if all parents are on the same branch, they
             #   can just be removed from the branchhead set.
             # - If one parent is on the same branch and the other is not
             #   and there was exactly one branchhead known, the existing
             #   branchhead can only be an ancestor if it is the parent.
             #   Otherwise it would have been removed as ancestor of
             #   the parent before. The other parent therefore can't have
             #   a branchhead as ancestor.
             # - In all other cases, the parents on different branches
             #   could have a branchhead as ancestor. Those parents are
             #   kept in the "uncertain" set. If all branchheads are also
             #   topological heads, they can't have descendants and further
             #   checks can be skipped. Otherwise, the ancestors of the
             #   "uncertain" set are removed from branchheads.
             #   This computation is heavy and avoided if at all possible.
             bheads = self._entries.get(branch, [])
             bheadset = {cl.rev(node) for node in bheads}
             uncertain = set()
             for newrev in sorted(newheadrevs):
                 if not bheadset:
                     bheadset.add(newrev)
                     continue
 
                 parents = [p for p in parentrevs(newrev) if p != nullrev]
                 samebranch = set()
                 otherbranch = set()
                 obsparents = set()
                 for p in parents:
                     if p in obsrevs:
                         # We ignored this obsolete changeset earlier, but now
                         # that it has non-ignored children, we need to make
                         # sure their ancestors are not considered heads. To
                         # achieve that, we will simply treat this obsolete
                         # changeset as a parent from other branch.
                         obsparents.add(p)
                     elif p in bheadset or getbranchinfo(p)[0] == branch:
                         samebranch.add(p)
                     else:
                         otherbranch.add(p)
                 if not (len(bheadset) == len(samebranch) == 1):
                     uncertain.update(otherbranch)
                     uncertain.update(obsparents)
                 bheadset.difference_update(samebranch)
                 bheadset.add(newrev)
 
             if uncertain:
                 if topoheads is None:
                     topoheads = set(cl.headrevs())
                 if bheadset - topoheads:
                     floorrev = min(bheadset)
                     if floorrev <= max(uncertain):
                         ancestors = set(cl.ancestors(uncertain, floorrev))
                         bheadset -= ancestors
             if bheadset:
                 self[branch] = [cl.node(rev) for rev in sorted(bheadset)]
 
 
 STATE_CLEAN = 1
 STATE_INHERITED = 2
 STATE_DIRTY = 3
 
 
 class _LocalBranchCache(_BaseBranchCache):
     """base class of branch-map info for a local repo or repoview"""
 
     _base_filename = None
     _default_key_hashes: Tuple[bytes] = cast(Tuple[bytes], ())
 
     def __init__(
         self,
         repo: "localrepo.localrepository",
         entries: Union[
             Dict[bytes, List[bytes]], Iterable[Tuple[bytes, List[bytes]]]
         ] = (),
         tipnode: Optional[bytes] = None,
         tiprev: Optional[int] = nullrev,
         key_hashes: Optional[Tuple[bytes]] = None,
         closednodes: Optional[Set[bytes]] = None,
         hasnode: Optional[Callable[[bytes], bool]] = None,
         verify_node: bool = False,
         inherited: bool = False,
     ) -> None:
         """hasnode is a function which can be used to verify whether changelog
         has a given node or not. If it's not provided, we assume that every node
         we have exists in changelog"""
         self._filtername = repo.filtername
         if tipnode is None:
             self.tipnode = repo.nullid
         else:
             self.tipnode = tipnode
         self.tiprev = tiprev
         if key_hashes is None:
             self.key_hashes = self._default_key_hashes
         else:
             self.key_hashes = key_hashes
         self._state = STATE_CLEAN
         if inherited:
             self._state = STATE_INHERITED
 
         super().__init__(repo=repo, entries=entries, closed_nodes=closednodes)
         # closednodes is a set of nodes that close their branch. If the branch
         # cache has been updated, it may contain nodes that are no longer
         # heads.
 
         # Do we need to verify branch at all ?
         self._verify_node = verify_node
         # branches for which nodes are verified
         self._verifiedbranches = set()
         self._hasnode = None
         if self._verify_node:
             self._hasnode = repo.changelog.hasnode
 
     def _compute_key_hashes(self, repo) -> Tuple[bytes]:
         raise NotImplementedError
 
+    def _ensure_populated(self, repo):
+        """make sure any lazily loaded values are fully populated"""
+
     def validfor(self, repo):
         """check that cache contents are valid for (a subset of) this repo
 
         - False when the order of changesets changed or if we detect a strip.
         - True when cache is up-to-date for the current repo or its subset."""
         try:
             node = repo.changelog.node(self.tiprev)
         except IndexError:
             # changesets were stripped and now we don't even have enough to
             # find tiprev
             return False
         if self.tipnode != node:
             # tiprev doesn't correspond to tipnode: repo was stripped, or this
             # repo has a different order of changesets
             return False
         repo_key_hashes = self._compute_key_hashes(repo)
         # hashes don't match if this repo view has a different set of filtered
         # revisions (e.g. due to phase changes) or obsolete revisions (e.g.
         # history was rewritten)
         return self.key_hashes == repo_key_hashes
 
     @classmethod
     def fromfile(cls, repo):
         f = None
         try:
             f = repo.cachevfs(cls._filename(repo))
             lineiter = iter(f)
             init_kwargs = cls._load_header(repo, lineiter)
             bcache = cls(
                 repo,
                 verify_node=True,
                 **init_kwargs,
             )
             if not bcache.validfor(repo):
                 # invalidate the cache
                 raise ValueError('tip differs')
             bcache._load_heads(repo, lineiter)
         except (IOError, OSError):
             return None
 
         except Exception as inst:
             if repo.ui.debugflag:
                 msg = b'invalid %s: %s\n'
                 msg %= (
                     _branchcachedesc(repo),
                     stringutil.forcebytestr(inst),
                 )
                 repo.ui.debug(msg)
             bcache = None
 
         finally:
             if f:
                 f.close()
 
         return bcache
 
     @classmethod
     def _load_header(cls, repo, lineiter) -> "dict[str, Any]":
         raise NotImplementedError
 
     def _load_heads(self, repo, lineiter):
         """fully loads the branchcache by reading from the file using the line
         iterator passed"""
         for line in lineiter:
             line = line.rstrip(b'\n')
             if not line:
                 continue
             node, state, label = line.split(b" ", 2)
             if state not in b'oc':
                 raise ValueError('invalid branch state')
             label = encoding.tolocal(label.strip())
             node = bin(node)
             self._entries.setdefault(label, []).append(node)
             if state == b'c':
                 self._closednodes.add(node)
 
     @classmethod
     def _filename(cls, repo):
         """name of a branchcache file for a given repo or repoview"""
         filename = cls._base_filename
         assert filename is not None
         if repo.filtername:
             filename = b'%s-%s' % (filename, repo.filtername)
         return filename
 
     def inherit_for(self, repo):
         """return a deep copy of the branchcache object"""
         assert repo.filtername != self._filtername
         other = type(self)(
             repo=repo,
             # we always do a shally copy of self._entries, and the values is
             # always replaced, so no need to deepcopy until the above remains
             # true.
             entries=self._entries,
             tipnode=self.tipnode,
             tiprev=self.tiprev,
             key_hashes=self.key_hashes,
             closednodes=set(self._closednodes),
             verify_node=self._verify_node,
             inherited=True,
         )
         # also copy information about the current verification state
         other._verifiedbranches = set(self._verifiedbranches)
         return other
 
     def sync_disk(self, repo):
         """synchronise the on disk file with the cache state
 
         If new value specific to this filter level need to be written, the file
         will be updated, if the state of the branchcache is inherited from a
         subset, any stalled on disk file will be deleted.
 
         That method does nothing if there is nothing to do.
         """
         if self._state == STATE_DIRTY:
             self.write(repo)
         elif self._state == STATE_INHERITED:
             filename = self._filename(repo)
             repo.cachevfs.tryunlink(filename)
 
     def write(self, repo):
         assert self._filtername == repo.filtername, (
             self._filtername,
             repo.filtername,
         )
         assert self._state == STATE_DIRTY, self._state
         # This method should not be called during an open transaction
         tr = repo.currenttransaction()
         if not getattr(tr, 'finalized', True):
             msg = "writing branchcache in the middle of a transaction"
             raise error.ProgrammingError(msg)
         try:
             filename = self._filename(repo)
             with repo.cachevfs(filename, b"w", atomictemp=True) as f:
                 self._write_header(f)
                 nodecount = self._write_heads(repo, f)
             repo.ui.log(
                 b'branchcache',
                 b'wrote %s with %d labels and %d nodes\n',
                 _branchcachedesc(repo),
                 len(self._entries),
                 nodecount,
             )
             self._state = STATE_CLEAN
         except (IOError, OSError, error.Abort) as inst:
             # Abort may be raised by read only opener, so log and continue
             repo.ui.debug(
                 b"couldn't write branch cache: %s\n"
                 % stringutil.forcebytestr(inst)
             )
 
     def _write_header(self, fp) -> None:
         raise NotImplementedError
 
     def _write_heads(self, repo, fp) -> int:
         """write list of heads to a file
 
         Return the number of heads written."""
         nodecount = 0
         for label, nodes in sorted(self._entries.items()):
             label = encoding.fromlocal(label)
             for node in nodes:
                 nodecount += 1
                 if node in self._closednodes:
                     state = b'c'
                 else:
                     state = b'o'
                 fp.write(b"%s %s %s\n" % (hex(node), state, label))
         return nodecount
 
     def _verifybranch(self, branch):
         """verify head nodes for the given branch."""
         if not self._verify_node:
             return
         if branch not in self._entries or branch in self._verifiedbranches:
             return
         assert self._hasnode is not None
         for n in self._entries[branch]:
             if not self._hasnode(n):
                 _unknownnode(n)
 
         self._verifiedbranches.add(branch)
 
     def _verifyall(self):
         """verifies nodes of all the branches"""
         for b in self._entries.keys():
             if b not in self._verifiedbranches:
                 self._verifybranch(b)
 
     def __getitem__(self, key):
         self._verifybranch(key)
         return super().__getitem__(key)
 
     def __contains__(self, key):
         self._verifybranch(key)
         return super().__contains__(key)
 
     def iteritems(self):
         self._verifyall()
         return super().iteritems()
 
     items = iteritems
 
     def iterheads(self):
         """returns all the heads"""
         self._verifyall()
         return super().iterheads()
 
     def hasbranch(self, label):
         """checks whether a branch of this name exists or not"""
         self._verifybranch(label)
         return super().hasbranch(label)
 
     def branchheads(self, branch, closed=False):
         self._verifybranch(branch)
         return super().branchheads(branch, closed=closed)
 
     def update(self, repo, revgen):
         assert self._filtername == repo.filtername, (
             self._filtername,
             repo.filtername,
         )
         cl = repo.changelog
         max_rev = super().update(repo, revgen)
         # new tip revision which we found after iterating items from new
         # branches
         if max_rev is not None and max_rev > self.tiprev:
             self.tiprev = max_rev
             self.tipnode = cl.node(max_rev)
         else:
             # We should not be here is if this is false
             assert cl.node(self.tiprev) == self.tipnode
 
         if not self.validfor(repo):
             # the tiprev and tipnode should be aligned, so if the current repo
             # is not seens as valid this is because old cache key is now
             # invalid for the repo.
             #
             # However. we've just updated the cache and we assume it's valid,
             # so let's make the cache key valid as well by recomputing it from
             # the cached data
             self.key_hashes = self._compute_key_hashes(repo)
             self.filteredhash = scmutil.combined_filtered_and_obsolete_hash(
                 repo,
                 self.tiprev,
             )
 
         self._state = STATE_DIRTY
         tr = repo.currenttransaction()
         if getattr(tr, 'finalized', True):
             # Avoid premature writing.
             #
             # (The cache warming setup by localrepo will update the file later.)
             self.write(repo)
 
 
 def branch_cache_from_file(repo) -> Optional[_LocalBranchCache]:
     """Build a branch cache from on-disk data if possible
 
     Return a branch cache of the right format depending of the repository.
     """
     if repo.ui.configbool(b"experimental", b"branch-cache-v3"):
         return BranchCacheV3.fromfile(repo)
     else:
         return BranchCacheV2.fromfile(repo)
 
 
 def new_branch_cache(repo, *args, **kwargs):
     """Build a new branch cache from argument
 
     Return a branch cache of the right format depending of the repository.
     """
     if repo.ui.configbool(b"experimental", b"branch-cache-v3"):
         return BranchCacheV3(repo, *args, **kwargs)
     else:
         return BranchCacheV2(repo, *args, **kwargs)
 
 
 class BranchCacheV2(_LocalBranchCache):
     """a branch cache using version 2 of the format on disk
 
     The cache is serialized on disk in the following format:
 
     <tip hex node> <tip rev number> [optional filtered repo hex hash]
     <branch head hex node> <open/closed state> <branch name>
     <branch head hex node> <open/closed state> <branch name>
     ...
 
     The first line is used to check if the cache is still valid. If the
     branch cache is for a filtered repo view, an optional third hash is
     included that hashes the hashes of all filtered and obsolete revisions.
 
     The open/closed state is represented by a single letter 'o' or 'c'.
     This field can be used to avoid changelog reads when determining if a
     branch head closes a branch or not.
     """
 
     _base_filename = b"branch2"
 
     @classmethod
     def _load_header(cls, repo, lineiter) -> "dict[str, Any]":
         """parse the head of a branchmap file
 
         return parameters to pass to a newly created class instance.
         """
         cachekey = next(lineiter).rstrip(b'\n').split(b" ", 2)
         last, lrev = cachekey[:2]
         last, lrev = bin(last), int(lrev)
         filteredhash = ()
         if len(cachekey) > 2:
             filteredhash = (bin(cachekey[2]),)
         return {
             "tipnode": last,
             "tiprev": lrev,
             "key_hashes": filteredhash,
         }
 
     def _write_header(self, fp) -> None:
         """write the branch cache header to a file"""
         cachekey = [hex(self.tipnode), b'%d' % self.tiprev]
         if self.key_hashes:
             cachekey.append(hex(self.key_hashes[0]))
         fp.write(b" ".join(cachekey) + b'\n')
 
     def _compute_key_hashes(self, repo) -> Tuple[bytes]:
         """return the cache key hashes that match this repoview state"""
         filtered_hash = scmutil.combined_filtered_and_obsolete_hash(
             repo,
             self.tiprev,
             needobsolete=True,
         )
         keys: Tuple[bytes] = cast(Tuple[bytes], ())
         if filtered_hash is not None:
             keys: Tuple[bytes] = (filtered_hash,)
         return keys
 
 
 class BranchCacheV3(_LocalBranchCache):
     """a branch cache using version 3 of the format on disk
 
     This version is still EXPERIMENTAL and the format is subject to changes.
 
     The cache is serialized on disk in the following format:
 
     <cache-key-xxx>=<xxx-value> <cache-key-yyy>=<yyy-value> […]
     <branch head hex node> <open/closed state> <branch name>
     <branch head hex node> <open/closed state> <branch name>
     ...
 
     The first line is used to check if the cache is still valid. It is a series
     of key value pair. The following key are recognized:
 
     - tip-rev: the rev-num of the tip-most revision seen by this cache
     - tip-node: the node-id of the tip-most revision sen by this cache
     - filtered-hash: the hash of all filtered revisions (before tip-rev)
                      ignored by this cache.
     - obsolete-hash: the hash of all non-filtered obsolete revisions (before
                      tip-rev) ignored by this cache.
 
     The tip-rev is used to know how far behind the value in the file are
     compared to the current repository state.
 
     The tip-node, filtered-hash and obsolete-hash are used to detect if this
     cache can be used for this repository state at all.
 
     The open/closed state is represented by a single letter 'o' or 'c'.
     This field can be used to avoid changelog reads when determining if a
     branch head closes a branch or not.
 
     Topological heads are not included in the listing and should be dispatched
     on the right branch at read time. Obsolete topological heads should be
     ignored.
     """
 
     _base_filename = b"branch3"
     _default_key_hashes = (None, None)
 
-    def _get_topo_heads(self, repo) -> List[int]:
+    def __init__(self, *args, pure_topo_branch=None, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._pure_topo_branch = pure_topo_branch
+        self._needs_populate = self._pure_topo_branch is not None
+
+    def inherit_for(self, repo):
+        new = super().inherit_for(repo)
+        new._pure_topo_branch = self._pure_topo_branch
+        new._needs_populate = self._needs_populate
+        return new
+
+    def _get_topo_heads(self, repo):
         """returns the topological head of a repoview content up to self.tiprev"""
         cl = repo.changelog
         if self.tiprev == nullrev:
             return []
         elif self.tiprev == cl.tiprev():
             return cl.headrevs()
         else:
             # XXX passing tiprev as ceiling of cl.headrevs could be faster
             heads = cl.headrevs(cl.revs(stop=self.tiprev))
             return heads
 
     def _write_header(self, fp) -> None:
         cache_keys = {
             b"tip-node": hex(self.tipnode),
             b"tip-rev": b'%d' % self.tiprev,
         }
         if self.key_hashes:
             if self.key_hashes[0] is not None:
                 cache_keys[b"filtered-hash"] = hex(self.key_hashes[0])
             if self.key_hashes[1] is not None:
                 cache_keys[b"obsolete-hash"] = hex(self.key_hashes[1])
+        if self._pure_topo_branch is not None:
+            cache_keys[b"topo-mode"] = b"pure"
         pieces = (b"%s=%s" % i for i in sorted(cache_keys.items()))
         fp.write(b" ".join(pieces) + b'\n')
+        if self._pure_topo_branch is not None:
+            label = encoding.fromlocal(self._pure_topo_branch)
+            fp.write(label + b'\n')
 
     def _write_heads(self, repo, fp) -> int:
         """write list of heads to a file
 
         Return the number of heads written."""
         nodecount = 0
-        topo_heads = set(self._get_topo_heads(repo))
+        topo_heads = None
+        if self._pure_topo_branch is None:
+            topo_heads = set(self._get_topo_heads(repo))
         to_rev = repo.changelog.index.rev
         for label, nodes in sorted(self._entries.items()):
+            if label == self._pure_topo_branch:
+                # not need to write anything the header took care of that
+                continue
             label = encoding.fromlocal(label)
             for node in nodes:
-                rev = to_rev(node)
-                if rev in topo_heads:
-                    continue
+                if topo_heads is not None:
+                    rev = to_rev(node)
+                    if rev in topo_heads:
+                        continue
                 if node in self._closednodes:
                     state = b'c'
                 else:
                     state = b'o'
                 nodecount += 1
                 fp.write(b"%s %s %s\n" % (hex(node), state, label))
         return nodecount
 
     @classmethod
     def _load_header(cls, repo, lineiter):
         header_line = next(lineiter)
         pieces = header_line.rstrip(b'\n').split(b" ")
         cache_keys = dict(p.split(b'=', 1) for p in pieces)
 
         args = {}
         filtered_hash = None
         obsolete_hash = None
+        has_pure_topo_heads = False
         for k, v in cache_keys.items():
             if k == b"tip-rev":
                 args["tiprev"] = int(v)
             elif k == b"tip-node":
                 args["tipnode"] = bin(v)
             elif k == b"filtered-hash":
                 filtered_hash = bin(v)
             elif k == b"obsolete-hash":
                 obsolete_hash = bin(v)
+            elif k == b"topo-mode":
+                if v == b"pure":
+                    has_pure_topo_heads = True
+                else:
+                    msg = b"unknown topo-mode: %r" % v
+                    raise ValueError(msg)
             else:
                 msg = b"unknown cache key: %r" % k
                 raise ValueError(msg)
         args["key_hashes"] = (filtered_hash, obsolete_hash)
+        if has_pure_topo_heads:
+            pure_line = next(lineiter).rstrip(b'\n')
+            args["pure_topo_branch"] = encoding.tolocal(pure_line)
         return args
 
     def _load_heads(self, repo, lineiter):
         """fully loads the branchcache by reading from the file using the line
         iterator passed"""
         super()._load_heads(repo, lineiter)
+        if self._pure_topo_branch is not None:
+            # no need to read the repository heads, we know their value already.
+            return
         cl = repo.changelog
         getbranchinfo = repo.revbranchcache().branchinfo
         obsrevs = obsolete.getrevs(repo, b'obsolete')
         to_node = cl.node
         touched_branch = set()
         for head in self._get_topo_heads(repo):
             if head in obsrevs:
                 continue
             node = to_node(head)
             branch, closed = getbranchinfo(head)
             self._entries.setdefault(branch, []).append(node)
             if closed:
                 self._closednodes.add(node)
             touched_branch.add(branch)
         to_rev = cl.index.rev
         for branch in touched_branch:
             self._entries[branch].sort(key=to_rev)
 
     def _compute_key_hashes(self, repo) -> Tuple[bytes]:
         """return the cache key hashes that match this repoview state"""
         return scmutil.filtered_and_obsolete_hash(
             repo,
             self.tiprev,
         )
 
+    def _process_new(
+        self,
+        repo,
+        newbranches,
+        new_closed,
+        obs_ignored,
+        max_rev,
+    ) -> None:
+        if (
+            # note: the check about `obs_ignored` is too strict as the
+            # obsolete revision could be non-topological, but lets keep
+            # things simple for now
+            #
+            # The same apply to `new_closed` if the closed changeset are
+            # not a head, we don't care that it is closed, but lets keep
+            # things simple here too.
+            not (obs_ignored or new_closed)
+            and (
+                not newbranches
+                or (
+                    len(newbranches) == 1
+                    and (
+                        self.tiprev == nullrev
+                        or self._pure_topo_branch in newbranches
+                    )
+                )
+            )
+        ):
+            if newbranches:
+                assert len(newbranches) == 1
+                self._pure_topo_branch = list(newbranches.keys())[0]
+                self._needs_populate = True
+                self._entries.pop(self._pure_topo_branch, None)
+            return
+
+        self._ensure_populated(repo)
+        self._pure_topo_branch = None
+        super()._process_new(
+            repo,
+            newbranches,
+            new_closed,
+            obs_ignored,
+            max_rev,
+        )
+
+    def _ensure_populated(self, repo):
+        """make sure any lazily loaded values are fully populated"""
+        if self._needs_populate:
+            assert self._pure_topo_branch is not None
+            cl = repo.changelog
+            to_node = cl.node
+            topo_heads = self._get_topo_heads(repo)
+            heads = [to_node(r) for r in topo_heads]
+            self._entries[self._pure_topo_branch] = heads
+            self._needs_populate = False
+
 
 class remotebranchcache(_BaseBranchCache):
     """Branchmap info for a remote connection, should not write locally"""
 
     def __init__(
         self,
         repo: "localrepo.localrepository",
         entries: Union[
             Dict[bytes, List[bytes]], Iterable[Tuple[bytes, List[bytes]]]
         ] = (),
         closednodes: Optional[Set[bytes]] = None,
     ) -> None:
         super().__init__(repo=repo, entries=entries, closed_nodes=closednodes)
 
 
 # Revision branch info cache
 
 _rbcversion = b'-v1'
 _rbcnames = b'rbc-names' + _rbcversion
 _rbcrevs = b'rbc-revs' + _rbcversion
 # [4 byte hash prefix][4 byte branch name number with sign bit indicating open]
 _rbcrecfmt = b'>4sI'
 _rbcrecsize = calcsize(_rbcrecfmt)
 _rbcmininc = 64 * _rbcrecsize
 _rbcnodelen = 4
 _rbcbranchidxmask = 0x7FFFFFFF
 _rbccloseflag = 0x80000000
 
 
 class rbcrevs:
     """a byte string consisting of an immutable prefix followed by a mutable suffix"""
 
     def __init__(self, revs):
         self._prefix = revs
         self._rest = bytearray()
 
     def __len__(self):
         return len(self._prefix) + len(self._rest)
 
     def unpack_record(self, rbcrevidx):
         if rbcrevidx < len(self._prefix):
             return unpack_from(_rbcrecfmt, util.buffer(self._prefix), rbcrevidx)
         else:
             return unpack_from(
                 _rbcrecfmt,
                 util.buffer(self._rest),
                 rbcrevidx - len(self._prefix),
             )
 
     def make_mutable(self):
         if len(self._prefix) > 0:
             entirety = bytearray()
             entirety[:] = self._prefix
             entirety.extend(self._rest)
             self._rest = entirety
             self._prefix = bytearray()
 
     def truncate(self, pos):
         self.make_mutable()
         del self._rest[pos:]
 
     def pack_into(self, rbcrevidx, node, branchidx):
         if rbcrevidx < len(self._prefix):
             self.make_mutable()
         buf = self._rest
         start_offset = rbcrevidx - len(self._prefix)
         end_offset = start_offset + _rbcrecsize
 
         if len(self._rest) < end_offset:
             # bytearray doesn't allocate extra space at least in Python 3.7.
             # When multiple changesets are added in a row, precise resize would
             # result in quadratic complexity. Overallocate to compensate by
             # using the classic doubling technique for dynamic arrays instead.
             # If there was a gap in the map before, less space will be reserved.
             self._rest.extend(b'\0' * end_offset)
         return pack_into(
             _rbcrecfmt,
             buf,
             start_offset,
             node,
             branchidx,
         )
 
     def extend(self, extension):
         return self._rest.extend(extension)
 
     def slice(self, begin, end):
         if begin < len(self._prefix):
             acc = bytearray()
             acc[:] = self._prefix[begin:end]
             acc.extend(
                 self._rest[begin - len(self._prefix) : end - len(self._prefix)]
             )
             return acc
         return self._rest[begin - len(self._prefix) : end - len(self._prefix)]
 
 
 class revbranchcache:
     """Persistent cache, mapping from revision number to branch name and close.
     This is a low level cache, independent of filtering.
 
     Branch names are stored in rbc-names in internal encoding separated by 0.
     rbc-names is append-only, and each branch name is only stored once and will
     thus have a unique index.
 
     The branch info for each revision is stored in rbc-revs as constant size
     records. The whole file is read into memory, but it is only 'parsed' on
     demand. The file is usually append-only but will be truncated if repo
     modification is detected.
     The record for each revision contains the first 4 bytes of the
     corresponding node hash, and the record is only used if it still matches.
     Even a completely trashed rbc-revs fill thus still give the right result
     while converging towards full recovery ... assuming no incorrectly matching
     node hashes.
     The record also contains 4 bytes where 31 bits contains the index of the
     branch and the last bit indicate that it is a branch close commit.
     The usage pattern for rbc-revs is thus somewhat similar to 00changelog.i
     and will grow with it but be 1/8th of its size.
     """
 
     def __init__(self, repo, readonly=True):
         assert repo.filtername is None
         self._repo = repo
         self._names = []  # branch names in local encoding with static index
         self._rbcrevs = rbcrevs(bytearray())
         self._rbcsnameslen = 0  # length of names read at _rbcsnameslen
         try:
             bndata = repo.cachevfs.read(_rbcnames)
             self._rbcsnameslen = len(bndata)  # for verification before writing
             if bndata:
                 self._names = [
                     encoding.tolocal(bn) for bn in bndata.split(b'\0')
                 ]
         except (IOError, OSError):
             if readonly:
                 # don't try to use cache - fall back to the slow path
                 self.branchinfo = self._branchinfo
 
         if self._names:
             try:
                 if repo.ui.configbool(b'storage', b'revbranchcache.mmap'):
                     with repo.cachevfs(_rbcrevs) as fp:
                         data = util.buffer(util.mmapread(fp))
                 else:
                     data = repo.cachevfs.read(_rbcrevs)
                 self._rbcrevs = rbcrevs(data)
             except (IOError, OSError) as inst:
                 repo.ui.debug(
                     b"couldn't read revision branch cache: %s\n"
                     % stringutil.forcebytestr(inst)
                 )
         # remember number of good records on disk
         self._rbcrevslen = min(
             len(self._rbcrevs) // _rbcrecsize, len(repo.changelog)
         )
         if self._rbcrevslen == 0:
             self._names = []
         self._rbcnamescount = len(self._names)  # number of names read at
         # _rbcsnameslen
 
     def _clear(self):
         self._rbcsnameslen = 0
         del self._names[:]
         self._rbcnamescount = 0
         self._rbcrevslen = len(self._repo.changelog)
         self._rbcrevs = rbcrevs(bytearray(self._rbcrevslen * _rbcrecsize))
         util.clearcachedproperty(self, b'_namesreverse')
 
     @util.propertycache
     def _namesreverse(self):
         return {b: r for r, b in enumerate(self._names)}
 
     def branchinfo(self, rev):
         """Return branch name and close flag for rev, using and updating
         persistent cache."""
         changelog = self._repo.changelog
         rbcrevidx = rev * _rbcrecsize
 
         # avoid negative index, changelog.read(nullrev) is fast without cache
         if rev == nullrev:
             return changelog.branchinfo(rev)
 
         # if requested rev isn't allocated, grow and cache the rev info
         if len(self._rbcrevs) < rbcrevidx + _rbcrecsize:
             return self._branchinfo(rev)
 
         # fast path: extract data from cache, use it if node is matching
         reponode = changelog.node(rev)[:_rbcnodelen]
         cachenode, branchidx = self._rbcrevs.unpack_record(rbcrevidx)
         close = bool(branchidx & _rbccloseflag)
         if close:
             branchidx &= _rbcbranchidxmask
         if cachenode == b'\0\0\0\0':
             pass
         elif cachenode == reponode:
             try:
                 return self._names[branchidx], close
             except IndexError:
                 # recover from invalid reference to unknown branch
                 self._repo.ui.debug(
                     b"referenced branch names not found"
                     b" - rebuilding revision branch cache from scratch\n"
                 )
                 self._clear()
         else:
             # rev/node map has changed, invalidate the cache from here up
             self._repo.ui.debug(
                 b"history modification detected - truncating "
                 b"revision branch cache to revision %d\n" % rev
             )
             truncate = rbcrevidx + _rbcrecsize
             self._rbcrevs.truncate(truncate)
             self._rbcrevslen = min(self._rbcrevslen, truncate)
 
         # fall back to slow path and make sure it will be written to disk
         return self._branchinfo(rev)
 
     def _branchinfo(self, rev):
         """Retrieve branch info from changelog and update _rbcrevs"""
         changelog = self._repo.changelog
         b, close = changelog.branchinfo(rev)
         if b in self._namesreverse:
             branchidx = self._namesreverse[b]
         else:
             branchidx = len(self._names)
             self._names.append(b)
             self._namesreverse[b] = branchidx
         reponode = changelog.node(rev)
         if close:
             branchidx |= _rbccloseflag
         self._setcachedata(rev, reponode, branchidx)
         return b, close
 
     def setdata(self, rev, changelogrevision):
         """add new data information to the cache"""
         branch, close = changelogrevision.branchinfo
 
         if branch in self._namesreverse:
             branchidx = self._namesreverse[branch]
         else:
             branchidx = len(self._names)
             self._names.append(branch)
             self._namesreverse[branch] = branchidx
         if close:
             branchidx |= _rbccloseflag
         self._setcachedata(rev, self._repo.changelog.node(rev), branchidx)
         # If no cache data were readable (non exists, bad permission, etc)
         # the cache was bypassing itself by setting:
         #
         #   self.branchinfo = self._branchinfo
         #
         # Since we now have data in the cache, we need to drop this bypassing.
         if 'branchinfo' in vars(self):
             del self.branchinfo
 
     def _setcachedata(self, rev, node, branchidx):
         """Writes the node's branch data to the in-memory cache data."""
         if rev == nullrev:
             return
         rbcrevidx = rev * _rbcrecsize
         self._rbcrevs.pack_into(rbcrevidx, node, branchidx)
         self._rbcrevslen = min(self._rbcrevslen, rev)
 
         tr = self._repo.currenttransaction()
         if tr:
             tr.addfinalize(b'write-revbranchcache', self.write)
 
     def write(self, tr=None):
         """Save branch cache if it is dirty."""
         repo = self._repo
         wlock = None
         step = b''
         try:
             # write the new names
             if self._rbcnamescount < len(self._names):
                 wlock = repo.wlock(wait=False)
                 step = b' names'
                 self._writenames(repo)
 
             # write the new revs
             start = self._rbcrevslen * _rbcrecsize
             if start != len(self._rbcrevs):
                 step = b''
                 if wlock is None:
                     wlock = repo.wlock(wait=False)
                 self._writerevs(repo, start)
 
         except (IOError, OSError, error.Abort, error.LockError) as inst:
             repo.ui.debug(
                 b"couldn't write revision branch cache%s: %s\n"
                 % (step, stringutil.forcebytestr(inst))
             )
         finally:
             if wlock is not None:
                 wlock.release()
 
     def _writenames(self, repo):
         """write the new branch names to revbranchcache"""
         if self._rbcnamescount != 0:
             f = repo.cachevfs.open(_rbcnames, b'ab')
             if f.tell() == self._rbcsnameslen:
                 f.write(b'\0')
             else:
                 f.close()
                 repo.ui.debug(b"%s changed - rewriting it\n" % _rbcnames)
                 self._rbcnamescount = 0
                 self._rbcrevslen = 0
         if self._rbcnamescount == 0:
             # before rewriting names, make sure references are removed
             repo.cachevfs.unlinkpath(_rbcrevs, ignoremissing=True)
             f = repo.cachevfs.open(_rbcnames, b'wb')
         f.write(
             b'\0'.join(
                 encoding.fromlocal(b)
                 for b in self._names[self._rbcnamescount :]
             )
         )
         self._rbcsnameslen = f.tell()
         f.close()
         self._rbcnamescount = len(self._names)
 
     def _writerevs(self, repo, start):
         """write the new revs to revbranchcache"""
         revs = min(len(repo.changelog), len(self._rbcrevs) // _rbcrecsize)
         with repo.cachevfs.open(_rbcrevs, b'ab') as f:
             if f.tell() != start:
                 repo.ui.debug(
                     b"truncating cache/%s to %d\n" % (_rbcrevs, start)
                 )
                 f.seek(start)
                 if f.tell() != start:
                     start = 0
                     f.seek(start)
                 f.truncate()
             end = revs * _rbcrecsize
             f.write(self._rbcrevs.slice(start, end))
         self._rbcrevslen = revs

tests/test-branches-obsolete.t

@@ -1,546 +1,563 b''
 ================================================================
 test the interaction of the branch cache with obsolete changeset
 ================================================================
 
 Some corner case have been covered by unrelated test (like rebase ones) this
 file meant to gather explicite testing of those.
 
 See also: test-obsolete-checkheads.t
 
 #testcases v2 v3
 
   $ cat >> $HGRCPATH << EOF
   > [phases]
   > publish = false
   > [experimental]
   > evolution = all
   > server.allow-hidden-access = *
   > EOF
 
 #if v3
   $ cat <<EOF >> $HGRCPATH
   > [experimental]
   > branch-cache-v3=yes
   > EOF
   $ CACHE_PREFIX=branch3
 #else
   $ cat <<EOF >> $HGRCPATH
   > [experimental]
   > branch-cache-v3=no
   > EOF
   $ CACHE_PREFIX=branch2
 #endif
 
   $ show_cache() {
   >     for cache_file in .hg/cache/$CACHE_PREFIX*; do
   >         echo "##### $cache_file"
   >         cat $cache_file
   >     done
   > }
 
 Setup graph
 #############
 
   $ . $RUNTESTDIR/testlib/common.sh
 
 graph with a single branch
 --------------------------
 
 We want some branching and some obsolescence
 
   $ hg init main-single-branch
   $ cd main-single-branch
   $ mkcommit root
   $ mkcommit A_1
   $ mkcommit A_2
   $ hg update 'desc("A_2")' --quiet
   $ mkcommit B_1
   $ mkcommit B_2
   $ mkcommit B_3
   $ mkcommit B_4
   $ hg update 'desc("A_2")' --quiet
   $ mkcommit A_3
   created new head
   $ mkcommit A_4
   $ hg up null --quiet
   $ hg clone --noupdate . ../main-single-branch-pre-ops
   $ hg log -r 'desc("A_1")' -T '{node}' > ../main-single-branch-node_A1
   $ hg log -r 'desc("A_2")' -T '{node}' > ../main-single-branch-node_A2
   $ hg log -r 'desc("A_3")' -T '{node}' > ../main-single-branch-node_A3
   $ hg log -r 'desc("A_4")' -T '{node}' > ../main-single-branch-node_A4
   $ hg log -r 'desc("B_1")' -T '{node}' > ../main-single-branch-node_B1
   $ hg log -r 'desc("B_2")' -T '{node}' > ../main-single-branch-node_B2
   $ hg log -r 'desc("B_3")' -T '{node}' > ../main-single-branch-node_B3
   $ hg log -r 'desc("B_4")' -T '{node}' > ../main-single-branch-node_B4
 
 (double check the heads are right before we obsolete)
 
   $ hg log -R ../main-single-branch-pre-ops -G -T '{desc}\n'
   o  A_4
   |
   o  A_3
   |
   | o  B_4
   | |
   | o  B_3
   | |
   | o  B_2
   | |
   | o  B_1
   |/
   o  A_2
   |
   o  A_1
   |
   o  root
   
   $ hg log -G -T '{desc}\n'
   o  A_4
   |
   o  A_3
   |
   | o  B_4
   | |
   | o  B_3
   | |
   | o  B_2
   | |
   | o  B_1
   |/
   o  A_2
   |
   o  A_1
   |
   o  root
   
+
+#if v2
+  $ show_cache
+  ##### .hg/cache/branch2-served
+  3d808bbc94408ea19da905596d4079357a1f28be 8
+  63ba7cd843d1e95aac1a24435befeb1909c53619 o default
+  3d808bbc94408ea19da905596d4079357a1f28be o default
+#else
+  $ show_cache
+  ##### .hg/cache/branch3-served
+  tip-node=3d808bbc94408ea19da905596d4079357a1f28be tip-rev=8 topo-mode=pure
+  default
+#endif
   $ hg log -T '{desc}\n' --rev 'head()'
   B_4
   A_4
 
 Absolete a couple of changes
 
   $ for d in B2 B3 B4 A4; do
   >   hg debugobsolete --record-parents `cat ../main-single-branch-node_$d`;
   > done
   1 new obsolescence markers
   obsoleted 1 changesets
   2 new orphan changesets
   1 new obsolescence markers
   obsoleted 1 changesets
   1 new obsolescence markers
   obsoleted 1 changesets
   1 new obsolescence markers
   obsoleted 1 changesets
 
 (double check the result is okay)
 
   $ hg log -G -T '{desc}\n'
   o  A_3
   |
   | o  B_1
   |/
   o  A_2
   |
   o  A_1
   |
   o  root
   
   $ hg heads -T '{desc}\n'
   A_3
   B_1
 #if v2
   $ show_cache
   ##### .hg/cache/branch2-served
   7c29ff2453bf38c75ee8982935739103c38a9284 7 f8006d64a10d35c011a5c5fa88be1e25c5929514
   550bb31f072912453ccbb503de1d554616911e88 o default
   7c29ff2453bf38c75ee8982935739103c38a9284 o default
 #else
   $ show_cache
   ##### .hg/cache/branch3-served
-  filtered-hash=f8006d64a10d35c011a5c5fa88be1e25c5929514 tip-node=7c29ff2453bf38c75ee8982935739103c38a9284 tip-rev=7
+  filtered-hash=f8006d64a10d35c011a5c5fa88be1e25c5929514 tip-node=7c29ff2453bf38c75ee8982935739103c38a9284 tip-rev=7 topo-mode=pure
+  default
 #endif
   $ cd ..
 
 
 Actual testing
 ##############
 
 Revealing obsolete changeset
 ----------------------------
 
 Check that revealing obsolete changesets does not confuse branch computation and checks
 
 Revealing tipmost changeset
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 
   $ cp -R ./main-single-branch tmp-repo
   $ cd tmp-repo
   $ hg update --hidden --rev 'desc("A_4")' --quiet
   updated to hidden changeset 3d808bbc9440
   (hidden revision '3d808bbc9440' is pruned)
   $ hg log -G -T '{desc}\n'
   @  A_4
   |
   o  A_3
   |
   | o  B_1
   |/
   o  A_2
   |
   o  A_1
   |
   o  root
   
   $ hg heads -T '{desc}\n'
   A_3
   B_1
 #if v2
   $ show_cache
   ##### .hg/cache/branch2
   3d808bbc94408ea19da905596d4079357a1f28be 8 a943c3355ad9e93654d58b1c934c7c4329a5d1d4
   550bb31f072912453ccbb503de1d554616911e88 o default
   7c29ff2453bf38c75ee8982935739103c38a9284 o default
   ##### .hg/cache/branch2-served
   3d808bbc94408ea19da905596d4079357a1f28be 8 a943c3355ad9e93654d58b1c934c7c4329a5d1d4
   550bb31f072912453ccbb503de1d554616911e88 o default
   7c29ff2453bf38c75ee8982935739103c38a9284 o default
 #else
   $ show_cache
   ##### .hg/cache/branch3
   obsolete-hash=b6d2b1f5b70f09c25c835edcae69be35f681605c tip-node=3d808bbc94408ea19da905596d4079357a1f28be tip-rev=8
-  550bb31f072912453ccbb503de1d554616911e88 o default
   7c29ff2453bf38c75ee8982935739103c38a9284 o default
   ##### .hg/cache/branch3-served
   filtered-hash=f8006d64a10d35c011a5c5fa88be1e25c5929514 obsolete-hash=ac5282439f301518f362f37547fcd52bcc670373 tip-node=3d808bbc94408ea19da905596d4079357a1f28be tip-rev=8
   7c29ff2453bf38c75ee8982935739103c38a9284 o default
 #endif
 
 Even when computing branches from scratch
 
   $ rm -rf .hg/cache/branch*
   $ rm -rf .hg/wcache/branch*
   $ hg heads -T '{desc}\n'
   A_3
   B_1
 #if v2
   $ show_cache
   ##### .hg/cache/branch2-served
   3d808bbc94408ea19da905596d4079357a1f28be 8 a943c3355ad9e93654d58b1c934c7c4329a5d1d4
   550bb31f072912453ccbb503de1d554616911e88 o default
   7c29ff2453bf38c75ee8982935739103c38a9284 o default
 #else
   $ show_cache
   ##### .hg/cache/branch3-served
   filtered-hash=f8006d64a10d35c011a5c5fa88be1e25c5929514 obsolete-hash=ac5282439f301518f362f37547fcd52bcc670373 tip-node=3d808bbc94408ea19da905596d4079357a1f28be tip-rev=8
   7c29ff2453bf38c75ee8982935739103c38a9284 o default
 #endif
 
 And we can get back to normal
 
   $ hg update null --quiet
   $ hg heads -T '{desc}\n'
   A_3
   B_1
 #if v2
   $ show_cache
   ##### .hg/cache/branch2-served
   7c29ff2453bf38c75ee8982935739103c38a9284 7 f8006d64a10d35c011a5c5fa88be1e25c5929514
   550bb31f072912453ccbb503de1d554616911e88 o default
   7c29ff2453bf38c75ee8982935739103c38a9284 o default
 #else
   $ show_cache
   ##### .hg/cache/branch3-served
-  filtered-hash=f8006d64a10d35c011a5c5fa88be1e25c5929514 tip-node=7c29ff2453bf38c75ee8982935739103c38a9284 tip-rev=7
+  filtered-hash=f8006d64a10d35c011a5c5fa88be1e25c5929514 tip-node=7c29ff2453bf38c75ee8982935739103c38a9284 tip-rev=7 topo-mode=pure
+  default
 #endif
 
   $ cd ..
   $ rm -rf tmp-repo
 
 Revealing  changeset in the middle of the changelog
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~------------------------
 
 Check that revealing an obsolete changeset does not confuse branch computation and checks
 
   $ cp -R ./main-single-branch tmp-repo
   $ cd tmp-repo
   $ hg update --hidden --rev 'desc("B_3")' --quiet
   updated to hidden changeset 9c996d7674bb
   (hidden revision '9c996d7674bb' is pruned)
   $ hg log -G -T '{desc}\n'
   o  A_3
   |
   | @  B_3
   | |
   | x  B_2
   | |
   | o  B_1
   |/
   o  A_2
   |
   o  A_1
   |
   o  root
   
   $ hg heads -T '{desc}\n'
   A_3
   B_1
 #if v2
   $ show_cache
   ##### .hg/cache/branch2
   3d808bbc94408ea19da905596d4079357a1f28be 8 a943c3355ad9e93654d58b1c934c7c4329a5d1d4
   550bb31f072912453ccbb503de1d554616911e88 o default
   7c29ff2453bf38c75ee8982935739103c38a9284 o default
   ##### .hg/cache/branch2-served
   7c29ff2453bf38c75ee8982935739103c38a9284 7 f8006d64a10d35c011a5c5fa88be1e25c5929514
   550bb31f072912453ccbb503de1d554616911e88 o default
   7c29ff2453bf38c75ee8982935739103c38a9284 o default
 #else
   $ show_cache
   ##### .hg/cache/branch3
   obsolete-hash=b6d2b1f5b70f09c25c835edcae69be35f681605c tip-node=3d808bbc94408ea19da905596d4079357a1f28be tip-rev=8
-  550bb31f072912453ccbb503de1d554616911e88 o default
   7c29ff2453bf38c75ee8982935739103c38a9284 o default
   ##### .hg/cache/branch3-served
   filtered-hash=f1456c0d675980582dda9b8edc7f13f503ce544f obsolete-hash=3e74f5349008671629e39d13d7e00d9ba94c74f7 tip-node=7c29ff2453bf38c75ee8982935739103c38a9284 tip-rev=7
   550bb31f072912453ccbb503de1d554616911e88 o default
 #endif
 
 Even when computing branches from scratch
 
   $ rm -rf .hg/cache/branch*
   $ rm -rf .hg/wcache/branch*
   $ hg heads -T '{desc}\n'
   A_3
   B_1
 #if v2
   $ show_cache
   ##### .hg/cache/branch2-served
   7c29ff2453bf38c75ee8982935739103c38a9284 7 f8006d64a10d35c011a5c5fa88be1e25c5929514
   550bb31f072912453ccbb503de1d554616911e88 o default
   7c29ff2453bf38c75ee8982935739103c38a9284 o default
 #else
   $ show_cache
   ##### .hg/cache/branch3-served
   filtered-hash=f1456c0d675980582dda9b8edc7f13f503ce544f obsolete-hash=3e74f5349008671629e39d13d7e00d9ba94c74f7 tip-node=7c29ff2453bf38c75ee8982935739103c38a9284 tip-rev=7
   550bb31f072912453ccbb503de1d554616911e88 o default
 #endif
 
 And we can get back to normal
 
   $ hg update null --quiet
   $ hg heads -T '{desc}\n'
   A_3
   B_1
 #if v2
   $ show_cache
   ##### .hg/cache/branch2-served
   7c29ff2453bf38c75ee8982935739103c38a9284 7 f8006d64a10d35c011a5c5fa88be1e25c5929514
   550bb31f072912453ccbb503de1d554616911e88 o default
   7c29ff2453bf38c75ee8982935739103c38a9284 o default
 #else
   $ show_cache
   ##### .hg/cache/branch3-served
-  filtered-hash=f8006d64a10d35c011a5c5fa88be1e25c5929514 tip-node=7c29ff2453bf38c75ee8982935739103c38a9284 tip-rev=7
+  filtered-hash=f8006d64a10d35c011a5c5fa88be1e25c5929514 tip-node=7c29ff2453bf38c75ee8982935739103c38a9284 tip-rev=7 topo-mode=pure
+  default
 #endif
 
   $ cd ..
   $ rm -rf tmp-repo
 
 Getting the obsolescence marker after the fact for the tip rev
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
   $ cp -R ./main-single-branch-pre-ops tmp-repo
   $ cd tmp-repo
   $ hg update --hidden --rev 'desc("A_4")' --quiet
   $ hg log -G -T '{desc}\n'
   @  A_4
   |
   o  A_3
   |
   | o  B_4
   | |
   | o  B_3
   | |
   | o  B_2
   | |
   | o  B_1
   |/
   o  A_2
   |
   o  A_1
   |
   o  root
   
   $ hg heads -T '{desc}\n'
   A_4
   B_4
   $ hg pull --rev `cat ../main-single-branch-node_A4` --remote-hidden
   pulling from $TESTTMP/main-single-branch
   no changes found
   1 new obsolescence markers
   obsoleted 1 changesets
 
 branch head are okay
 
   $ hg heads -T '{desc}\n'
   A_3
   B_4
 #if v2
   $ show_cache
   ##### .hg/cache/branch2-served
   3d808bbc94408ea19da905596d4079357a1f28be 8 ac5282439f301518f362f37547fcd52bcc670373
   63ba7cd843d1e95aac1a24435befeb1909c53619 o default
   7c29ff2453bf38c75ee8982935739103c38a9284 o default
 #else
   $ show_cache
   ##### .hg/cache/branch3-served
   obsolete-hash=ac5282439f301518f362f37547fcd52bcc670373 tip-node=3d808bbc94408ea19da905596d4079357a1f28be tip-rev=8
   7c29ff2453bf38c75ee8982935739103c38a9284 o default
 #endif
 
 Even when computing branches from scratch
 
   $ rm -rf .hg/cache/branch*
   $ rm -rf .hg/wcache/branch*
   $ hg heads -T '{desc}\n'
   A_3
   B_4
 #if v2
   $ show_cache
   ##### .hg/cache/branch2-served
   3d808bbc94408ea19da905596d4079357a1f28be 8 ac5282439f301518f362f37547fcd52bcc670373
   63ba7cd843d1e95aac1a24435befeb1909c53619 o default
   7c29ff2453bf38c75ee8982935739103c38a9284 o default
 #else
   $ show_cache
   ##### .hg/cache/branch3-served
   obsolete-hash=ac5282439f301518f362f37547fcd52bcc670373 tip-node=3d808bbc94408ea19da905596d4079357a1f28be tip-rev=8
   7c29ff2453bf38c75ee8982935739103c38a9284 o default
 #endif
 
 And we can get back to normal
 
   $ hg update null --quiet
   $ hg heads -T '{desc}\n'
   A_3
   B_4
 #if v2
   $ show_cache
   ##### .hg/cache/branch2-served
   7c29ff2453bf38c75ee8982935739103c38a9284 7
   63ba7cd843d1e95aac1a24435befeb1909c53619 o default
   7c29ff2453bf38c75ee8982935739103c38a9284 o default
 #else
   $ show_cache
   ##### .hg/cache/branch3-served
-  tip-node=7c29ff2453bf38c75ee8982935739103c38a9284 tip-rev=7
+  tip-node=7c29ff2453bf38c75ee8982935739103c38a9284 tip-rev=7 topo-mode=pure
+  default
 #endif
 
   $ cd ..
   $ rm -rf tmp-repo
 
 Getting the obsolescence marker after the fact for another rev
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
   $ cp -R ./main-single-branch-pre-ops tmp-repo
   $ cd tmp-repo
   $ hg update --hidden --rev 'desc("B_3")' --quiet
   $ hg log -G -T '{desc}\n'
   o  A_4
   |
   o  A_3
   |
   | o  B_4
   | |
   | @  B_3
   | |
   | o  B_2
   | |
   | o  B_1
   |/
   o  A_2
   |
   o  A_1
   |
   o  root
   
   $ hg heads -T '{desc}\n'
   A_4
   B_4
 #if v2
   $ show_cache
   ##### .hg/cache/branch2-served
   3d808bbc94408ea19da905596d4079357a1f28be 8
   63ba7cd843d1e95aac1a24435befeb1909c53619 o default
   3d808bbc94408ea19da905596d4079357a1f28be o default
 #else
   $ show_cache
   ##### .hg/cache/branch3-served
-  tip-node=3d808bbc94408ea19da905596d4079357a1f28be tip-rev=8
+  tip-node=3d808bbc94408ea19da905596d4079357a1f28be tip-rev=8 topo-mode=pure
+  default
 #endif
 
   $ hg pull --rev `cat ../main-single-branch-node_B4` --remote-hidden
   pulling from $TESTTMP/main-single-branch
   no changes found
   3 new obsolescence markers
   obsoleted 3 changesets
 
 branch head are okay
 
   $ hg heads -T '{desc}\n'
   A_4
   B_1
 #if v2
   $ show_cache
   ##### .hg/cache/branch2-served
   3d808bbc94408ea19da905596d4079357a1f28be 8 f8006d64a10d35c011a5c5fa88be1e25c5929514
   550bb31f072912453ccbb503de1d554616911e88 o default
   3d808bbc94408ea19da905596d4079357a1f28be o default
 #else
   $ show_cache
   ##### .hg/cache/branch3-served
   filtered-hash=f1456c0d675980582dda9b8edc7f13f503ce544f obsolete-hash=3e74f5349008671629e39d13d7e00d9ba94c74f7 tip-node=3d808bbc94408ea19da905596d4079357a1f28be tip-rev=8
   550bb31f072912453ccbb503de1d554616911e88 o default
 #endif
 
 Even when computing branches from scratch
 
   $ rm -rf .hg/cache/branch*
   $ rm -rf .hg/wcache/branch*
   $ hg heads -T '{desc}\n'
   A_4
   B_1
 #if v2
   $ show_cache
   ##### .hg/cache/branch2-served
   3d808bbc94408ea19da905596d4079357a1f28be 8 f8006d64a10d35c011a5c5fa88be1e25c5929514
   550bb31f072912453ccbb503de1d554616911e88 o default
   3d808bbc94408ea19da905596d4079357a1f28be o default
 #else
   $ show_cache
   ##### .hg/cache/branch3-served
   filtered-hash=f1456c0d675980582dda9b8edc7f13f503ce544f obsolete-hash=3e74f5349008671629e39d13d7e00d9ba94c74f7 tip-node=3d808bbc94408ea19da905596d4079357a1f28be tip-rev=8
   550bb31f072912453ccbb503de1d554616911e88 o default
 #endif
 
 And we can get back to normal
 
   $ hg update null --quiet
   $ hg heads -T '{desc}\n'
   A_4
   B_1
 #if v2
   $ show_cache
   ##### .hg/cache/branch2-served
   3d808bbc94408ea19da905596d4079357a1f28be 8 f8006d64a10d35c011a5c5fa88be1e25c5929514
   550bb31f072912453ccbb503de1d554616911e88 o default
   3d808bbc94408ea19da905596d4079357a1f28be o default
 #else
   $ show_cache
   ##### .hg/cache/branch3-served
-  filtered-hash=f8006d64a10d35c011a5c5fa88be1e25c5929514 tip-node=3d808bbc94408ea19da905596d4079357a1f28be tip-rev=8
+  filtered-hash=f8006d64a10d35c011a5c5fa88be1e25c5929514 tip-node=3d808bbc94408ea19da905596d4079357a1f28be tip-rev=8 topo-mode=pure
+  default
 #endif
 
   $ cd ..
   $ rm -rf tmp-repo

tests/test-branches.t

@@ -1,1380 +1,1384 b''
 #testcases mmap nommap
 #testcases v2 v3
 
 #if mmap
   $ cat <<EOF >> $HGRCPATH
   > [storage]
   > revbranchcache.mmap=true
   > EOF
 #endif
 
 #if v3
   $ cat <<EOF >> $HGRCPATH
   > [experimental]
   > branch-cache-v3=yes
   > EOF
 #else
   $ cat <<EOF >> $HGRCPATH
   > [experimental]
   > branch-cache-v3=no
   > EOF
 #endif
 
   $ hg init a
   $ cd a
 
 Verify checking branch of nullrev before the cache is created doesnt crash
   $ hg log -r 'branch(.)' -T '{branch}\n'
 
 Basic test
   $ echo 'root' >root
   $ hg add root
   $ hg commit -d '0 0' -m "Adding root node"
 
   $ echo 'a' >a
   $ hg add a
   $ hg branch a
   marked working directory as branch a
   (branches are permanent and global, did you want a bookmark?)
   $ hg commit -d '1 0' -m "Adding a branch"
 
   $ hg branch q
   marked working directory as branch q
   $ echo 'aa' >a
   $ hg branch -C
   reset working directory to branch a
   $ hg commit -d '2 0' -m "Adding to a branch"
 
   $ hg update -C 0
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ echo 'b' >b
   $ hg add b
   $ hg branch b
   marked working directory as branch b
   $ hg commit -d '2 0' -m "Adding b branch"
 
   $ echo 'bh1' >bh1
   $ hg add bh1
   $ hg commit -d '3 0' -m "Adding b branch head 1"
 
   $ hg update -C 2
   1 files updated, 0 files merged, 2 files removed, 0 files unresolved
   $ echo 'bh2' >bh2
   $ hg add bh2
   $ hg commit -d '4 0' -m "Adding b branch head 2"
 
   $ echo 'c' >c
   $ hg add c
   $ hg branch c
   marked working directory as branch c
   $ hg commit -d '5 0' -m "Adding c branch"
 
 reserved names
 
   $ hg branch tip
   abort: the name 'tip' is reserved
   [10]
   $ hg branch null
   abort: the name 'null' is reserved
   [10]
   $ hg branch .
   abort: the name '.' is reserved
   [10]
 
 invalid characters
 
   $ hg branch 'foo:bar'
   abort: ':' cannot be used in a name
   [10]
 
   $ hg branch 'foo
   > bar'
   abort: '\n' cannot be used in a name
   [10]
 
 trailing or leading spaces should be stripped before testing duplicates
 
   $ hg branch 'b '
   abort: a branch of the same name already exists
   (use 'hg update' to switch to it)
   [10]
 
   $ hg branch ' b'
   abort: a branch of the same name already exists
   (use 'hg update' to switch to it)
   [10]
 
 underscores in numeric branch names (issue6737)
 
   $ hg branch 2700_210
   marked working directory as branch 2700_210
 
 verify update will accept invalid legacy branch names
 
   $ hg init test-invalid-branch-name
   $ cd test-invalid-branch-name
   $ hg unbundle -u "$TESTDIR"/bundles/test-invalid-branch-name.hg
   adding changesets
   adding manifests
   adding file changes
   added 3 changesets with 3 changes to 2 files
   new changesets f0e4c7f04036:33c2ceb9310b (3 drafts)
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ hg update '"colon:test"'
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd ..
 
   $ echo 'd' >d
   $ hg add d
   $ hg branch 'a branch name much longer than the default justification used by branches'
   marked working directory as branch a branch name much longer than the default justification used by branches
   $ hg commit -d '6 0' -m "Adding d branch"
 
   $ hg branches
   a branch name much longer than the default justification used by branches 7:10ff5895aa57
   b                              4:aee39cd168d0
   c                              6:589736a22561 (inactive)
   a                              5:d8cbc61dbaa6 (inactive)
   default                        0:19709c5a4e75 (inactive)
 
 -------
 
   $ hg branches -a
   a branch name much longer than the default justification used by branches 7:10ff5895aa57
   b                              4:aee39cd168d0
 
 --- Branch a
 
   $ hg log -b a
   changeset:   5:d8cbc61dbaa6
   branch:      a
   parent:      2:881fe2b92ad0
   user:        test
   date:        Thu Jan 01 00:00:04 1970 +0000
   summary:     Adding b branch head 2
   
   changeset:   2:881fe2b92ad0
   branch:      a
   user:        test
   date:        Thu Jan 01 00:00:02 1970 +0000
   summary:     Adding to a branch
   
   changeset:   1:dd6b440dd85a
   branch:      a
   user:        test
   date:        Thu Jan 01 00:00:01 1970 +0000
   summary:     Adding a branch
   
 
 ---- Branch b
 
   $ hg log -b b
   changeset:   4:aee39cd168d0
   branch:      b
   user:        test
   date:        Thu Jan 01 00:00:03 1970 +0000
   summary:     Adding b branch head 1
   
   changeset:   3:ac22033332d1
   branch:      b
   parent:      0:19709c5a4e75
   user:        test
   date:        Thu Jan 01 00:00:02 1970 +0000
   summary:     Adding b branch
   
 
 ---- going to test branch listing by rev
   $ hg branches -r0
   default                        0:19709c5a4e75 (inactive)
   $ hg branches -qr0
   default
 --- now more than one rev
   $ hg branches -r2:5
   b                              4:aee39cd168d0
   a                              5:d8cbc61dbaa6 (inactive)
   $ hg branches -qr2:5
   b
   a
 ---- going to test branch closing
 
   $ hg branches
   a branch name much longer than the default justification used by branches 7:10ff5895aa57
   b                              4:aee39cd168d0
   c                              6:589736a22561 (inactive)
   a                              5:d8cbc61dbaa6 (inactive)
   default                        0:19709c5a4e75 (inactive)
   $ hg up -C b
   2 files updated, 0 files merged, 4 files removed, 0 files unresolved
   $ echo 'xxx1' >> b
   $ hg commit -d '7 0' -m 'adding cset to branch b'
   $ hg up -C aee39cd168d0
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo 'xxx2' >> b
   $ hg commit -d '8 0' -m 'adding head to branch b'
   created new head
   $ echo 'xxx3' >> b
   $ hg commit -d '9 0' -m 'adding another cset to branch b'
   $ hg branches
   b                             10:bfbe841b666e
   a branch name much longer than the default justification used by branches 7:10ff5895aa57
   c                              6:589736a22561 (inactive)
   a                              5:d8cbc61dbaa6 (inactive)
   default                        0:19709c5a4e75 (inactive)
   $ hg heads --closed
   changeset:   10:bfbe841b666e
   branch:      b
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:09 1970 +0000
   summary:     adding another cset to branch b
   
   changeset:   8:eebb944467c9
   branch:      b
   parent:      4:aee39cd168d0
   user:        test
   date:        Thu Jan 01 00:00:07 1970 +0000
   summary:     adding cset to branch b
   
   changeset:   7:10ff5895aa57
   branch:      a branch name much longer than the default justification used by branches
   user:        test
   date:        Thu Jan 01 00:00:06 1970 +0000
   summary:     Adding d branch
   
   changeset:   6:589736a22561
   branch:      c
   user:        test
   date:        Thu Jan 01 00:00:05 1970 +0000
   summary:     Adding c branch
   
   changeset:   5:d8cbc61dbaa6
   branch:      a
   parent:      2:881fe2b92ad0
   user:        test
   date:        Thu Jan 01 00:00:04 1970 +0000
   summary:     Adding b branch head 2
   
   changeset:   0:19709c5a4e75
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     Adding root node
   
   $ hg heads
   changeset:   10:bfbe841b666e
   branch:      b
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:09 1970 +0000
   summary:     adding another cset to branch b
   
   changeset:   8:eebb944467c9
   branch:      b
   parent:      4:aee39cd168d0
   user:        test
   date:        Thu Jan 01 00:00:07 1970 +0000
   summary:     adding cset to branch b
   
   changeset:   7:10ff5895aa57
   branch:      a branch name much longer than the default justification used by branches
   user:        test
   date:        Thu Jan 01 00:00:06 1970 +0000
   summary:     Adding d branch
   
   changeset:   6:589736a22561
   branch:      c
   user:        test
   date:        Thu Jan 01 00:00:05 1970 +0000
   summary:     Adding c branch
   
   changeset:   5:d8cbc61dbaa6
   branch:      a
   parent:      2:881fe2b92ad0
   user:        test
   date:        Thu Jan 01 00:00:04 1970 +0000
   summary:     Adding b branch head 2
   
   changeset:   0:19709c5a4e75
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     Adding root node
   
   $ hg commit -d '9 0' --close-branch -m 'prune bad branch'
   $ hg branches -a
   b                              8:eebb944467c9
   a branch name much longer than the default justification used by branches 7:10ff5895aa57
   $ hg up -C b
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg commit -d '9 0' --close-branch -m 'close this part branch too'
   $ hg commit -d '9 0' --close-branch -m 're-closing this branch'
   abort: current revision is already a branch closing head
   [10]
 
   $ echo foo > b
   $ hg commit -d '9 0' --close-branch -m 're-closing this branch'
 
   $ echo bar > b
   $ hg commit -d '9 0' --close-branch -m 're-closing this branch' bh1
   abort: current revision is already a branch closing head
   [10]
   $ hg commit -d '9 0' --close-branch -m 're-closing this branch' b
 
   $ echo baz > b
   $ hg commit -d '9 0' --close-branch -m 'empty re-closing this branch' -X b
   abort: current revision is already a branch closing head
   [10]
   $ hg revert b
 
   $ hg debugstrip --rev 13: --no-backup
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg revert --all --no-backup
 
   $ hg log -r tip --debug
   changeset:   12:e3d49c0575d8fc2cb1cd6859c747c14f5f6d499f
   branch:      b
   tag:         tip
   phase:       draft
   parent:      8:eebb944467c9fb9651ed232aeaf31b3c0a7fc6c1
   parent:      -1:0000000000000000000000000000000000000000
   manifest:    8:6f9ed32d2b310e391a4f107d5f0f071df785bfee
   user:        test
   date:        Thu Jan 01 00:00:09 1970 +0000
   extra:       branch=b
   extra:       close=1
   description:
   close this part branch too
   
   
 --- b branch should be inactive
 
   $ hg branches
   a branch name much longer than the default justification used by branches 7:10ff5895aa57
   c                              6:589736a22561 (inactive)
   a                              5:d8cbc61dbaa6 (inactive)
   default                        0:19709c5a4e75 (inactive)
   $ hg branches -c
   a branch name much longer than the default justification used by branches 7:10ff5895aa57
   b                             12:e3d49c0575d8 (closed)
   c                              6:589736a22561 (inactive)
   a                              5:d8cbc61dbaa6 (inactive)
   default                        0:19709c5a4e75 (inactive)
   $ hg branches -a
   a branch name much longer than the default justification used by branches 7:10ff5895aa57
   $ hg branches -q
   a branch name much longer than the default justification used by branches
   c
   a
   default
   $ hg heads b
   no open branch heads found on branches b
   [1]
   $ hg heads --closed b
   changeset:   12:e3d49c0575d8
   branch:      b
   tag:         tip
   parent:      8:eebb944467c9
   user:        test
   date:        Thu Jan 01 00:00:09 1970 +0000
   summary:     close this part branch too
   
   changeset:   11:d3f163457ebf
   branch:      b
   user:        test
   date:        Thu Jan 01 00:00:09 1970 +0000
   summary:     prune bad branch
   
   $ echo 'xxx4' >> b
   $ hg commit -d '9 0' -m 'reopen branch with a change'
   reopening closed branch head 12
 
 --- branch b is back in action
 
   $ hg branches -a
   b                             13:e23b5505d1ad
   a branch name much longer than the default justification used by branches 7:10ff5895aa57
 
 ---- test heads listings
 
   $ hg heads
   changeset:   13:e23b5505d1ad
   branch:      b
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:09 1970 +0000
   summary:     reopen branch with a change
   
   changeset:   7:10ff5895aa57
   branch:      a branch name much longer than the default justification used by branches
   user:        test
   date:        Thu Jan 01 00:00:06 1970 +0000
   summary:     Adding d branch
   
   changeset:   6:589736a22561
   branch:      c
   user:        test
   date:        Thu Jan 01 00:00:05 1970 +0000
   summary:     Adding c branch
   
   changeset:   5:d8cbc61dbaa6
   branch:      a
   parent:      2:881fe2b92ad0
   user:        test
   date:        Thu Jan 01 00:00:04 1970 +0000
   summary:     Adding b branch head 2
   
   changeset:   0:19709c5a4e75
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     Adding root node
   
 
 branch default
 
   $ hg heads default
   changeset:   0:19709c5a4e75
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   summary:     Adding root node
   
 
 branch a
 
   $ hg heads a
   changeset:   5:d8cbc61dbaa6
   branch:      a
   parent:      2:881fe2b92ad0
   user:        test
   date:        Thu Jan 01 00:00:04 1970 +0000
   summary:     Adding b branch head 2
   
   $ hg heads --active a
   no open branch heads found on branches a
   [1]
 
 branch b
 
   $ hg heads b
   changeset:   13:e23b5505d1ad
   branch:      b
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:09 1970 +0000
   summary:     reopen branch with a change
   
   $ hg heads --closed b
   changeset:   13:e23b5505d1ad
   branch:      b
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:09 1970 +0000
   summary:     reopen branch with a change
   
   changeset:   11:d3f163457ebf
   branch:      b
   user:        test
   date:        Thu Jan 01 00:00:09 1970 +0000
   summary:     prune bad branch
   
 
 reclose branch
 
   $ hg up -C c
   3 files updated, 0 files merged, 2 files removed, 0 files unresolved
   $ hg commit -d '9 0' --close-branch -m 'reclosing this branch'
   $ hg branches
   b                             13:e23b5505d1ad
   a branch name much longer than the default justification used by branches 7:10ff5895aa57
   a                              5:d8cbc61dbaa6 (inactive)
   default                        0:19709c5a4e75 (inactive)
   $ hg branches --closed
   b                             13:e23b5505d1ad
   a branch name much longer than the default justification used by branches 7:10ff5895aa57
   c                             14:f894c25619d3 (closed)
   a                              5:d8cbc61dbaa6 (inactive)
   default                        0:19709c5a4e75 (inactive)
 
 multihead branch
 
   $ hg up -C default
   0 files updated, 0 files merged, 3 files removed, 0 files unresolved
   $ hg branch m
   marked working directory as branch m
   $ touch m
   $ hg add m
   $ hg commit -d '10 0' -m 'multihead base'
   $ echo "m1" >m
   $ hg commit -d '10 0' -m 'head 1'
   $ hg up -C '.^'
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ echo "m2" >m
   $ hg commit -d '10 0' -m 'head 2'
   created new head
   $ hg log -b m
   changeset:   17:df343b0df04f
   branch:      m
   tag:         tip
   parent:      15:f3447637f53e
   user:        test
   date:        Thu Jan 01 00:00:10 1970 +0000
   summary:     head 2
   
   changeset:   16:a58ca5d3bdf3
   branch:      m
   user:        test
   date:        Thu Jan 01 00:00:10 1970 +0000
   summary:     head 1
   
   changeset:   15:f3447637f53e
   branch:      m
   parent:      0:19709c5a4e75
   user:        test
   date:        Thu Jan 01 00:00:10 1970 +0000
   summary:     multihead base
   
   $ hg heads --topo m
   changeset:   17:df343b0df04f
   branch:      m
   tag:         tip
   parent:      15:f3447637f53e
   user:        test
   date:        Thu Jan 01 00:00:10 1970 +0000
   summary:     head 2
   
   changeset:   16:a58ca5d3bdf3
   branch:      m
   user:        test
   date:        Thu Jan 01 00:00:10 1970 +0000
   summary:     head 1
   
   $ hg branches
   m                             17:df343b0df04f
   b                             13:e23b5505d1ad
   a branch name much longer than the default justification used by branches 7:10ff5895aa57
   a                              5:d8cbc61dbaa6 (inactive)
   default                        0:19709c5a4e75 (inactive)
 
 partially merge multihead branch
 
   $ hg up -C default
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg branch md
   marked working directory as branch md
   $ hg merge m
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg commit -d '11 0' -m 'merge head 2'
   $ hg heads --topo m
   changeset:   16:a58ca5d3bdf3
   branch:      m
   user:        test
   date:        Thu Jan 01 00:00:10 1970 +0000
   summary:     head 1
   
   $ hg branches
   md                            18:c914c99f1fbb
   m                             17:df343b0df04f
   b                             13:e23b5505d1ad
   a branch name much longer than the default justification used by branches 7:10ff5895aa57
   a                              5:d8cbc61dbaa6 (inactive)
   default                        0:19709c5a4e75 (inactive)
 
 partially close multihead branch
 
   $ hg up -C a58ca5d3bdf3
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg commit -d '12 0' -m 'close head 1' --close-branch
   $ hg heads --topo m
   changeset:   19:cd21a80baa3d
   branch:      m
   tag:         tip
   parent:      16:a58ca5d3bdf3
   user:        test
   date:        Thu Jan 01 00:00:12 1970 +0000
   summary:     close head 1
   
   $ hg branches
   md                            18:c914c99f1fbb
   b                             13:e23b5505d1ad
   a branch name much longer than the default justification used by branches 7:10ff5895aa57
   m                             17:df343b0df04f (inactive)
   a                              5:d8cbc61dbaa6 (inactive)
   default                        0:19709c5a4e75 (inactive)
 
 default branch colors:
 
   $ cat <<EOF >> $HGRCPATH
   > [extensions]
   > color =
   > [color]
   > mode = ansi
   > EOF
 
   $ hg up -C b
   2 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg branches --color=always
   \x1b[0;0mmd\x1b[0m\x1b[0;33m                            18:c914c99f1fbb\x1b[0m (esc)
   \x1b[0;32mb\x1b[0m\x1b[0;33m                             13:e23b5505d1ad\x1b[0m (esc)
   \x1b[0;0ma branch name much longer than the default justification used by branches\x1b[0m\x1b[0;33m 7:10ff5895aa57\x1b[0m (esc)
   \x1b[0;0mm\x1b[0m\x1b[0;33m                             17:df343b0df04f\x1b[0m (inactive) (esc)
   \x1b[0;0ma\x1b[0m\x1b[0;33m                              5:d8cbc61dbaa6\x1b[0m (inactive) (esc)
   \x1b[0;0mdefault\x1b[0m\x1b[0;33m                        0:19709c5a4e75\x1b[0m (inactive) (esc)
 
 default closed branch color:
 
   $ hg branches --color=always --closed
   \x1b[0;0mmd\x1b[0m\x1b[0;33m                            18:c914c99f1fbb\x1b[0m (esc)
   \x1b[0;32mb\x1b[0m\x1b[0;33m                             13:e23b5505d1ad\x1b[0m (esc)
   \x1b[0;0ma branch name much longer than the default justification used by branches\x1b[0m\x1b[0;33m 7:10ff5895aa57\x1b[0m (esc)
   \x1b[0;0mm\x1b[0m\x1b[0;33m                             17:df343b0df04f\x1b[0m (inactive) (esc)
   \x1b[0;30;1mc\x1b[0m\x1b[0;33m                             14:f894c25619d3\x1b[0m (closed) (esc)
   \x1b[0;0ma\x1b[0m\x1b[0;33m                              5:d8cbc61dbaa6\x1b[0m (inactive) (esc)
   \x1b[0;0mdefault\x1b[0m\x1b[0;33m                        0:19709c5a4e75\x1b[0m (inactive) (esc)
 
   $ cat <<EOF >> $HGRCPATH
   > [extensions]
   > color =
   > [color]
   > branches.active = green
   > branches.closed = blue
   > branches.current = red
   > branches.inactive = magenta
   > log.changeset = cyan
   > EOF
 
 custom branch colors:
 
   $ hg branches --color=always
   \x1b[0;32mmd\x1b[0m\x1b[0;36m                            18:c914c99f1fbb\x1b[0m (esc)
   \x1b[0;31mb\x1b[0m\x1b[0;36m                             13:e23b5505d1ad\x1b[0m (esc)
   \x1b[0;32ma branch name much longer than the default justification used by branches\x1b[0m\x1b[0;36m 7:10ff5895aa57\x1b[0m (esc)
   \x1b[0;35mm\x1b[0m\x1b[0;36m                             17:df343b0df04f\x1b[0m (inactive) (esc)
   \x1b[0;35ma\x1b[0m\x1b[0;36m                              5:d8cbc61dbaa6\x1b[0m (inactive) (esc)
   \x1b[0;35mdefault\x1b[0m\x1b[0;36m                        0:19709c5a4e75\x1b[0m (inactive) (esc)
 
 custom closed branch color:
 
   $ hg branches --color=always --closed
   \x1b[0;32mmd\x1b[0m\x1b[0;36m                            18:c914c99f1fbb\x1b[0m (esc)
   \x1b[0;31mb\x1b[0m\x1b[0;36m                             13:e23b5505d1ad\x1b[0m (esc)
   \x1b[0;32ma branch name much longer than the default justification used by branches\x1b[0m\x1b[0;36m 7:10ff5895aa57\x1b[0m (esc)
   \x1b[0;35mm\x1b[0m\x1b[0;36m                             17:df343b0df04f\x1b[0m (inactive) (esc)
   \x1b[0;34mc\x1b[0m\x1b[0;36m                             14:f894c25619d3\x1b[0m (closed) (esc)
   \x1b[0;35ma\x1b[0m\x1b[0;36m                              5:d8cbc61dbaa6\x1b[0m (inactive) (esc)
   \x1b[0;35mdefault\x1b[0m\x1b[0;36m                        0:19709c5a4e75\x1b[0m (inactive) (esc)
 
 template output:
 
   $ hg branches -Tjson --closed
   [
    {
     "active": true,
     "branch": "md",
     "closed": false,
     "current": false,
     "node": "c914c99f1fbb2b1d785a0a939ed3f67275df18e9",
     "rev": 18
    },
    {
     "active": true,
     "branch": "b",
     "closed": false,
     "current": true,
     "node": "e23b5505d1ad24aab6f84fd8c7cb8cd8e5e93be0",
     "rev": 13
    },
    {
     "active": true,
     "branch": "a branch name much longer than the default justification used by branches",
     "closed": false,
     "current": false,
     "node": "10ff5895aa5793bd378da574af8cec8ea408d831",
     "rev": 7
    },
    {
     "active": false,
     "branch": "m",
     "closed": false,
     "current": false,
     "node": "df343b0df04feb2a946cd4b6e9520e552fef14ee",
     "rev": 17
    },
    {
     "active": false,
     "branch": "c",
     "closed": true,
     "current": false,
     "node": "f894c25619d3f1484639d81be950e0a07bc6f1f6",
     "rev": 14
    },
    {
     "active": false,
     "branch": "a",
     "closed": false,
     "current": false,
     "node": "d8cbc61dbaa6dc817175d1e301eecb863f280832",
     "rev": 5
    },
    {
     "active": false,
     "branch": "default",
     "closed": false,
     "current": false,
     "node": "19709c5a4e75bf938f8e349aff97438539bb729e",
     "rev": 0
    }
   ]
 
   $ hg branches --closed -T '{if(closed, "{branch}\n")}'
   c
 
   $ hg branches -T '{word(0, branch)}: {desc|firstline}\n'
   md: merge head 2
   b: reopen branch with a change
   a: Adding d branch
   m: head 2
   a: Adding b branch head 2
   default: Adding root node
 
   $ cat <<'EOF' > "$TESTTMP/map-myjson"
   > docheader = '\{\n'
   > docfooter = '\n}\n'
   > separator = ',\n'
   > branches = ' {dict(branch, node|short)|json}'
   > EOF
   $ hg branches -T "$TESTTMP/map-myjson"
   {
    {"branch": "md", "node": "c914c99f1fbb"},
    {"branch": "b", "node": "e23b5505d1ad"},
    {"branch": "a branch *", "node": "10ff5895aa57"}, (glob)
    {"branch": "m", "node": "df343b0df04f"},
    {"branch": "a", "node": "d8cbc61dbaa6"},
    {"branch": "default", "node": "19709c5a4e75"}
   }
 
   $ cat <<'EOF' >> .hg/hgrc
   > [templates]
   > myjson = ' {dict(branch, node|short)|json}'
   > myjson:docheader = '\{\n'
   > myjson:docfooter = '\n}\n'
   > myjson:separator = ',\n'
   > EOF
   $ hg branches -T myjson
   {
    {"branch": "md", "node": "c914c99f1fbb"},
    {"branch": "b", "node": "e23b5505d1ad"},
    {"branch": "a branch *", "node": "10ff5895aa57"}, (glob)
    {"branch": "m", "node": "df343b0df04f"},
    {"branch": "a", "node": "d8cbc61dbaa6"},
    {"branch": "default", "node": "19709c5a4e75"}
   }
 
   $ cat <<'EOF' >> .hg/hgrc
   > [templates]
   > :docheader = 'should not be selected as a docheader for literal templates\n'
   > EOF
   $ hg branches -T '{branch}\n'
   md
   b
   a branch name much longer than the default justification used by branches
   m
   a
   default
 
 Tests of revision branch name caching
 
 We rev branch cache is updated automatically. In these tests we use a trick to
 trigger rebuilds. We remove the branch head cache and run 'hg head' to cause a
 rebuild that also will populate the rev branch cache.
 
 revision branch cache is created when building the branch head cache
   $ rm -rf .hg/cache; hg head a -T '{rev}\n'
   5
   $ f --hexdump --size .hg/cache/rbc-*
   .hg/cache/rbc-names-v1: size=92
   0000: 64 65 66 61 75 6c 74 00 61 00 62 00 63 00 61 20 |default.a.b.c.a |
   0010: 62 72 61 6e 63 68 20 6e 61 6d 65 20 6d 75 63 68 |branch name much|
   0020: 20 6c 6f 6e 67 65 72 20 74 68 61 6e 20 74 68 65 | longer than the|
   0030: 20 64 65 66 61 75 6c 74 20 6a 75 73 74 69 66 69 | default justifi|
   0040: 63 61 74 69 6f 6e 20 75 73 65 64 20 62 79 20 62 |cation used by b|
   0050: 72 61 6e 63 68 65 73 00 6d 00 6d 64             |ranches.m.md|
   .hg/cache/rbc-revs-v1: size=160
   0000: 19 70 9c 5a 00 00 00 00 dd 6b 44 0d 00 00 00 01 |.p.Z.....kD.....|
   0010: 88 1f e2 b9 00 00 00 01 ac 22 03 33 00 00 00 02 |.........".3....|
   0020: ae e3 9c d1 00 00 00 02 d8 cb c6 1d 00 00 00 01 |................|
   0030: 58 97 36 a2 00 00 00 03 10 ff 58 95 00 00 00 04 |X.6.......X.....|
   0040: ee bb 94 44 00 00 00 02 5f 40 61 bb 00 00 00 02 |...D...._@a.....|
   0050: bf be 84 1b 00 00 00 02 d3 f1 63 45 80 00 00 02 |..........cE....|
   0060: e3 d4 9c 05 80 00 00 02 e2 3b 55 05 00 00 00 02 |.........;U.....|
   0070: f8 94 c2 56 80 00 00 03 f3 44 76 37 00 00 00 05 |...V.....Dv7....|
   0080: a5 8c a5 d3 00 00 00 05 df 34 3b 0d 00 00 00 05 |.........4;.....|
   0090: c9 14 c9 9f 00 00 00 06 cd 21 a8 0b 80 00 00 05 |.........!......|
 
 no errors when revbranchcache is not writable
 
   $ echo >> .hg/cache/rbc-revs-v1
   $ mv .hg/cache/rbc-revs-v1 .hg/cache/rbc-revs-v1_
   $ mkdir .hg/cache/rbc-revs-v1
   $ rm -f .hg/cache/branch* && hg head a -T '{rev}\n'
   5
   $ rmdir .hg/cache/rbc-revs-v1
   $ mv .hg/cache/rbc-revs-v1_ .hg/cache/rbc-revs-v1
 
 no errors when wlock cannot be acquired
 
 #if unix-permissions
   $ mv .hg/cache/rbc-revs-v1 .hg/cache/rbc-revs-v1_
   $ rm -f .hg/cache/branch*
   $ chmod 555 .hg
   $ hg head a -T '{rev}\n'
   5
   $ chmod 755 .hg
   $ mv .hg/cache/rbc-revs-v1_ .hg/cache/rbc-revs-v1
 #endif
 
 recovery from invalid cache revs file with trailing data
   $ echo >> .hg/cache/rbc-revs-v1
   $ rm -f .hg/cache/branch* && hg head a -T '{rev}\n' --debug
   5
   truncating cache/rbc-revs-v1 to 160
   $ f --size .hg/cache/rbc-revs*
   .hg/cache/rbc-revs-v1: size=160
 
 recovery from invalid cache file with partial last record
   $ mv .hg/cache/rbc-revs-v1 .
   $ f -qDB 119 rbc-revs-v1 > .hg/cache/rbc-revs-v1
   $ f --size .hg/cache/rbc-revs*
   .hg/cache/rbc-revs-v1: size=119
   $ rm -f .hg/cache/branch* && hg head a -T '{rev}\n' --debug
   5
   truncating cache/rbc-revs-v1 to 112
   $ f --size .hg/cache/rbc-revs*
   .hg/cache/rbc-revs-v1: size=160
 
 recovery from invalid cache file with missing record - no truncation
   $ mv .hg/cache/rbc-revs-v1 .
   $ f -qDB 112 rbc-revs-v1 > .hg/cache/rbc-revs-v1
   $ rm -f .hg/cache/branch* && hg head a -T '{rev}\n' --debug
   5
   $ f --size .hg/cache/rbc-revs*
   .hg/cache/rbc-revs-v1: size=160
 
 recovery from invalid cache file with some bad records
   $ mv .hg/cache/rbc-revs-v1 .
   $ f -qDB 8 rbc-revs-v1 > .hg/cache/rbc-revs-v1
   $ f --size .hg/cache/rbc-revs*
   .hg/cache/rbc-revs-v1: size=8
   $ f -qDB 112 rbc-revs-v1 >> .hg/cache/rbc-revs-v1
   $ f --size .hg/cache/rbc-revs*
   .hg/cache/rbc-revs-v1: size=120
   $ hg log -r 'branch(.)' -T '{rev} ' --debug
   history modification detected - truncating revision branch cache to revision * (glob)
   history modification detected - truncating revision branch cache to revision 1
   3 4 8 9 10 11 12 13 truncating cache/rbc-revs-v1 to 8
   $ rm -f .hg/cache/branch* && hg head a -T '{rev}\n' --debug
   5
   truncating cache/rbc-revs-v1 to 104
   $ f --size --hexdump --bytes=16 .hg/cache/rbc-revs*
   .hg/cache/rbc-revs-v1: size=160
   0000: 19 70 9c 5a 00 00 00 00 dd 6b 44 0d 00 00 00 01 |.p.Z.....kD.....|
 
 cache is updated when committing
   $ hg branch i-will-regret-this
   marked working directory as branch i-will-regret-this
   $ hg ci -m regrets
   $ f --size .hg/cache/rbc-*
   .hg/cache/rbc-names-v1: size=111
   .hg/cache/rbc-revs-v1: size=168
 
 update after rollback - the cache will be correct but rbc-names will will still
 contain the branch name even though it no longer is used
   $ hg up -qr '.^'
   $ hg rollback -qf
   $ f --size .hg/cache/rbc-names-*
   .hg/cache/rbc-names-v1: size=111
   $ grep "i-will-regret-this" .hg/cache/rbc-names-* > /dev/null
   $ f --size .hg/cache/rbc-revs-*
   .hg/cache/rbc-revs-v1: size=160
 
 cache is updated/truncated when stripping - it is thus very hard to get in a
 situation where the cache is out of sync and the hash check detects it
   $ hg --config extensions.strip= strip -r tip --nob
   $ f --size .hg/cache/rbc-revs*
   .hg/cache/rbc-revs-v1: size=152
 
 cache is rebuilt when corruption is detected
   $ echo > .hg/cache/rbc-names-v1
   $ hg log -r '5:&branch(.)' -T '{rev} ' --debug
   referenced branch names not found - rebuilding revision branch cache from scratch
   8 9 10 11 12 13 truncating cache/rbc-revs-v1 to 40
   $ f --size .hg/cache/rbc-names-*
   .hg/cache/rbc-names-v1: size=84
   $ grep "i-will-regret-this" .hg/cache/rbc-names-* > /dev/null
   [1]
   $ f --size .hg/cache/rbc-revs-*
   .hg/cache/rbc-revs-v1: size=152
 
 Test that cache files are created and grows correctly:
 
   $ rm .hg/cache/rbc*
   $ hg log -r "5 & branch(5)" -T "{rev}\n"
   5
 
 (here v3 is querying branch info for heads so it warm much more of the cache)
 
 #if v2
   $ f --size .hg/cache/rbc-*
   .hg/cache/rbc-names-v1: size=1
   .hg/cache/rbc-revs-v1: size=48
 #else
   $ f --size .hg/cache/rbc-*
   .hg/cache/rbc-names-v1: size=84
   .hg/cache/rbc-revs-v1: size=152
 #endif
 
   $ cd ..
 
 Test for multiple incorrect branch cache entries:
 
   $ hg init b
   $ cd b
   $ touch f
   $ hg ci -Aqmf
   $ echo >> f
   $ hg ci -Amf
   $ hg branch -q branch
   $ hg ci -Amf
 
 #if v2
 
   $ f --size --sha256 .hg/cache/rbc-*
   .hg/cache/rbc-names-v1: size=14, sha256=d376f7eea9a7e28fac6470e78dae753c81a5543c9ad436e96999590e004a281c
   .hg/cache/rbc-revs-v1: size=24, sha256=ec89032fd4e66e7282cb6e403848c681a855a9c36c6b44d19179218553b78779
 
   $ : > .hg/cache/rbc-revs-v1
 
 No superfluous rebuilding of cache:
   $ hg log -r "branch(null)&branch(branch)" --debug
   $ f --size --sha256 .hg/cache/rbc-*
   .hg/cache/rbc-names-v1: size=14, sha256=d376f7eea9a7e28fac6470e78dae753c81a5543c9ad436e96999590e004a281c
   .hg/cache/rbc-revs-v1: size=24, sha256=ec89032fd4e66e7282cb6e403848c681a855a9c36c6b44d19179218553b78779
 #endif
 
   $ cd ..
 
 Test to make sure that `--close-branch` only works on a branch head:
 --------------------------------------------------------------------
   $ hg init closebranch
   $ cd closebranch
   $ for ch in a b c; do
   > echo $ch > $ch
   > hg add $ch
   > hg ci -m "added "$ch
   > done;
 
   $ hg up -r "desc('added b')"
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
 
 trying to close branch from a cset which is not a branch head
 it should abort:
   $ hg ci -m "closing branch" --close-branch
   abort: can only close branch heads
   (use --force-close-branch to close branch from a non-head changeset)
   [10]
 
   $ hg up 0
   0 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg log -GT "{rev}: {node|short} {desc|firstline}\n\t{branch}\n\n"
   o  2: 155349b645be added c
   |  	default
   |
   o  1: 5f6d8a4bf34a added b
   |  	default
   |
   @  0: 9092f1db7931 added a
      	default
   
 Test --force-close-branch to close a branch from a non-head changeset:
 ---------------------------------------------------------------------
 
   $ hg show stack --config extensions.show=
     o  1553 added c
     o  5f6d added b
     @  9092 added a
 
   $ hg ci -m "branch closed" --close-branch
   abort: can only close branch heads
   (use --force-close-branch to close branch from a non-head changeset)
   [10]
 
   $ hg ci -m "branch closed" --force-close-branch
   created new head
   $ cd ..
 
 Test various special cases for the branchmap
 --------------------------------------------
 
 Basic fork of the same branch
 
   $ hg init branchmap-testing1
   $ cd branchmap-testing1
   $ hg debugbuild '@A . :base . :p1 *base /p1'
   $ hg log -G
   o    changeset:   3:71ca9a6d524e
   |\   branch:      A
   | |  tag:         tip
   | |  parent:      2:a3b807b3ff0b
   | |  parent:      1:99ba08759bc7
   | |  user:        debugbuilddag
   | |  date:        Thu Jan 01 00:00:03 1970 +0000
   | |  summary:     r3
   | |
   | o  changeset:   2:a3b807b3ff0b
   | |  branch:      A
   | |  parent:      0:2ab8003a1750
   | |  user:        debugbuilddag
   | |  date:        Thu Jan 01 00:00:02 1970 +0000
   | |  summary:     r2
   | |
   o |  changeset:   1:99ba08759bc7
   |/   branch:      A
   |    tag:         p1
   |    user:        debugbuilddag
   |    date:        Thu Jan 01 00:00:01 1970 +0000
   |    summary:     r1
   |
   o  changeset:   0:2ab8003a1750
      branch:      A
      tag:         base
      user:        debugbuilddag
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     r0
   
   $ hg branches
   A                              3:71ca9a6d524e
   $ hg clone -r 1 -r 2 . ../branchmap-testing1-clone
   adding changesets
   adding manifests
   adding file changes
   added 3 changesets with 0 changes to 0 files (+1 heads)
   new changesets 2ab8003a1750:a3b807b3ff0b
   updating to branch A
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd ../branchmap-testing1-clone
   $ hg pull ../branchmap-testing1
   pulling from ../branchmap-testing1
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 0 changes to 0 files (-1 heads)
   new changesets 71ca9a6d524e
   (run 'hg update' to get a working copy)
   $ hg branches
   A                              3:71ca9a6d524e
   $ cd ..
 
 Switching to a different branch and back
 
   $ hg init branchmap-testing2
   $ cd branchmap-testing2
   $ hg debugbuild '@A . @B . @A .'
   $ hg log -G
   o  changeset:   2:9699e9f260b5
   |  branch:      A
   |  tag:         tip
   |  user:        debugbuilddag
   |  date:        Thu Jan 01 00:00:02 1970 +0000
   |  summary:     r2
   |
   o  changeset:   1:0bc7d348d965
   |  branch:      B
   |  user:        debugbuilddag
   |  date:        Thu Jan 01 00:00:01 1970 +0000
   |  summary:     r1
   |
   o  changeset:   0:2ab8003a1750
      branch:      A
      user:        debugbuilddag
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     r0
   
   $ hg branches
   A                              2:9699e9f260b5
   B                              1:0bc7d348d965 (inactive)
   $ hg clone -r 1 . ../branchmap-testing2-clone
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 0 changes to 0 files
   new changesets 2ab8003a1750:0bc7d348d965
   updating to branch B
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd ../branchmap-testing2-clone
   $ hg pull ../branchmap-testing2
   pulling from ../branchmap-testing2
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 0 changes to 0 files
   new changesets 9699e9f260b5
   (run 'hg update' to get a working copy)
   $ hg branches
   A                              2:9699e9f260b5
   B                              1:0bc7d348d965 (inactive)
   $ cd ..
 
 A fork on a branch switching to a different branch and back
 is still collecting the fork.
 
   $ hg init branchmap-testing3
   $ cd branchmap-testing3
   $ hg debugbuild '@A . :base . :p1 *base @B . @A /p1'
   $ hg log -G
   o    changeset:   4:3614a1711d23
   |\   branch:      A
   | |  tag:         tip
   | |  parent:      3:e9c8abcf65aa
   | |  parent:      1:99ba08759bc7
   | |  user:        debugbuilddag
   | |  date:        Thu Jan 01 00:00:04 1970 +0000
   | |  summary:     r4
   | |
   | o  changeset:   3:e9c8abcf65aa
   | |  branch:      B
   | |  user:        debugbuilddag
   | |  date:        Thu Jan 01 00:00:03 1970 +0000
   | |  summary:     r3
   | |
   | o  changeset:   2:a3b807b3ff0b
   | |  branch:      A
   | |  parent:      0:2ab8003a1750
   | |  user:        debugbuilddag
   | |  date:        Thu Jan 01 00:00:02 1970 +0000
   | |  summary:     r2
   | |
   o |  changeset:   1:99ba08759bc7
   |/   branch:      A
   |    tag:         p1
   |    user:        debugbuilddag
   |    date:        Thu Jan 01 00:00:01 1970 +0000
   |    summary:     r1
   |
   o  changeset:   0:2ab8003a1750
      branch:      A
      tag:         base
      user:        debugbuilddag
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     r0
   
   $ hg branches
   A                              4:3614a1711d23
   B                              3:e9c8abcf65aa (inactive)
   $ hg clone -r 1 -r 3 . ../branchmap-testing3-clone
   adding changesets
   adding manifests
   adding file changes
   added 4 changesets with 0 changes to 0 files (+1 heads)
   new changesets 2ab8003a1750:e9c8abcf65aa
   updating to branch A
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd ../branchmap-testing3-clone
   $ hg pull ../branchmap-testing3
   pulling from ../branchmap-testing3
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 0 changes to 0 files (-1 heads)
   new changesets 3614a1711d23
   (run 'hg update' to get a working copy)
   $ hg branches
   A                              4:3614a1711d23
   B                              3:e9c8abcf65aa (inactive)
   $ cd ..
 
 Intermediary parents are on different branches.
 
   $ hg init branchmap-testing4
   $ cd branchmap-testing4
   $ hg debugbuild '@A . @B :base . @A :p1 *base @C . @A /p1'
   $ hg log -G
   o    changeset:   4:4bf67499b70a
   |\   branch:      A
   | |  tag:         tip
   | |  parent:      3:4a546028fa8f
   | |  parent:      1:0bc7d348d965
   | |  user:        debugbuilddag
   | |  date:        Thu Jan 01 00:00:04 1970 +0000
   | |  summary:     r4
   | |
   | o  changeset:   3:4a546028fa8f
   | |  branch:      C
   | |  user:        debugbuilddag
   | |  date:        Thu Jan 01 00:00:03 1970 +0000
   | |  summary:     r3
   | |
   | o  changeset:   2:a3b807b3ff0b
   | |  branch:      A
   | |  parent:      0:2ab8003a1750
   | |  user:        debugbuilddag
   | |  date:        Thu Jan 01 00:00:02 1970 +0000
   | |  summary:     r2
   | |
   o |  changeset:   1:0bc7d348d965
   |/   branch:      B
   |    tag:         p1
   |    user:        debugbuilddag
   |    date:        Thu Jan 01 00:00:01 1970 +0000
   |    summary:     r1
   |
   o  changeset:   0:2ab8003a1750
      branch:      A
      tag:         base
      user:        debugbuilddag
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     r0
   
   $ hg branches
   A                              4:4bf67499b70a
   C                              3:4a546028fa8f (inactive)
   B                              1:0bc7d348d965 (inactive)
   $ hg clone -r 1 -r 3 . ../branchmap-testing4-clone
   adding changesets
   adding manifests
   adding file changes
   added 4 changesets with 0 changes to 0 files (+1 heads)
   new changesets 2ab8003a1750:4a546028fa8f
   updating to branch B
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd ../branchmap-testing4-clone
   $ hg pull ../branchmap-testing4
   pulling from ../branchmap-testing4
   searching for changes
   adding changesets
   adding manifests
   adding file changes
   added 1 changesets with 0 changes to 0 files (-1 heads)
   new changesets 4bf67499b70a
   (run 'hg update' to get a working copy)
   $ hg branches
   A                              4:4bf67499b70a
   C                              3:4a546028fa8f (inactive)
   B                              1:0bc7d348d965 (inactive)
   $ cd ..
 
 Check that the cache are not written too early
 ----------------------------------------------
 
   $ hg log -R branchmap-testing1 -G
   o    changeset:   3:71ca9a6d524e
   |\   branch:      A
   | |  tag:         tip
   | |  parent:      2:a3b807b3ff0b
   | |  parent:      1:99ba08759bc7
   | |  user:        debugbuilddag
   | |  date:        Thu Jan 01 00:00:03 1970 +0000
   | |  summary:     r3
   | |
   | o  changeset:   2:a3b807b3ff0b
   | |  branch:      A
   | |  parent:      0:2ab8003a1750
   | |  user:        debugbuilddag
   | |  date:        Thu Jan 01 00:00:02 1970 +0000
   | |  summary:     r2
   | |
   o |  changeset:   1:99ba08759bc7
   |/   branch:      A
   |    tag:         p1
   |    user:        debugbuilddag
   |    date:        Thu Jan 01 00:00:01 1970 +0000
   |    summary:     r1
   |
   o  changeset:   0:2ab8003a1750
      branch:      A
      tag:         base
      user:        debugbuilddag
      date:        Thu Jan 01 00:00:00 1970 +0000
      summary:     r0
   
   $ hg bundle -R branchmap-testing1 --base 1 bundle.hg --rev 'head()'
   2 changesets found
 
 Unbundling revision should warm the served cache
 
   $ hg clone branchmap-testing1 --rev 1 branchmap-update-01
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 0 changes to 0 files
   new changesets 2ab8003a1750:99ba08759bc7
   updating to branch A
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
 #if v3
   $ cat branchmap-update-01/.hg/cache/branch3-base
-  tip-node=99ba08759bc7f6fdbe5304e83d0387f35c082479 tip-rev=1
+  tip-node=99ba08759bc7f6fdbe5304e83d0387f35c082479 tip-rev=1 topo-mode=pure
+  A
 #else
   $ cat branchmap-update-01/.hg/cache/branch2-base
   99ba08759bc7f6fdbe5304e83d0387f35c082479 1
   99ba08759bc7f6fdbe5304e83d0387f35c082479 o A
 #endif
   $ hg -R branchmap-update-01 unbundle bundle.hg
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 0 changes to 0 files
   new changesets a3b807b3ff0b:71ca9a6d524e (2 drafts)
   (run 'hg update' to get a working copy)
 #if v3
   $ cat branchmap-update-01/.hg/cache/branch3-served
-  tip-node=71ca9a6d524ed3c2a215119b2086ac3b8c4c8286 tip-rev=3
+  tip-node=71ca9a6d524ed3c2a215119b2086ac3b8c4c8286 tip-rev=3 topo-mode=pure
+  A
 #else
   $ cat branchmap-update-01/.hg/cache/branch2-served
   71ca9a6d524ed3c2a215119b2086ac3b8c4c8286 3
   71ca9a6d524ed3c2a215119b2086ac3b8c4c8286 o A
 #endif
 
 aborted Unbundle should not update the on disk cache
 
   $ cat >> simplehook.py << EOF
   > import sys
   > from mercurial import node
   > from mercurial import branchmap
   > def hook(ui, repo, *args, **kwargs):
   >     s = repo.filtered(b"served")
   >     s.branchmap()
   >     return 1
   > EOF
   $ hg clone branchmap-testing1 --rev 1 branchmap-update-02
   adding changesets
   adding manifests
   adding file changes
   added 2 changesets with 0 changes to 0 files
   new changesets 2ab8003a1750:99ba08759bc7
   updating to branch A
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 #if v3
   $ cat branchmap-update-02/.hg/cache/branch3-base
-  tip-node=99ba08759bc7f6fdbe5304e83d0387f35c082479 tip-rev=1
+  tip-node=99ba08759bc7f6fdbe5304e83d0387f35c082479 tip-rev=1 topo-mode=pure
+  A
 #else
   $ cat branchmap-update-02/.hg/cache/branch2-base
   99ba08759bc7f6fdbe5304e83d0387f35c082479 1
   99ba08759bc7f6fdbe5304e83d0387f35c082479 o A
 #endif
   $ hg -R branchmap-update-02 unbundle bundle.hg --config "hooks.pretxnclose=python:$TESTTMP/simplehook.py:hook"
   adding changesets
   adding manifests
   adding file changes
   transaction abort!
   rollback completed
   abort: pretxnclose hook failed
   [40]
 #if v3
   $ cat branchmap-update-02/.hg/cache/branch3-base
-  tip-node=99ba08759bc7f6fdbe5304e83d0387f35c082479 tip-rev=1
+  tip-node=99ba08759bc7f6fdbe5304e83d0387f35c082479 tip-rev=1 topo-mode=pure
+  A
 #else
   $ cat branchmap-update-02/.hg/cache/branch2-base
   99ba08759bc7f6fdbe5304e83d0387f35c082479 1
   99ba08759bc7f6fdbe5304e83d0387f35c082479 o A
 #endif