branchmap: use mmap for faster revbranchcache loading

A typical revbranchmap usage is:
- load the entire revbranchmap file into memory
- maybe do a few lookups
- add a few bytes to it
- write the addition to disk

There's no reason to load the entire revbranchmap into memory.
We can split it into a large immutable prefix and a mutable suffix,
and then memorymap the prefix, thus saving all the useless loading.

Benchmarking on some real-world pushes suggests that out of ~100s server-side
push handling revbranchcache handling is responsible for:

* ~7s with no change
* ~1.3s with the change, without mmap
* 0.04s with the change, with mmap

mercurial/branchmap.py

@@ -1,870 +1,931 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 (
     Callable,
     Dict,
     Iterable,
     List,
     Optional,
     Set,
     TYPE_CHECKING,
     Tuple,
     Union,
 )
 
 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)
         return self._per_filter[repo.filtername]
 
     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 = branchcache.fromfile(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)
                 bcache = self[subset].copy()
                 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 = branchcache(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 = branchcache(
                 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):
                     self._per_filter[candidate] = cache
                     cache.write(rview)
                     return
 
     def clear(self):
         self._per_filter.clear()
 
     def write_delayed(self, repo):
         unfi = repo.unfiltered()
         for filtername, cache in self._per_filter.items():
             if cache._delayed:
                 repo = unfi.filtered(filtername)
                 cache.write(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 branchcache:
     """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.
 
     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.
     """
 
     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,
         filteredhash: Optional[bytes] = None,
         closednodes: Optional[Set[bytes]] = None,
         hasnode: Optional[Callable[[bytes], bool]] = 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"""
         self._repo = repo
         self._delayed = False
         if tipnode is None:
             self.tipnode = repo.nullid
         else:
             self.tipnode = tipnode
         self.tiprev = tiprev
         self.filteredhash = filteredhash
         # 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 closednodes is None:
             self._closednodes = set()
         else:
             self._closednodes = closednodes
         self._entries = dict(entries)
         # whether closed nodes are verified or not
         self._closedverified = False
         # branches for which nodes are verified
         self._verifiedbranches = set()
         self._hasnode = hasnode
         if self._hasnode is None:
             self._hasnode = lambda x: True
 
     def _verifyclosed(self):
         """verify the closed nodes we have"""
         if self._closedverified:
             return
         for node in self._closednodes:
             if not self._hasnode(node):
                 _unknownnode(node)
 
         self._closedverified = True
 
     def _verifybranch(self, branch):
         """verify head nodes for the given branch."""
         if branch not in self._entries or branch in self._verifiedbranches:
             return
         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"""
         needverification = set(self._entries.keys()) - self._verifiedbranches
         for b in needverification:
             self._verifybranch(b)
 
     def __iter__(self):
         return iter(self._entries)
 
     def __setitem__(self, key, value):
         self._entries[key] = value
 
     def __getitem__(self, key):
         self._verifybranch(key)
         return self._entries[key]
 
     def __contains__(self, key):
         self._verifybranch(key)
         return key in self._entries
 
     def iteritems(self):
         for k, v in self._entries.items():
             self._verifybranch(k)
             yield k, v
 
     items = iteritems
 
     def hasbranch(self, label):
         """checks whether a branch of this name exists or not"""
         self._verifybranch(label)
         return label in self._entries
 
     @classmethod
     def fromfile(cls, repo):
         f = None
         try:
             f = repo.cachevfs(cls._filename(repo))
             lineiter = iter(f)
             cachekey = next(lineiter).rstrip(b'\n').split(b" ", 2)
             last, lrev = cachekey[:2]
             last, lrev = bin(last), int(lrev)
             filteredhash = None
             hasnode = repo.changelog.hasnode
             if len(cachekey) > 2:
                 filteredhash = bin(cachekey[2])
             bcache = cls(
                 repo,
                 tipnode=last,
                 tiprev=lrev,
                 filteredhash=filteredhash,
                 hasnode=hasnode,
             )
             if not bcache.validfor(repo):
                 # invalidate the cache
                 raise ValueError('tip differs')
             bcache.load(repo, lineiter)
         except (IOError, OSError):
             return None
 
         except Exception as inst:
             if repo.ui.debugflag:
                 msg = b'invalid %s: %s\n'
                 repo.ui.debug(
                     msg
                     % (
                         _branchcachedesc(repo),
                         stringutil.forcebytestr(inst),
                     )
                 )
             bcache = None
 
         finally:
             if f:
                 f.close()
 
         return bcache
 
     def load(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)
 
     @staticmethod
     def _filename(repo):
         """name of a branchcache file for a given repo or repoview"""
         filename = b"branch2"
         if repo.filtername:
             filename = b'%s-%s' % (filename, repo.filtername)
         return filename
 
     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
         tiphash = scmutil.filteredhash(repo, self.tiprev, needobsolete=True)
         # 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.filteredhash == tiphash
 
     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):
         self._verifybranch(branch)
         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"""
         self._verifyall()
         return self._entries.values()
 
     def copy(self):
         """return an deep copy of the branchcache object"""
         return type(self)(
             self._repo,
             self._entries,
             self.tipnode,
             self.tiprev,
             self.filteredhash,
             self._closednodes,
         )
 
     def write(self, repo):
         tr = repo.currenttransaction()
         if not getattr(tr, 'finalized', True):
             # Avoid premature writing.
             #
             # (The cache warming setup by localrepo will update the file later.)
             self._delayed = True
             return
         try:
             filename = self._filename(repo)
             with repo.cachevfs(filename, b"w", atomictemp=True) as f:
                 cachekey = [hex(self.tipnode), b'%d' % self.tiprev]
                 if self.filteredhash is not None:
                     cachekey.append(hex(self.filteredhash))
                 f.write(b" ".join(cachekey) + b'\n')
                 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'
                         f.write(b"%s %s %s\n" % (hex(node), state, label))
             repo.ui.log(
                 b'branchcache',
                 b'wrote %s with %d labels and %d nodes\n',
                 _branchcachedesc(repo),
                 len(self._entries),
                 nodecount,
             )
             self._delayed = False
         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 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
         # collect new branch entries
         newbranches = {}
         getbranchinfo = repo.revbranchcache().branchinfo
         for r in revgen:
             branch, closesbranch = getbranchinfo(r)
             newbranches.setdefault(branch, []).append(r)
             if closesbranch:
                 self._closednodes.add(cl.node(r))
 
         # new tip revision which we found after iterating items from new
         # branches
         ntiprev = self.tiprev
 
         # Delay fetching the topological heads until they are needed.
         # A repository without non-continous branches can skip this part.
         topoheads = None
 
         # If a changeset is visible, its parents must be visible too, so
         # use the faster unfiltered parent accessor.
         parentrevs = repo.unfiltered().changelog.parentrevs
 
         # Faster than using ctx.obsolete()
         obsrevs = obsolete.getrevs(repo, b'obsolete')
 
         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 newrev in obsrevs:
                     # We ignore obsolete changesets as they shouldn't be
                     # considered heads.
                     continue
 
                 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)]
             tiprev = max(newheadrevs)
             if tiprev > ntiprev:
                 ntiprev = tiprev
 
         if ntiprev > self.tiprev:
             self.tiprev = ntiprev
             self.tipnode = cl.node(ntiprev)
 
         if not self.validfor(repo):
             # old cache key is now invalid for the repo, but 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.tipnode = repo.nullid
             self.tiprev = nullrev
             for heads in self.iterheads():
                 if not heads:
                     # all revisions on a branch are obsolete
                     continue
                 # note: tiprev is not necessarily the tip revision of repo,
                 # because the tip could be obsolete (i.e. not a head)
                 tiprev = max(cl.rev(node) for node in heads)
                 if tiprev > self.tiprev:
                     self.tipnode = cl.node(tiprev)
                     self.tiprev = tiprev
         self.filteredhash = scmutil.filteredhash(
             repo, self.tiprev, needobsolete=True
         )
 
         duration = util.timer() - starttime
         repo.ui.log(
             b'branchcache',
             b'updated %s in %.4f seconds\n',
             _branchcachedesc(repo),
             duration,
         )
 
         self.write(repo)
 
 
 class remotebranchcache(branchcache):
     """Branchmap info for a remote connection, should not write locally"""
 
     def write(self, repo):
         pass
 
 
 # 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 = bytearray()
+        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'format', b'mmap-revbranchcache'):
+                    with repo.cachevfs(_rbcrevs) as fp:
+                        data = util.buffer(util.mmapread(fp))
+                else:
                 data = repo.cachevfs.read(_rbcrevs)
-                self._rbcrevs[:] = data
+                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 = bytearray(self._rbcrevslen * _rbcrecsize)
+        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 = unpack_from(
-            _rbcrecfmt, util.buffer(self._rbcrevs), rbcrevidx
-        )
+        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
-            del self._rbcrevs[truncate:]
+            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
-        requiredsize = rbcrevidx + _rbcrecsize
-        rbccur = len(self._rbcrevs)
-        if rbccur < requiredsize:
-            # 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
-            # use the classic doubling technique for dynamic arrays instead.
-            # If there was a gap in the map before, less space will be reserved.
-            self._rbcrevs.extend(b'\0' * max(_rbcmininc, requiredsize))
-        pack_into(_rbcrecfmt, self._rbcrevs, rbcrevidx, node, branchidx)
+        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[start:end])
+            f.write(self._rbcrevs.slice(start, end))
         self._rbcrevslen = revs

mercurial/configitems.toml

@@ -1,2915 +1,2920 b''
 # configitems.toml - centralized declaration of configuration options
 #
 # This file contains declarations of the core Mercurial configuration options.
 #
 # # Structure
 #
 # items: array of config items
 # templates: mapping of template name to template declaration
 # template-applications: array of template applications
 #
 # # Elements
 #
 # ## Item
 #
 # Declares a core Mercurial option.
 #
 # - section: string (required)
 # - name: string (required)
 # - default-type: boolean, changes how `default` is read
 # - default: any
 # - generic: boolean
 # - priority: integer, only if `generic` is true
 # - alias: list of 2-tuples of strings
 # - experimental: boolean
 # - documentation: string
 # - in_core_extension: string
 #
 # ## Template
 #
 # Declares a group of options to be re-used for multiple sections.
 #
 # - all the same fields as `Item`, except `section` and `name`
 # - `suffix` (string, required)
 #
 # ## Template applications
 #
 # Uses a `Template` to instanciate its options in a given section.
 #
 # - template: string (required, must match a `Template` name)
 # - section: string (required)
 
 [[items]]
 section = "alias"
 name = ".*"
 default-type = "dynamic"
 generic = true
 
 [[items]]
 section = "auth"
 name = "cookiefile"
 
 # bookmarks.pushing: internal hack for discovery
 [[items]]
 section = "bookmarks"
 name = "pushing"
 default-type = "list_type"
 
 # bundle.mainreporoot: internal hack for bundlerepo
 [[items]]
 section = "bundle"
 name = "mainreporoot"
 default = ""
 
 [[items]]
 section = "censor"
 name = "policy"
 default = "abort"
 experimental = true
 
 [[items]]
 section = "chgserver"
 name = "idletimeout"
 default = 3600
 
 [[items]]
 section = "chgserver"
 name = "skiphash"
 default = false
 
 [[items]]
 section = "cmdserver"
 name = "log"
 
 [[items]]
 section = "cmdserver"
 name = "max-log-files"
 default = 7
 
 [[items]]
 section = "cmdserver"
 name = "max-log-size"
 default = "1 MB"
 
 [[items]]
 section = "cmdserver"
 name = "max-repo-cache"
 default = 0
 experimental = true
 
 [[items]]
 section = "cmdserver"
 name = "message-encodings"
 default-type = "list_type"
 
 [[items]]
 section = "cmdserver"
 name = "shutdown-on-interrupt"
 default = true
 
 [[items]]
 section = "cmdserver"
 name = "track-log"
 default-type = "lambda"
 default = [ "chgserver", "cmdserver", "repocache",]
 
 [[items]]
 section = "color"
 name = ".*"
 generic = true
 
 [[items]]
 section = "color"
 name = "mode"
 default = "auto"
 
 [[items]]
 section = "color"
 name = "pagermode"
 default-type = "dynamic"
 
 [[items]]
 section = "command-templates"
 name = "graphnode"
 alias = [["ui", "graphnodetemplate"]]
 
 [[items]]
 section = "command-templates"
 name = "log"
 alias = [["ui", "logtemplate"]]
 
 [[items]]
 section = "command-templates"
 name = "mergemarker"
 default = '{node|short} {ifeq(tags, "tip", "", ifeq(tags, "", "", "{tags} "))}{if(bookmarks, "{bookmarks} ")}{ifeq(branch, "default", "", "{branch} ")}- {author|user}: {desc|firstline}'
 alias = [["ui", "mergemarkertemplate"]]
 
 [[items]]
 section = "command-templates"
 name = "oneline-summary"
 
 [[items]]
 section = "command-templates"
 name = "oneline-summary.*"
 default-type = "dynamic"
 generic = true
 
 [[items]]
 section = "command-templates"
 name = "pre-merge-tool-output"
 alias = [["ui", "pre-merge-tool-output-template"]]
 
 [[items]]
 section = "commands"
 name = "commit.post-status"
 default = false
 
 [[items]]
 section = "commands"
 name = "grep.all-files"
 default = false
 experimental = true
 
 [[items]]
 section = "commands"
 name = "merge.require-rev"
 default = false
 
 [[items]]
 section = "commands"
 name = "push.require-revs"
 default = false
 
 # Rebase related configuration moved to core because other extension are doing
 # strange things. For example, shelve import the extensions to reuse some bit
 # without formally loading it.
 [[items]]
 section = "commands"
 name = "rebase.requiredest"
 default = false
 
 [[items]]
 section = "commands"
 name = "resolve.confirm"
 default = false
 
 [[items]]
 section = "commands"
 name = "resolve.explicit-re-merge"
 default = false
 
 [[items]]
 section = "commands"
 name = "resolve.mark-check"
 default = "none"
 
 [[items]]
 section = "commands"
 name = "show.aliasprefix"
 default-type = "list_type"
 
 [[items]]
 section = "commands"
 name = "status.relative"
 default = false
 
 [[items]]
 section = "commands"
 name = "status.skipstates"
 default = []
 experimental = true
 
 [[items]]
 section = "commands"
 name = "status.terse"
 default = ""
 
 [[items]]
 section = "commands"
 name = "status.verbose"
 default = false
 
 [[items]]
 section = "commands"
 name = "update.check"
 
 [[items]]
 section = "commands"
 name = "update.requiredest"
 default = false
 
 [[items]]
 section = "committemplate"
 name = ".*"
 generic = true
 
 [[items]]
 section = "convert"
 name = "bzr.saverev"
 default = true
 
 [[items]]
 section = "convert"
 name = "cvsps.cache"
 default = true
 
 [[items]]
 section = "convert"
 name = "cvsps.fuzz"
 default = 60
 
 [[items]]
 section = "convert"
 name = "cvsps.logencoding"
 
 [[items]]
 section = "convert"
 name = "cvsps.mergefrom"
 
 [[items]]
 section = "convert"
 name = "cvsps.mergeto"
 
 [[items]]
 section = "convert"
 name = "git.committeractions"
 default-type = "lambda"
 default = [ "messagedifferent",]
 
 [[items]]
 section = "convert"
 name = "git.extrakeys"
 default-type = "list_type"
 
 [[items]]
 section = "convert"
 name = "git.findcopiesharder"
 default = false
 
 [[items]]
 section = "convert"
 name = "git.remoteprefix"
 default = "remote"
 
 [[items]]
 section = "convert"
 name = "git.renamelimit"
 default = 400
 
 [[items]]
 section = "convert"
 name = "git.saverev"
 default = true
 
 [[items]]
 section = "convert"
 name = "git.similarity"
 default = 50
 
 [[items]]
 section = "convert"
 name = "git.skipsubmodules"
 default = false
 
 [[items]]
 section = "convert"
 name = "hg.clonebranches"
 default = false
 
 [[items]]
 section = "convert"
 name = "hg.ignoreerrors"
 default = false
 
 [[items]]
 section = "convert"
 name = "hg.preserve-hash"
 default = false
 
 [[items]]
 section = "convert"
 name = "hg.revs"
 
 [[items]]
 section = "convert"
 name = "hg.saverev"
 default = false
 
 [[items]]
 section = "convert"
 name = "hg.sourcename"
 
 [[items]]
 section = "convert"
 name = "hg.startrev"
 
 [[items]]
 section = "convert"
 name = "hg.tagsbranch"
 default = "default"
 
 [[items]]
 section = "convert"
 name = "hg.usebranchnames"
 default = true
 
 [[items]]
 section = "convert"
 name = "ignoreancestorcheck"
 default = false
 experimental = true
 
 [[items]]
 section = "convert"
 name = "localtimezone"
 default = false
 
 [[items]]
 section = "convert"
 name = "p4.encoding"
 default-type = "dynamic"
 
 [[items]]
 section = "convert"
 name = "p4.startrev"
 default = 0
 
 [[items]]
 section = "convert"
 name = "skiptags"
 default = false
 
 [[items]]
 section = "convert"
 name = "svn.branches"
 
 [[items]]
 section = "convert"
 name = "svn.dangerous-set-commit-dates"
 default = false
 
 [[items]]
 section = "convert"
 name = "svn.debugsvnlog"
 default = true
 
 [[items]]
 section = "convert"
 name = "svn.startrev"
 default = 0
 
 [[items]]
 section = "convert"
 name = "svn.tags"
 
 [[items]]
 section = "convert"
 name = "svn.trunk"
 
 [[items]]
 section = "debug"
 name = "bundling-stats"
 default = false
 documentation = "Display extra information about the bundling process."
 
 [[items]]
 section = "debug"
 name = "dirstate.delaywrite"
 default = 0
 
 [[items]]
 section = "debug"
 name = "revlog.debug-delta"
 default = false
 
 [[items]]
 section = "debug"
 name = "revlog.verifyposition.changelog"
 default = ""
 
 [[items]]
 section = "debug"
 name = "unbundling-stats"
 default = false
 documentation = "Display extra information about the unbundling process."
 
 [[items]]
 section = "defaults"
 name = ".*"
 generic = true
 
 [[items]]
 section = "devel"
 name = "all-warnings"
 default = false
 
 [[items]]
 section = "devel"
 name = "bundle.delta"
 default = ""
 
 [[items]]
 section = "devel"
 name = "bundle2.debug"
 default = false
 
 [[items]]
 section = "devel"
 name = "cache-vfs"
 
 [[items]]
 section = "devel"
 name = "check-locks"
 default = false
 
 [[items]]
 section = "devel"
 name = "check-relroot"
 default = false
 
 [[items]]
 section = "devel"
 name = "copy-tracing.multi-thread"
 default = true
 
 # Track copy information for all files, not just "added" ones (very slow)
 [[items]]
 section = "devel"
 name = "copy-tracing.trace-all-files"
 default = false
 
 [[items]]
 section = "devel"
 name = "debug.abort-update"
 default = false
 documentation = """If true, then any merge with the working copy, \
 e.g. [hg update], will be aborted after figuring out what needs to be done, \
 but before spawning the parallel worker."""
 
 [[items]]
 section = "devel"
 name = "debug.copies"
 default = false
 
 [[items]]
 section = "devel"
 name = "debug.extensions"
 default = false
 
 [[items]]
 section = "devel"
 name = "debug.peer-request"
 default = false
 
 [[items]]
 section = "devel"
 name = "debug.repo-filters"
 default = false
 
 [[items]]
 section = "devel"
 name = "default-date"
 
 [[items]]
 section = "devel"
 name = "deprec-warn"
 default = false
 
 # possible values:
 # - auto (the default)
 # - force-append
 # - force-new
 [[items]]
 section = "devel"
 name = "dirstate.v2.data_update_mode"
 default = "auto"
 
 [[items]]
 section = "devel"
 name = "disableloaddefaultcerts"
 default = false
 
 [[items]]
 section = "devel"
 name = "discovery.exchange-heads"
 default = true
 documentation = """If false, the discovery will not start with remote \
 head fetching and local head querying."""
 
 [[items]]
 section = "devel"
 name = "discovery.grow-sample"
 default = true
 documentation = """If false, the sample size used in set discovery \
 will not be increased through the process."""
 
 [[items]]
 section = "devel"
 name = "discovery.grow-sample.dynamic"
 default = true
 documentation = """If true, the default, the sample size is adapted to the shape \
 of the undecided set. It is set to the max of:
 `<target-size>, len(roots(undecided)), len(heads(undecided))`"""
 
 [[items]]
 section = "devel"
 name = "discovery.grow-sample.rate"
 default = 1.05
 documentation = "Controls the rate at which the sample grows."
 
 [[items]]
 section = "devel"
 name = "discovery.randomize"
 default = true
 documentation = """If false, random samplings during discovery are deterministic. \
 It is meant for integration tests."""
 
 [[items]]
 section = "devel"
 name = "discovery.sample-size"
 default = 200
 documentation = "Controls the initial size of the discovery sample."
 
 [[items]]
 section = "devel"
 name = "discovery.sample-size.initial"
 default = 100
 documentation = "Controls the initial size of the discovery for initial change."
 
 [[items]]
 section = "devel"
 name = "legacy.exchange"
 default-type = "list_type"
 
 [[items]]
 section = "devel"
 name = "persistent-nodemap"
 default = false
 documentation = """When true, revlogs use a special reference version of the \
 nodemap, that is not performant but is "known" to behave properly."""
 
 [[items]]
 section = "devel"
 name = "server-insecure-exact-protocol"
 default = ""
 
 [[items]]
 section = "devel"
 name = "servercafile"
 default = ""
 
 [[items]]
 section = "devel"
 name = "serverexactprotocol"
 default = ""
 
 [[items]]
 section = "devel"
 name = "serverrequirecert"
 default = false
 
 [[items]]
 section = "devel"
 name = "strip-obsmarkers"
 default = true
 
 [[items]]
 section = 'devel'
 name = 'sync.status.pre-dirstate-write-file'
 documentation = """
 Makes the status algorithm wait for the existence of this file \
 (or until a timeout of `devel.sync.status.pre-dirstate-write-file-timeout` \
 seconds) before taking the lock and writing the dirstate. \
 Status signals that it's ready to wait by creating a file \
 with the same name + `.waiting`. \
 Useful when testing race conditions."""
 
 [[items]]
 section = 'devel'
 name = 'sync.status.pre-dirstate-write-file-timeout'
 default=2
 
 [[items]]
 section = 'devel'
 name = 'sync.dirstate.post-docket-read-file'
 
 [[items]]
 section = 'devel'
 name = 'sync.dirstate.post-docket-read-file-timeout'
 default=2
 
 [[items]]
 section = 'devel'
 name = 'sync.dirstate.pre-read-file'
 
 [[items]]
 section = 'devel'
 name = 'sync.dirstate.pre-read-file-timeout'
 default=2
 
 [[items]]
 section = "devel"
 name = "user.obsmarker"
 
 [[items]]
 section = "devel"
 name = "warn-config"
 
 [[items]]
 section = "devel"
 name = "warn-config-default"
 
 [[items]]
 section = "devel"
 name = "warn-config-unknown"
 
 [[items]]
 section = "devel"
 name = "warn-empty-changegroup"
 default = false
 
 [[items]]
 section = "diff"
 name = "merge"
 default = false
 experimental = true
 
 [[items]]
 section = "email"
 name = "bcc"
 
 [[items]]
 section = "email"
 name = "cc"
 
 [[items]]
 section = "email"
 name = "charsets"
 default-type = "list_type"
 
 [[items]]
 section = "email"
 name = "from"
 
 [[items]]
 section = "email"
 name = "method"
 default = "smtp"
 
 [[items]]
 section = "email"
 name = "reply-to"
 
 [[items]]
 section = "email"
 name = "to"
 
 [[items]]
 section = "experimental"
 name = "archivemetatemplate"
 default-type = "dynamic"
 
 [[items]]
 section = "experimental"
 name = "auto-publish"
 default = "publish"
 
 [[items]]
 section = "experimental"
 name = "bundle-phases"
 default = false
 
 [[items]]
 section = "experimental"
 name = "bundle2-advertise"
 default = true
 
 [[items]]
 section = "experimental"
 name = "bundle2-output-capture"
 default = false
 
 [[items]]
 section = "experimental"
 name = "bundle2.pushback"
 default = false
 
 [[items]]
 section = "experimental"
 name = "bundle2lazylocking"
 default = false
 
 [[items]]
 section = "experimental"
 name = "bundlecomplevel"
 
 [[items]]
 section = "experimental"
 name = "bundlecomplevel.bzip2"
 
 [[items]]
 section = "experimental"
 name = "bundlecomplevel.gzip"
 
 [[items]]
 section = "experimental"
 name = "bundlecomplevel.none"
 
 [[items]]
 section = "experimental"
 name = "bundlecomplevel.zstd"
 
 [[items]]
 section = "experimental"
 name = "bundlecompthreads"
 
 [[items]]
 section = "experimental"
 name = "bundlecompthreads.bzip2"
 
 [[items]]
 section = "experimental"
 name = "bundlecompthreads.gzip"
 
 [[items]]
 section = "experimental"
 name = "bundlecompthreads.none"
 
 [[items]]
 section = "experimental"
 name = "bundlecompthreads.zstd"
 
 [[items]]
 section = "experimental"
 name = "changegroup3"
 default = true
 
 [[items]]
 section = "experimental"
 name = "changegroup4"
 default = false
 
 # might remove rank configuration once the computation has no impact
 [[items]]
 section = "experimental"
 name = "changelog-v2.compute-rank"
 default = true
 
 [[items]]
 section = "experimental"
 name = "cleanup-as-archived"
 default = false
 
 [[items]]
 section = "experimental"
 name = "clientcompressionengines"
 default-type = "list_type"
 
 [[items]]
 section = "experimental"
 name = "copies.read-from"
 default = "filelog-only"
 
 [[items]]
 section = "experimental"
 name = "copies.write-to"
 default = "filelog-only"
 
 [[items]]
 section = "experimental"
 name = "copytrace"
 default = "on"
 
 [[items]]
 section = "experimental"
 name = "copytrace.movecandidateslimit"
 default = 100
 
 [[items]]
 section = "experimental"
 name = "copytrace.sourcecommitlimit"
 default = 100
 
 [[items]]
 section = "experimental"
 name = "crecordtest"
 
 [[items]]
 section = "experimental"
 name = "directaccess"
 default = false
 
 [[items]]
 section = "experimental"
 name = "directaccess.revnums"
 default = false
 
 [[items]]
 section = "experimental"
 name = "editortmpinhg"
 default = false
 
 [[items]]
 section = "experimental"
 name = "evolution"
 default-type = "list_type"
 
 [[items]]
 section = "experimental"
 name = "evolution.allowdivergence"
 default = false
 alias = [["experimental", "allowdivergence"]]
 
 [[items]]
 section = "experimental"
 name = "evolution.allowunstable"
 
 [[items]]
 section = "experimental"
 name = "evolution.bundle-obsmarker"
 default = false
 
 [[items]]
 section = "experimental"
 name = "evolution.bundle-obsmarker:mandatory"
 default = true
 
 [[items]]
 section = "experimental"
 name = "evolution.createmarkers"
 
 [[items]]
 section = "experimental"
 name = "evolution.effect-flags"
 default = true
 alias = [["experimental", "effect-flags"]]
 
 [[items]]
 section = "experimental"
 name = "evolution.exchange"
 
 [[items]]
 section = "experimental"
 name = "evolution.report-instabilities"
 default = true
 
 [[items]]
 section = "experimental"
 name = "evolution.track-operation"
 default = true
 
 [[items]]
 section = "experimental"
 name = "exportableenviron"
 default-type = "list_type"
 
 [[items]]
 section = "experimental"
 name = "extendedheader.index"
 
 [[items]]
 section = "experimental"
 name = "extendedheader.similarity"
 default = false
 
 [[items]]
 section = "experimental"
 name = "extra-filter-revs"
 documentation = """Repo-level config to prevent a revset from being visible.
 The target use case is to use `share` to expose different subsets of the same \
 repository, especially server side. See also `server.view`."""
 
 [[items]]
 section = "experimental"
 name = "graphshorten"
 default = false
 
 [[items]]
 section = "experimental"
 name = "graphstyle.grandparent"
 default-type = "dynamic"
 
 [[items]]
 section = "experimental"
 name = "graphstyle.missing"
 default-type = "dynamic"
 
 [[items]]
 section = "experimental"
 name = "graphstyle.parent"
 default-type = "dynamic"
 
 [[items]]
 section = "experimental"
 name = "hook-track-tags"
 default = false
 
 [[items]]
 section = "experimental"
 name = "httppostargs"
 default = false
 
 [[items]]
 section = "experimental"
 name = "log.topo"
 default = false
 
 [[items]]
 section = "experimental"
 name = "maxdeltachainspan"
 default = -1
 
 [[items]]
 section = "experimental"
 name = "merge-track-salvaged"
 default = false
 documentation = """Tracks files which were undeleted (merge might delete them \
 but we explicitly kept/undeleted them) and creates new filenodes for them."""
 
 [[items]]
 section = "experimental"
 name = "merge.checkpathconflicts"
 default = false
 
 [[items]]
 section = "experimental"
 name = "mmapindexthreshold"
 
 [[items]]
 section = "experimental"
 name = "narrow"
 default = false
 
 [[items]]
 section = "experimental"
 name = "nointerrupt"
 default = false
 
 [[items]]
 section = "experimental"
 name = "nointerrupt-interactiveonly"
 default = true
 
 [[items]]
 section = "experimental"
 name = "nonnormalparanoidcheck"
 default = false
 
 [[items]]
 section = "experimental"
 name = "obsmarkers-exchange-debug"
 default = false
 
 [[items]]
 section = "experimental"
 name = "rebaseskipobsolete"
 default = true
 
 [[items]]
 section = "experimental"
 name = "remotenames"
 default = false
 
 [[items]]
 section = "experimental"
 name = "removeemptydirs"
 default = true
 
 [[items]]
 section = "experimental"
 name = "revert.interactive.select-to-keep"
 default = false
 
 [[items]]
 section = "experimental"
 name = "revisions.disambiguatewithin"
 
 [[items]]
 section = "experimental"
 name = "revisions.prefixhexnode"
 default = false
 
 # "out of experimental" todo list.
 #
 # * include management of a persistent nodemap in the main docket
 # * enforce a "no-truncate" policy for mmap safety
 #      - for censoring operation
 #      - for stripping operation
 #      - for rollback operation
 # * proper streaming (race free) of the docket file
 # * track garbage data to evemtually allow rewriting -existing- sidedata.
 # * Exchange-wise, we will also need to do something more efficient than
 #   keeping references to the affected revlogs, especially memory-wise when
 #   rewriting sidedata.
 # * introduce a proper solution to reduce the number of filelog related files.
 # * use caching for reading sidedata (similar to what we do for data).
 # * no longer set offset=0 if sidedata_size=0 (simplify cutoff computation).
 # * Improvement to consider
 #   - avoid compression header in chunk using the default compression?
 #   - forbid "inline" compression mode entirely?
 #   - split the data offset and flag field (the 2 bytes save are mostly trouble)
 #   - keep track of uncompressed -chunk- size (to preallocate memory better)
 #   - keep track of chain base or size (probably not that useful anymore)
 [[items]]
 section = "experimental"
 name = "revlogv2"
 
 [[items]]
 section = "experimental"
 name = "rust.index"
 default = false
 
 [[items]]
 section = "experimental"
 name = "server.allow-hidden-access"
 default-type = "list_type"
 
 [[items]]
 section = "experimental"
 name = "server.filesdata.recommended-batch-size"
 default = 50000
 
 [[items]]
 section = "experimental"
 name = "server.manifestdata.recommended-batch-size"
 default = 100000
 
 [[items]]
 section = "experimental"
 name = "server.stream-narrow-clones"
 default = false
 
 [[items]]
 section = "experimental"
 name = "single-head-per-branch"
 default = false
 
 [[items]]
 section = "experimental"
 name = "single-head-per-branch:account-closed-heads"
 default = false
 
 [[items]]
 section = "experimental"
 name = "single-head-per-branch:public-changes-only"
 default = false
 
 [[items]]
 section = "experimental"
 name = "sparse-read"
 default = false
 
 [[items]]
 section = "experimental"
 name = "sparse-read.density-threshold"
 default = 0.5
 
 [[items]]
 section = "experimental"
 name = "sparse-read.min-gap-size"
 default = "65K"
 
 [[items]]
 section = "experimental"
 name = "stream-v3"
 default = false
 
 [[items]]
 section = "experimental"
 name = "treemanifest"
 default = false
 
 [[items]]
 section = "experimental"
 name = "update.atomic-file"
 default = false
 
 [[items]]
 section = "experimental"
 name = "web.full-garbage-collection-rate"
 default = 1  # still forcing a full collection on each request
 
 [[items]]
 section = "experimental"
 name = "worker.repository-upgrade"
 default = false
 
 [[items]]
 section = "experimental"
 name = "worker.wdir-get-thread-safe"
 default = false
 
 [[items]]
 section = "experimental"
 name = "xdiff"
 default = false
 
 [[items]]
 section = "extdata"
 name = ".*"
 generic = true
 
 [[items]]
 section = "extensions"
 name = "[^:]*"
 generic = true
 
 [[items]]
 section = "extensions"
 name = "[^:]*:required"
 default = false
 generic = true
 
 [[items]]
 section = "format"
 name = "bookmarks-in-store"
 default = false
 
 [[items]]
 section = "format"
 name = "chunkcachesize"
 experimental = true
 
 [[items]]
 section = "format"
 name = "dotencode"
 default = true
 
 # The interaction between the archived phase and obsolescence markers needs to
 # be sorted out before wider usage of this are to be considered.
 #
 # At the time this message is written, behavior when archiving obsolete
 # changeset differ significantly from stripping. As part of stripping, we also
 # remove the obsolescence marker associated to the stripped changesets,
 # revealing the precedecessors changesets when applicable. When archiving, we
 # don't touch the obsolescence markers, keeping everything hidden. This can
 # result in quite confusing situation for people combining exchanging draft
 # with the archived phases. As some markers needed by others may be skipped
 # during exchange.
 [[items]]
 section = "format"
 name = "exp-archived-phase"
 default = false
 experimental = true
 
 # Experimental TODOs:
 #
 # * Same as for revlogv2 (but for the reduction of the number of files)
 # * Actually computing the rank of changesets
 # * Improvement to investigate
 #   - storing .hgtags fnode
 #   - storing branch related identifier
 [[items]]
 section = "format"
 name = "exp-use-changelog-v2"
 experimental = true
 
 [[items]]
 section = "format"
 name = "exp-use-copies-side-data-changeset"
 default = false
 experimental = true
 
 [[items]]
 section = "format"
 name = "generaldelta"
 default = false
 experimental = true
 
 [[items]]
 section = "format"
 name = "manifestcachesize"
 experimental = true
 
 [[items]]
 section = "format"
 name = "maxchainlen"
 default-type = "dynamic"
 experimental = true
 
 [[items]]
 section = "format"
 name = "obsstore-version"
 
 [[items]]
 section = "format"
 name = "revlog-compression"
 default-type = "lambda"
 alias = [["experimental", "format.compression"]]
 default = [ "zstd", "zlib",]
 
 [[items]]
 section = "format"
 name = "sparse-revlog"
 default = true
 
 [[items]]
 section = "format"
 name = "use-dirstate-tracked-hint"
 default = false
 experimental = true
 
 [[items]]
 section = "format"
 name = "use-dirstate-tracked-hint.automatic-upgrade-of-mismatching-repositories"
 default = false
 experimental = true
 
 [[items]]
 section = "format"
 name = "use-dirstate-tracked-hint.automatic-upgrade-of-mismatching-repositories:quiet"
 default = false
 experimental = true
 
 [[items]]
 section = "format"
 name = "use-dirstate-tracked-hint.version"
 default = 1
 experimental = true
 
 [[items]]
 section = "format"
 name = "use-dirstate-v2"
 default = false
 alias = [["format", "exp-rc-dirstate-v2"]]
 experimental = true
 documentation = """Enables dirstate-v2 format *when creating a new repository*.
 Which format to use for existing repos is controlled by `.hg/requires`."""
 
 [[items]]
 section = "format"
 name = "use-dirstate-v2.automatic-upgrade-of-mismatching-repositories"
 default = false
 experimental = true
 
 [[items]]
 section = "format"
 name = "use-dirstate-v2.automatic-upgrade-of-mismatching-repositories:quiet"
 default = false
 experimental = true
 
 # Having this on by default means we are confident about the scaling of phases.
 # This is not garanteed to be the case at the time this message is written.
 [[items]]
 section = "format"
 name = "use-internal-phase"
 default = false
 experimental = true
 
 [[items]]
 section = "format"
 name = "use-persistent-nodemap"
 default-type = "dynamic"
 
 [[items]]
 section = "format"
 name = "use-share-safe"
 default = true
 
 [[items]]
 section = "format"
 name = "use-share-safe.automatic-upgrade-of-mismatching-repositories"
 default = false
 experimental = true
 
 [[items]]
 section = "format"
 name = "use-share-safe.automatic-upgrade-of-mismatching-repositories:quiet"
 default = false
 experimental = true
 
 [[items]]
 section = "format"
 name = "usefncache"
 default = true
 
 [[items]]
 section = "format"
 name = "usegeneraldelta"
 default = true
 
 [[items]]
 section = "format"
 name = "usestore"
 default = true
 
 [[items]]
 section = "fsmonitor"
 name = "warn_update_file_count"
 default = 50000
 
 [[items]]
 section = "fsmonitor"
 name = "warn_update_file_count_rust"
 default = 400000
 
 [[items]]
 section = "fsmonitor"
 name = "warn_when_unused"
 default = true
 
 [[items]]
 section = "help"
 name = 'hidden-command\..*'
 default = false
 generic = true
 
 [[items]]
 section = "help"
 name = 'hidden-topic\..*'
 default = false
 generic = true
 
 [[items]]
 section = "hgweb-paths"
 name = ".*"
 default-type = "list_type"
 generic = true
 
 [[items]]
 section = "hooks"
 name = ".*:run-with-plain"
 default = true
 generic = true
 
 [[items]]
 section = "hooks"
 name = "[^:]*"
 default-type = "dynamic"
 generic = true
 
 [[items]]
 section = "hostfingerprints"
 name = ".*"
 default-type = "list_type"
 generic = true
 
 [[items]]
 section = "hostsecurity"
 name = ".*:ciphers$"
 default-type = "dynamic"
 generic = true
 
 [[items]]
 section = "hostsecurity"
 name = ".*:fingerprints$"
 default-type = "list_type"
 generic = true
 
 [[items]]
 section = "hostsecurity"
 name = ".*:minimumprotocol$"
 default-type = "dynamic"
 generic = true
 
 [[items]]
 section = "hostsecurity"
 name = ".*:verifycertsfile$"
 generic = true
 
 [[items]]
 section = "hostsecurity"
 name = "ciphers"
 
 [[items]]
 section = "hostsecurity"
 name = "minimumprotocol"
 default-type = "dynamic"
 
 [[items]]
 section = "http"
 name = "timeout"
 
 [[items]]
 section = "http_proxy"
 name = "always"
 default = false
 
 [[items]]
 section = "http_proxy"
 name = "host"
 
 [[items]]
 section = "http_proxy"
 name = "no"
 default-type = "list_type"
 
 [[items]]
 section = "http_proxy"
 name = "passwd"
 
 [[items]]
 section = "http_proxy"
 name = "user"
 
 [[items]]
 section = "logtoprocess"
 name = "command"
 
 [[items]]
 section = "logtoprocess"
 name = "commandexception"
 
 [[items]]
 section = "logtoprocess"
 name = "commandfinish"
 
 [[items]]
 section = "logtoprocess"
 name = "develwarn"
 
 [[items]]
 section = "logtoprocess"
 name = "uiblocked"
 
 [[items]]
 section = "merge"
 name = "checkignored"
 default = "abort"
 
 [[items]]
 section = "merge"
 name = "checkunknown"
 default = "abort"
 
 [[items]]
 section = "merge"
 name = "disable-partial-tools"
 default = false
 experimental = true
 
 [[items]]
 section = "merge"
 name = "followcopies"
 default = true
 
 [[items]]
 section = "merge"
 name = "on-failure"
 default = "continue"
 
 [[items]]
 section = "merge"
 name = "preferancestor"
 default-type = "lambda"
 default = ["*"]
 experimental = true
 
 [[items]]
 section = "merge"
 name = "strict-capability-check"
 default = false
 
 [[items]]
 section = "merge-tools"
 name = ".*"
 generic = true
 
 [[items]]
 section = "merge-tools"
 name = '.*\.args$'
 default = "$local $base $other"
 generic = true
 priority = -1
 
 [[items]]
 section = "merge-tools"
 name = '.*\.binary$'
 default = false
 generic = true
 priority = -1
 
 [[items]]
 section = "merge-tools"
 name = '.*\.check$'
 default-type = "list_type"
 generic = true
 priority = -1
 
 [[items]]
 section = "merge-tools"
 name = '.*\.checkchanged$'
 default = false
 generic = true
 priority = -1
 
 [[items]]
 section = "merge-tools"
 name = '.*\.executable$'
 default-type = "dynamic"
 generic = true
 priority = -1
 
 [[items]]
 section = "merge-tools"
 name = '.*\.fixeol$'
 default = false
 generic = true
 priority = -1
 
 [[items]]
 section = "merge-tools"
 name = '.*\.gui$'
 default = false
 generic = true
 priority = -1
 
 [[items]]
 section = "merge-tools"
 name = '.*\.mergemarkers$'
 default = "basic"
 generic = true
 priority = -1
 
 [[items]]
 section = "merge-tools"
 name = '.*\.mergemarkertemplate$'  # take from command-templates.mergemarker
 default-type = "dynamic"
 generic = true
 priority = -1
 
 [[items]]
 section = "merge-tools"
 name = '.*\.premerge$'
 default-type = "dynamic"
 generic = true
 priority = -1
 
 [[items]]
 section = "merge-tools"
 name = '.*\.priority$'
 default = 0
 generic = true
 priority = -1
 
 [[items]]
 section = "merge-tools"
 name = '.*\.regappend$'
 default = ""
 generic = true
 priority = -1
 
 [[items]]
 section = "merge-tools"
 name = '.*\.symlink$'
 default = false
 generic = true
 priority = -1
 
 [[items]]
 section = "pager"
 name = "attend-.*"
 default-type = "dynamic"
 generic = true
 
 [[items]]
 section = "pager"
 name = "ignore"
 default-type = "list_type"
 
 [[items]]
 section = "pager"
 name = "pager"
 default-type = "dynamic"
 
 [[items]]
 section = "partial-merge-tools"
 name = ".*"
 generic = true
 experimental = true
 
 [[items]]
 section = "partial-merge-tools"
 name = '.*\.args'
 default = "$local $base $other"
 generic = true
 priority = -1
 experimental = true
 
 [[items]]
 section = "partial-merge-tools"
 name = '.*\.disable'
 default = false
 generic = true
 priority = -1
 experimental = true
 
 [[items]]
 section = "partial-merge-tools"
 name = '.*\.executable$'
 default-type = "dynamic"
 generic = true
 priority = -1
 experimental = true
 
 [[items]]
 section = "partial-merge-tools"
 name = '.*\.order'
 default = 0
 generic = true
 priority = -1
 experimental = true
 
 [[items]]
 section = "partial-merge-tools"
 name = '.*\.patterns'
 default-type = "dynamic"
 generic = true
 priority = -1
 experimental = true
 
 [[items]]
 section = "patch"
 name = "eol"
 default = "strict"
 
 [[items]]
 section = "patch"
 name = "fuzz"
 default = 2
 
 [[items]]
 section = "paths"
 name = "[^:]*"
 generic = true
 
 [[items]]
 section = "paths"
 name = ".*:bookmarks.mode"
 default = "default"
 generic = true
 
 [[items]]
 section = "paths"
 name = ".*:multi-urls"
 default = false
 generic = true
 
 [[items]]
 section = "paths"
 name = ".*:pulled-delta-reuse-policy"
 generic = true
 
 [[items]]
 section = "paths"
 name = ".*:pushrev"
 generic = true
 
 [[items]]
 section = "paths"
 name = ".*:pushurl"
 generic = true
 
 [[items]]
 section = "paths"
 name = "default"
 
 [[items]]
 section = "paths"
 name = "default-push"
 
 [[items]]
 section = "phases"
 name = "checksubrepos"
 default = "follow"
 
 [[items]]
 section = "phases"
 name = "new-commit"
 default = "draft"
 
 [[items]]
 section = "phases"
 name = "publish"
 default = true
 
 [[items]]
 section = "profiling"
 name = "enabled"
 default = false
 
 [[items]]
 section = "profiling"
 name = "format"
 default = "text"
 
 [[items]]
 section = "profiling"
 name = "freq"
 default = 1000
 
 [[items]]
 section = "profiling"
 name = "limit"
 default = 30
 
 [[items]]
 section = "profiling"
 name = "nested"
 default = 0
 
 [[items]]
 section = "profiling"
 name = "output"
 
 [[items]]
 section = "profiling"
 name = "showmax"
 default = 0.999
 
 [[items]]
 section = "profiling"
 name = "showmin"
 default-type = "dynamic"
 
 [[items]]
 section = "profiling"
 name = "showtime"
 default = true
 
 [[items]]
 section = "profiling"
 name = "sort"
 default = "inlinetime"
 
 [[items]]
 section = "profiling"
 name = "statformat"
 default = "hotpath"
 
 [[items]]
 section = "profiling"
 name = "time-track"
 default-type = "dynamic"
 
 [[items]]
 section = "profiling"
 name = "type"
 default = "stat"
 
 [[items]]
 section = "progress"
 name = "assume-tty"
 default = false
 
 [[items]]
 section = "progress"
 name = "changedelay"
 default = 1
 
 [[items]]
 section = "progress"
 name = "clear-complete"
 default = true
 
 [[items]]
 section = "progress"
 name = "debug"
 default = false
 
 [[items]]
 section = "progress"
 name = "delay"
 default = 3
 
 [[items]]
 section = "progress"
 name = "disable"
 default = false
 
 [[items]]
 section = "progress"
 name = "estimateinterval"
 default = 60.0
 
 [[items]]
 section = "progress"
 name = "format"
 default-type = "lambda"
 default = [ "topic", "bar", "number", "estimate",]
 
 [[items]]
 section = "progress"
 name = "refresh"
 default = 0.1
 
 [[items]]
 section = "progress"
 name = "width"
 default-type = "dynamic"
 
 [[items]]
 section = "pull"
 name = "confirm"
 default = false
 
 [[items]]
 section = "push"
 name = "pushvars.server"
 default = false
 
 [[items]]
 section = "rebase"
 name = "experimental.inmemory"
 default = false
 
 [[items]]
 section = "rebase"
 name = "singletransaction"
 default = false
 
 [[items]]
 section = "rebase"
 name = "store-source"
 default = true
 experimental = true
 documentation = """Controls creation of a `rebase_source` extra field during rebase.
 When false, no such field is created. This is useful e.g. for incrementally \
 converting changesets and then rebasing them onto an existing repo.
 WARNING: this is an advanced setting reserved for people who know \
 exactly what they are doing. Misuse of this setting can easily \
 result in obsmarker cycles and a vivid headache."""
 
 [[items]]
 section = "rewrite"
 name = "backup-bundle"
 default = true
 alias = [["ui", "history-editing-backup"]]
 
 [[items]]
 section = "rewrite"
 name = "empty-successor"
 default = "skip"
 experimental = true
 
 [[items]]
 section = "rewrite"
 name = "update-timestamp"
 default = false
 
 [[items]]
 section = "rhg"
 name = "cat"
 default = true
 experimental = true
 documentation = """rhg cat has some quirks that need to be ironed out. \
 In particular, the `-r` argument accepts a partial hash, but does not \
 correctly resolve `abcdef` as a potential bookmark, tag or branch name."""
 
 [[items]]
 section = "rhg"
 name = "fallback-exectutable"
 experimental = true
 
 [[items]]
 section = "rhg"
 name = "fallback-immediately"
 default = false
 experimental = true
 
 [[items]]
 section = "rhg"
 name = "ignored-extensions"
 default-type = "list_type"
 experimental = true
 
 [[items]]
 section = "rhg"
 name = "on-unsupported"
 default = "abort"
 experimental = true
 
 [[items]]
 section = "server"
 name = "bookmarks-pushkey-compat"
 default = true
 
 [[items]]
 section = "server"
 name = "bundle1"
 default = true
 
 [[items]]
 section = "server"
 name = "bundle1.pull"
 
 [[items]]
 section = "server"
 name = "bundle1.push"
 
 [[items]]
 section = "server"
 name = "bundle1gd"
 
 [[items]]
 section = "server"
 name = "bundle1gd.pull"
 
 [[items]]
 section = "server"
 name = "bundle1gd.push"
 
 [[items]]
 section = "server"
 name = "bundle2.stream"
 default = true
 alias = [["experimental", "bundle2.stream"]]
 
 [[items]]
 section = "server"
 name = "compressionengines"
 default-type = "list_type"
 
 [[items]]
 section = "server"
 name = "concurrent-push-mode"
 default = "check-related"
 
 [[items]]
 section = "server"
 name = "disablefullbundle"
 default = false
 
 [[items]]
 section = "server"
 name = "maxhttpheaderlen"
 default = 1024
 
 [[items]]
 section = "server"
 name = "preferuncompressed"
 default = false
 
 [[items]]
 section = "server"
 name = "pullbundle"
 default = true
 
 [[items]]
 section = "server"
 name = "streamunbundle"
 default = false
 
 [[items]]
 section = "server"
 name = "uncompressed"
 default = true
 
 [[items]]
 section = "server"
 name = "uncompressedallowsecret"
 default = false
 
 [[items]]
 section = "server"
 name = "validate"
 default = false
 
 [[items]]
 section = "server"
 name = "view"
 default = "served"
 
 [[items]]
 section = "server"
 name = "zliblevel"
 default = -1
 
 [[items]]
 section = "server"
 name = "zstdlevel"
 default = 3
 
 [[items]]
 section = "share"
 name = "pool"
 
 [[items]]
 section = "share"
 name = "poolnaming"
 default = "identity"
 
 [[items]]
 section = "share"
 name = "safe-mismatch.source-not-safe"
 default = "abort"
 
 [[items]]
 section = "share"
 name = "safe-mismatch.source-not-safe.warn"
 default = true
 
 [[items]]
 section = "share"
 name = "safe-mismatch.source-not-safe:verbose-upgrade"
 default = true
 
 [[items]]
 section = "share"
 name = "safe-mismatch.source-safe"
 default = "abort"
 
 [[items]]
 section = "share"
 name = "safe-mismatch.source-safe.warn"
 default = true
 
 [[items]]
 section = "share"
 name = "safe-mismatch.source-safe:verbose-upgrade"
 default = true
 
 [[items]]
 section = "shelve"
 name = "maxbackups"
 default = 10
 
 [[items]]
 section = "shelve"
 name = "store"
 default = "internal"
 experimental = true
 
 [[items]]
 section = "smtp"
 name = "host"
 
 [[items]]
 section = "smtp"
 name = "local_hostname"
 
 [[items]]
 section = "smtp"
 name = "password"
 
 [[items]]
 section = "smtp"
 name = "port"
 default-type = "dynamic"
 
 [[items]]
 section = "smtp"
 name = "tls"
 default = "none"
 
 [[items]]
 section = "smtp"
 name = "username"
 
 [[items]]
 section = "sparse"
 name = "missingwarning"
 default = true
 experimental = true
 
 [[items]]
 section = "storage"
 name = "dirstate-v2.slow-path"
 default = "abort"
 experimental = true  # experimental as long as format.use-dirstate-v2 is.
 
 [[items]]
 section = "storage"
 name = "new-repo-backend"
 default = "revlogv1"
 experimental = true
 
 [[items]]
 section = "storage"
 name = "revlog.delta-parent-search.candidate-group-chunk-size"
 default = 20
 
 [[items]]
 section = "storage"
 name = "revlog.issue6528.fix-incoming"
 default = true
 
 [[items]]
 section = "storage"
 name = "revlog.optimize-delta-parent-choice"
 default = true
 alias = [["format", "aggressivemergedeltas"]]
 
 [[items]]
 section = "storage"
 name = "revlog.persistent-nodemap.mmap"
 default = true
 
 [[items]]
 section = "storage"
 name = "revlog.persistent-nodemap.slow-path"
 default = "abort"
 
 [[items]]
 section = "storage"
 name = "revlog.reuse-external-delta"
 default = true
 
 [[items]]
 section = "storage"
 name = "revlog.reuse-external-delta-parent"
 documentation = """This option is true unless `format.generaldelta` is set."""
 
 [[items]]
 section = "storage"
 name = "revlog.zlib.level"
 
 [[items]]
 section = "storage"
 name = "revlog.zstd.level"
 
 [[items]]
 section = "subrepos"
 name = "allowed"
 default-type = "dynamic"  # to make backporting simpler
 
 [[items]]
 section = "subrepos"
 name = "git:allowed"
 default-type = "dynamic"
 
 [[items]]
 section = "subrepos"
 name = "hg:allowed"
 default-type = "dynamic"
 
 [[items]]
 section = "subrepos"
 name = "svn:allowed"
 default-type = "dynamic"
 
 [[items]]
 section = "templateconfig"
 name = ".*"
 default-type = "dynamic"
 generic = true
 
 [[items]]
 section = "templates"
 name = ".*"
 generic = true
 
 [[items]]
 section = "trusted"
 name = "groups"
 default-type = "list_type"
 
 [[items]]
 section = "trusted"
 name = "users"
 default-type = "list_type"
 
 [[items]]
 section = "ui"
 name = "_usedassubrepo"
 default = false
 
 [[items]]
 section = "ui"
 name = "allowemptycommit"
 default = false
 
 [[items]]
 section = "ui"
 name = "archivemeta"
 default = true
 
 [[items]]
 section = "ui"
 name = "askusername"
 default = false
 
 [[items]]
 section = "ui"
 name = "available-memory"
 
 [[items]]
 section = "ui"
 name = "clonebundlefallback"
 default = false
 
 [[items]]
 section = "ui"
 name = "clonebundleprefers"
 default-type = "list_type"
 
 [[items]]
 section = "ui"
 name = "clonebundles"
 default = true
 
 [[items]]
 section = "ui"
 name = "color"
 default = "auto"
 
 [[items]]
 section = "ui"
 name = "commitsubrepos"
 default = false
 
 [[items]]
 section = "ui"
 name = "debug"
 default = false
 
 [[items]]
 section = "ui"
 name = "debugger"
 
 [[items]]
 section = "ui"
 name = "detailed-exit-code"
 default = false
 experimental = true
 
 [[items]]
 section = "ui"
 name = "editor"
 default-type = "dynamic"
 
 [[items]]
 section = "ui"
 name = "fallbackencoding"
 
 [[items]]
 section = "ui"
 name = "forcecwd"
 
 [[items]]
 section = "ui"
 name = "forcemerge"
 
 [[items]]
 section = "ui"
 name = "formatdebug"
 default = false
 
 [[items]]
 section = "ui"
 name = "formatjson"
 default = false
 
 [[items]]
 section = "ui"
 name = "formatted"
 
 [[items]]
 section = "ui"
 name = "interactive"
 
 [[items]]
 section = "ui"
 name = "interface"
 
 [[items]]
 section = "ui"
 name = "interface.chunkselector"
 
 [[items]]
 section = "ui"
 name = "large-file-limit"
 default = 10485760
 
 [[items]]
 section = "ui"
 name = "logblockedtimes"
 default = false
 
 [[items]]
 section = "ui"
 name = "merge"
 
 [[items]]
 section = "ui"
 name = "mergemarkers"
 default = "basic"
 
 [[items]]
 section = "ui"
 name = "message-output"
 default = "stdio"
 
 [[items]]
 section = "ui"
 name = "nontty"
 default = false
 
 [[items]]
 section = "ui"
 name = "origbackuppath"
 
 [[items]]
 section = "ui"
 name = "paginate"
 default = true
 
 [[items]]
 section = "ui"
 name = "patch"
 
 [[items]]
 section = "ui"
 name = "portablefilenames"
 default = "warn"
 
 [[items]]
 section = "ui"
 name = "promptecho"
 default = false
 
 [[items]]
 section = "ui"
 name = "quiet"
 default = false
 
 [[items]]
 section = "ui"
 name = "quietbookmarkmove"
 default = false
 
 [[items]]
 section = "ui"
 name = "relative-paths"
 default = "legacy"
 
 [[items]]
 section = "ui"
 name = "remotecmd"
 default = "hg"
 
 [[items]]
 section = "ui"
 name = "report_untrusted"
 default = true
 
 [[items]]
 section = "ui"
 name = "rollback"
 default = true
 
 [[items]]
 section = "ui"
 name = "signal-safe-lock"
 default = true
 
 [[items]]
 section = "ui"
 name = "slash"
 default = false
 
 [[items]]
 section = "ui"
 name = "ssh"
 default = "ssh"
 
 [[items]]
 section = "ui"
 name = "ssherrorhint"
 
 [[items]]
 section = "ui"
 name = "statuscopies"
 default = false
 
 [[items]]
 section = "ui"
 name = "strict"
 default = false
 
 [[items]]
 section = "ui"
 name = "style"
 default = ""
 
 [[items]]
 section = "ui"
 name = "supportcontact"
 
 [[items]]
 section = "ui"
 name = "textwidth"
 default = 78
 
 [[items]]
 section = "ui"
 name = "timeout"
 default = "600"
 
 [[items]]
 section = "ui"
 name = "timeout.warn"
 default = 0
 
 [[items]]
 section = "ui"
 name = "timestamp-output"
 default = false
 
 [[items]]
 section = "ui"
 name = "traceback"
 default = false
 
 [[items]]
 section = "ui"
 name = "tweakdefaults"
 default = false
 
 [[items]]
 section = "ui"
 name = "username"
 alias = [["ui", "user"]]
 
 [[items]]
 section = "ui"
 name = "verbose"
 default = false
 
 [[items]]
 section = "usage"
 name = "repository-role"
 default = "default"
 documentation = """What this repository is used for.
 
 This is used to adjust behavior and performance to best fit the repository purpose.
 
 Currently recognised values are:
 - default: an all purpose repository
 """
 
 [[items]]
 section = "usage"
 name = "resources"
 default = "default"
 documentation = """How aggressive Mercurial can be with resource usage:
 
 Currently recognised values are:
 - default: the default value currently is equivalent to medium,
 - high:    allows for higher cpu, memory and disk-space usage to improve the performance of some operations.
 - medium:  aims at a moderate resource usage,
 - low:     reduces resources usage when possible, decreasing overall performance.
 
 For finer configuration, see also `usage.resources.cpu`,
 `usage.resources.disk` and `usage.resources.memory`.
 """
 
 [[items]]
 section = "usage"
 name = "resources.cpu"
 default = "default"
 documentation = """How aggressive Mercurial can be in terms of cpu usage:
 
 Currently recognised values are:
 - default: the default value, inherits the value from `usage.resources`,
 - high:    allows for more aggressive cpu usage, improving storage quality and
            the performance of some operations at the expense of machine load
 - medium:  aims at a moderate cpu usage,
 - low:     reduces cpu usage when possible, potentially at the expense of
            slower operations, increased storage and exchange payload.
 
 """
 
 [[items]]
 section = "usage"
 name = "resources.disk"
 default = "default"
 documentation = """How aggressive Mercurial can be in terms of disk usage:
 
 Currently recognised values are:
 - default: the default value, inherits the value from `usage.resources`,
 - high:    allows for more disk space usage where it can improve the performance,
 - medium:  aims at a moderate disk usage,
 - low:     reduces disk usage when possible, decreasing performance in some occasion.
 """
 
 [[items]]
 section = "usage"
 name = "resources.memory"
 default = "default"
 documentation = """How aggressive Mercurial can be in terms of memory usage:
 
 Currently recognised values are:
 - default: the default value, inherits the value from `usage.resources`,
 - high:    allows for more aggressive memory usage to improve overall performance,
 - medium:  aims at a moderate memory usage,
 - low:     reduces memory usage when possible at the cost of overall performance.
 """
 
 [[items]]
 section = "verify"
 name = "skipflags"
 default = 0
 
 [[items]]
 section = "web"
 name = "accesslog"
 default = "-"
 
 [[items]]
 section = "web"
 name = "address"
 default = ""
 
 [[items]]
 section = "web"
 name = "allow-archive"
 default-type = "list_type"
 alias = [["web", "allow_archive"]]
 
 [[items]]
 section = "web"
 name = "allow-pull"
 default = true
 alias = [["web", "allowpull"]]
 
 [[items]]
 section = "web"
 name = "allow-push"
 default-type = "list_type"
 alias = [["web", "allow_push"]]
 
 [[items]]
 section = "web"
 name = "allow_read"
 default-type = "list_type"
 
 [[items]]
 section = "web"
 name = "allowbz2"
 default = false
 
 [[items]]
 section = "web"
 name = "allowgz"
 default = false
 
 [[items]]
 section = "web"
 name = "allowzip"
 default = false
 
 [[items]]
 section = "web"
 name = "archivesubrepos"
 default = false
 
 [[items]]
 section = "web"
 name = "baseurl"
 
 [[items]]
 section = "web"
 name = "cacerts"
 
 [[items]]
 section = "web"
 name = "cache"
 default = true
 
 [[items]]
 section = "web"
 name = "certificate"
 
 [[items]]
 section = "web"
 name = "collapse"
 default = false
 
 [[items]]
 section = "web"
 name = "comparisoncontext"
 default = 5
 
 [[items]]
 section = "web"
 name = "contact"
 
 [[items]]
 section = "web"
 name = "csp"
 
 [[items]]
 section = "web"
 name = "deny_push"
 default-type = "list_type"
 
 [[items]]
 section = "web"
 name = "deny_read"
 default-type = "list_type"
 
 [[items]]
 section = "web"
 name = "descend"
 default = true
 
 [[items]]
 section = "web"
 name = "description"
 default = ""
 
 [[items]]
 section = "web"
 name = "encoding"
 default-type = "lazy_module"
 default = "encoding.encoding"
 
 [[items]]
 section = "web"
 name = "errorlog"
 default = "-"
 
 [[items]]
 section = "web"
 name = "guessmime"
 default = false
 
 [[items]]
 section = "web"
 name = "hidden"
 default = false
 
 [[items]]
 section = "web"
 name = "ipv6"
 default = false
 
 [[items]]
 section = "web"
 name = "labels"
 default-type = "list_type"
 
 [[items]]
 section = "web"
 name = "logoimg"
 default = "hglogo.png"
 
 [[items]]
 section = "web"
 name = "logourl"
 default = "https://mercurial-scm.org/"
 
 [[items]]
 section = "web"
 name = "maxchanges"
 default = 10
 
 [[items]]
 section = "web"
 name = "maxfiles"
 default = 10
 
 [[items]]
 section = "web"
 name = "maxshortchanges"
 default = 60
 
 [[items]]
 section = "web"
 name = "motd"
 default = ""
 
 [[items]]
 section = "web"
 name = "name"
 default-type = "dynamic"
 
 [[items]]
 section = "web"
 name = "port"
 default = 8000
 
 [[items]]
 section = "web"
 name = "prefix"
 default = ""
 
 [[items]]
 section = "web"
 name = "push_ssl"
 default = true
 
 [[items]]
 section = "web"
 name = "refreshinterval"
 default = 20
 
 [[items]]
 section = "web"
 name = "server-header"
 
 [[items]]
 section = "web"
 name = "static"
 
 [[items]]
 section = "web"
 name = "staticurl"
 
 [[items]]
 section = "web"
 name = "stripes"
 default = 1
 
 [[items]]
 section = "web"
 name = "style"
 default = "paper"
 
 [[items]]
 section = "web"
 name = "templates"
 
 [[items]]
 section = "web"
 name = "view"
 default = "served"
 experimental = true
 
 [[items]]
 section = "worker"
 name = "backgroundclose"
 default-type = "dynamic"
 
 [[items]]
 section = "worker"
 name = "backgroundclosemaxqueue"
 # Windows defaults to a limit of 512 open files. A buffer of 128
 # should give us enough headway.
 default = 384
 
 [[items]]
 section = "worker"
 name = "backgroundcloseminfilecount"
 default = 2048
 
 [[items]]
 section = "worker"
 name = "backgroundclosethreadcount"
 default = 4
 
 [[items]]
 section = "worker"
 name = "enabled"
 default = true
 
 [[items]]
 section = "worker"
 name = "numcpus"
 
 # Templates and template applications
 
 [[template-applications]]
 template = "diff-options"
 section = "annotate"
 
 [[template-applications]]
 template = "diff-options"
 section = "commands"
 prefix = "commit.interactive"
 
 [[template-applications]]
 template = "diff-options"
 section = "commands"
 prefix = "revert.interactive"
 
 [[template-applications]]
 template = "diff-options"
 section = "diff"
 
 [templates]
 [[templates.diff-options]]
 suffix = "nodates"
 default = false
 
 [[templates.diff-options]]
 suffix = "showfunc"
 default = false
 
 [[templates.diff-options]]
 suffix = "unified"
 
 [[templates.diff-options]]
 suffix = "git"
 default = false
 
 [[templates.diff-options]]
 suffix = "ignorews"
 default = false
 
 [[templates.diff-options]]
 suffix = "ignorewsamount"
 default = false
 
 [[templates.diff-options]]
 suffix = "ignoreblanklines"
 default = false
 
 [[templates.diff-options]]
 suffix = "ignorewseol"
 default = false
 
 [[templates.diff-options]]
 suffix = "nobinary"
 default = false
 
 [[templates.diff-options]]
 suffix = "noprefix"
 default = false
 
 [[templates.diff-options]]
 suffix = "word-diff"
 default = false
 
 # In-core extensions
 
 [[items]]
 section = "blackbox"
 name = "debug.to-stderr"
 default = false
 in_core_extension = "blackbox"
 
 [[items]]
 section = "blackbox"
 name = "dirty"
 default = false
 in_core_extension = "blackbox"
 
 [[items]]
 section = "blackbox"
 name = "maxsize"
 default = "1 MB"
 in_core_extension = "blackbox"
 
 [[items]]
 section = "blackbox"
 name = "logsource"
 default = false
 in_core_extension = "blackbox"
 
 [[items]]
 section = "blackbox"
 name = "maxfiles"
 default = 7
 in_core_extension = "blackbox"
 
 [[items]]
 section = "blackbox"
 name = "track"
 default-type = "lambda"
 default = ["*"]
 in_core_extension = "blackbox"
 
 [[items]]
 section = "blackbox"
 name = "ignore"
 default-type = "lambda"
 default = ["chgserver", "cmdserver", "extension"]
 in_core_extension = "blackbox"
 
 [[items]]
 section = "blackbox"
 name = "date-format"
 default = ""
 in_core_extension = "blackbox"
+
+[[items]]
+section = "format"
+name = "mmap-revbranchcache"
+default = false

tests/test-branches.t

@@ -1,1364 +1,1366 b''
+#testcases mmap nommap
+
+#if mmap
+  $ cat <<EOF >> $HGRCPATH
+  > [format]
+  > mmap-revbranchcache=true
+  > 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 13
   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 --hexdump .hg/cache/rbc-*
   .hg/cache/rbc-names-v1: size=111
   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 00 69 2d 77 |ranches.m.md.i-w|
   0060: 69 6c 6c 2d 72 65 67 72 65 74 2d 74 68 69 73    |ill-regret-this|
   .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 |.........!......|
 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 --hexdump .hg/cache/rbc-*
   .hg/cache/rbc-names-v1: size=84
   0000: 62 00 61 00 63 00 61 20 62 72 61 6e 63 68 20 6e |b.a.c.a branch n|
   0010: 61 6d 65 20 6d 75 63 68 20 6c 6f 6e 67 65 72 20 |ame much longer |
   0020: 74 68 61 6e 20 74 68 65 20 64 65 66 61 75 6c 74 |than the default|
   0030: 20 6a 75 73 74 69 66 69 63 61 74 69 6f 6e 20 75 | justification u|
   0040: 73 65 64 20 62 79 20 62 72 61 6e 63 68 65 73 00 |sed by branches.|
   0050: 6d 00 6d 64                                     |m.md|
   .hg/cache/rbc-revs-v1: size=152
   0000: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |................|
   0010: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |................|
   0020: 00 00 00 00 00 00 00 00 d8 cb c6 1d 00 00 00 01 |................|
   0030: 58 97 36 a2 00 00 00 02 10 ff 58 95 00 00 00 03 |X.6.......X.....|
   0040: ee bb 94 44 00 00 00 00 5f 40 61 bb 00 00 00 00 |...D...._@a.....|
   0050: bf be 84 1b 00 00 00 00 d3 f1 63 45 80 00 00 00 |..........cE....|
   0060: e3 d4 9c 05 80 00 00 00 e2 3b 55 05 00 00 00 00 |.........;U.....|
   0070: f8 94 c2 56 80 00 00 02 f3 44 76 37 00 00 00 04 |...V.....Dv7....|
   0080: a5 8c a5 d3 00 00 00 04 df 34 3b 0d 00 00 00 04 |.........4;.....|
   0090: c9 14 c9 9f 00 00 00 05                         |........|
 
 Test that cache files are created and grows correctly:
 
   $ rm .hg/cache/rbc*
   $ hg log -r "5 & branch(5)" -T "{rev}\n"
   5
   $ f --size --hexdump .hg/cache/rbc-*
   .hg/cache/rbc-names-v1: size=1
   0000: 61                                              |a|
-  .hg/cache/rbc-revs-v1: size=152
+  .hg/cache/rbc-revs-v1: size=48
   0000: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |................|
   0010: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |................|
   0020: 00 00 00 00 00 00 00 00 d8 cb c6 1d 00 00 00 00 |................|
-  0030: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |................|
-  0040: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |................|
-  0050: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |................|
-  0060: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |................|
-  0070: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |................|
-  0080: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 |................|
-  0090: 00 00 00 00 00 00 00 00                         |........|
 
   $ 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
 
   $ f --size --hexdump .hg/cache/rbc-*
   .hg/cache/rbc-names-v1: size=14
   0000: 64 65 66 61 75 6c 74 00 62 72 61 6e 63 68       |default.branch|
   .hg/cache/rbc-revs-v1: size=24
   0000: 66 e5 f5 aa 00 00 00 00 fa 4c 04 e5 00 00 00 00 |f........L......|
   0010: 56 46 78 69 00 00 00 01                         |VFxi....|
   $ : > .hg/cache/rbc-revs-v1
 
 No superfluous rebuilding of cache:
   $ hg log -r "branch(null)&branch(branch)" --debug
   $ f --size --hexdump .hg/cache/rbc-*
   .hg/cache/rbc-names-v1: size=14
   0000: 64 65 66 61 75 6c 74 00 62 72 61 6e 63 68       |default.branch|
   .hg/cache/rbc-revs-v1: size=24
   0000: 66 e5 f5 aa 00 00 00 00 fa 4c 04 e5 00 00 00 00 |f........L......|
   0010: 56 46 78 69 00 00 00 01                         |VFxi....|
 
   $ 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
   $ cat branchmap-update-01/.hg/cache/branch2-served
   99ba08759bc7f6fdbe5304e83d0387f35c082479 1
   99ba08759bc7f6fdbe5304e83d0387f35c082479 o A
   $ 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)
   $ cat branchmap-update-01/.hg/cache/branch2-served
   71ca9a6d524ed3c2a215119b2086ac3b8c4c8286 3
   71ca9a6d524ed3c2a215119b2086ac3b8c4c8286 o A
 
 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
 
   $ cat branchmap-update-02/.hg/cache/branch2-served
   99ba08759bc7f6fdbe5304e83d0387f35c082479 1
   99ba08759bc7f6fdbe5304e83d0387f35c082479 o A
   $ 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]
   $ cat branchmap-update-02/.hg/cache/branch2-served
   99ba08759bc7f6fdbe5304e83d0387f35c082479 1
   99ba08759bc7f6fdbe5304e83d0387f35c082479 o A